From b9aad1f15dc600e4dbe4c62d3fcced6363188ba3 Mon Sep 17 00:00:00 2001 From: zautrix Date: Sat, 26 Jun 2004 19:01:18 +0000 Subject: Initial revision --- (limited to 'libkcal') diff --git a/libkcal/alarm.cpp b/libkcal/alarm.cpp new file mode 100644 index 0000000..07812c2 --- a/dev/null +++ b/libkcal/alarm.cpp @@ -0,0 +1,407 @@ +/* + This file is part of libkcal. + Copyright (c) 1998 Preston Brown + Copyright (c) 2001 Cornelius Schumacher + + 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 + +#include "incidence.h" +#include "todo.h" + +#include "alarm.h" + +using namespace KCal; +#include +Alarm::Alarm(Incidence *parent) + : mParent(parent), + mType(Audio), + mDescription(""), // to make operator==() not fail + mFile(""), // to make operator==() not fail + mMailSubject(""), // to make operator==() not fail + mAlarmSnoozeTime(5), + mAlarmRepeatCount(0), + mEndOffset(false), + mHasTime(false), + mAlarmEnabled(false) +{ + +} + +Alarm::~Alarm() +{ +} + +bool Alarm::operator==( const Alarm& rhs ) const +{ + if ( mType != rhs.mType || + mAlarmSnoozeTime != rhs.mAlarmSnoozeTime || + mAlarmRepeatCount != rhs.mAlarmRepeatCount || + mAlarmEnabled != rhs.mAlarmEnabled || + mHasTime != rhs.mHasTime) + return false; + + if (mHasTime) { + if (mAlarmTime != rhs.mAlarmTime) + return false; + } else { + if (mOffset != rhs.mOffset || + mEndOffset != rhs.mEndOffset) + return false; + } + + switch (mType) { + case Display: + return mDescription == rhs.mDescription; + + case Email: + return mDescription == rhs.mDescription && + mMailAttachFiles == rhs.mMailAttachFiles && + mMailAddresses == rhs.mMailAddresses && + mMailSubject == rhs.mMailSubject; + + case Procedure: + return mFile == rhs.mFile && + mDescription == rhs.mDescription; + + case Audio: + return mFile == rhs.mFile; + + case Invalid: + break; + } + return false; +} + +void Alarm::setType(Alarm::Type type) +{ + if (type == mType) + return; + + switch (type) { + case Display: + mDescription = ""; + break; + case Procedure: + mFile = mDescription = ""; + break; + case Audio: + mFile = ""; + break; + case Email: + mMailSubject = mDescription = ""; + mMailAddresses.clear(); + mMailAttachFiles.clear(); + break; + case Invalid: + break; + default: + return; + } + mType = type; + mParent->updated(); +} + +Alarm::Type Alarm::type() const +{ + return mType; +} + +void Alarm::setAudioAlarm(const QString &audioFile) +{ + mType = Audio; + mFile = audioFile; + mParent->updated(); +} + +void Alarm::setAudioFile(const QString &audioFile) +{ + if (mType == Audio) { + mFile = audioFile; + mParent->updated(); + } +} + +QString Alarm::audioFile() const +{ + return (mType == Audio) ? mFile : QString::null; +} + +void Alarm::setProcedureAlarm(const QString &programFile, const QString &arguments) +{ + mType = Procedure; + mFile = programFile; + mDescription = arguments; + mParent->updated(); +} + +void Alarm::setProgramFile(const QString &programFile) +{ + if (mType == Procedure) { + mFile = programFile; + mParent->updated(); + } +} + +QString Alarm::programFile() const +{ + return (mType == Procedure) ? mFile : QString::null; +} + +void Alarm::setProgramArguments(const QString &arguments) +{ + if (mType == Procedure) { + mDescription = arguments; + mParent->updated(); + } +} + +QString Alarm::programArguments() const +{ + return (mType == Procedure) ? mDescription : QString::null; +} + +void Alarm::setEmailAlarm(const QString &subject, const QString &text, + const QValueList &addressees, const QStringList &attachments) +{ + mType = Email; + mMailSubject = subject; + mDescription = text; + mMailAddresses = addressees; + mMailAttachFiles = attachments; + mParent->updated(); +} + +void Alarm::setMailAddress(const Person &mailAddress) +{ + if (mType == Email) { + mMailAddresses.clear(); + mMailAddresses += mailAddress; + mParent->updated(); + } +} + +void Alarm::setMailAddresses(const QValueList &mailAddresses) +{ + if (mType == Email) { + mMailAddresses = mailAddresses; + mParent->updated(); + } +} + +void Alarm::addMailAddress(const Person &mailAddress) +{ + if (mType == Email) { + mMailAddresses += mailAddress; + mParent->updated(); + } +} + +QValueList Alarm::mailAddresses() const +{ + return (mType == Email) ? mMailAddresses : QValueList(); +} + +void Alarm::setMailSubject(const QString &mailAlarmSubject) +{ + if (mType == Email) { + mMailSubject = mailAlarmSubject; + mParent->updated(); + } +} + +QString Alarm::mailSubject() const +{ + return (mType == Email) ? mMailSubject : QString::null; +} + +void Alarm::setMailAttachment(const QString &mailAttachFile) +{ + if (mType == Email) { + mMailAttachFiles.clear(); + mMailAttachFiles += mailAttachFile; + mParent->updated(); + } +} + +void Alarm::setMailAttachments(const QStringList &mailAttachFiles) +{ + if (mType == Email) { + mMailAttachFiles = mailAttachFiles; + mParent->updated(); + } +} + +void Alarm::addMailAttachment(const QString &mailAttachFile) +{ + if (mType == Email) { + mMailAttachFiles += mailAttachFile; + mParent->updated(); + } +} + +QStringList Alarm::mailAttachments() const +{ + return (mType == Email) ? mMailAttachFiles : QStringList(); +} + +void Alarm::setMailText(const QString &text) +{ + if (mType == Email) { + mDescription = text; + mParent->updated(); + } +} + +QString Alarm::mailText() const +{ + return (mType == Email) ? mDescription : QString::null; +} + +void Alarm::setDisplayAlarm(const QString &text) +{ + mType = Display; + mDescription = text; + mParent->updated(); +} + +void Alarm::setText(const QString &text) +{ + if (mType == Display) { + mDescription = text; + mParent->updated(); + } +} + +QString Alarm::text() const +{ + return (mType == Display) ? mDescription : QString::null; +} + +void Alarm::setTime(const QDateTime &alarmTime) +{ + mAlarmTime = alarmTime; + mHasTime = true; + + mParent->updated(); +} + +QDateTime Alarm::time() const +{ + if ( hasTime() ) + return mAlarmTime; + else + { + if (mParent->type()=="Todo") { + Todo *t = static_cast(mParent); + return mOffset.end( t->dtDue() ); + } else if (mEndOffset) { + return mOffset.end( mParent->dtEnd() ); + } else { + return mOffset.end( mParent->dtStart() ); + } + } +} + +bool Alarm::hasTime() const +{ + return mHasTime; +} + +void Alarm::setSnoozeTime(int alarmSnoozeTime) +{ + mAlarmSnoozeTime = alarmSnoozeTime; + mParent->updated(); +} + +int Alarm::snoozeTime() const +{ + return mAlarmSnoozeTime; +} + +void Alarm::setRepeatCount(int alarmRepeatCount) +{ + kdDebug(5800) << "Alarm::setRepeatCount(): " << alarmRepeatCount << endl; + + mAlarmRepeatCount = alarmRepeatCount; + mParent->updated(); +} + +int Alarm::repeatCount() const +{ + kdDebug(5800) << "Alarm::repeatCount(): " << mAlarmRepeatCount << endl; + return mAlarmRepeatCount; +} + +void Alarm::toggleAlarm() +{ + mAlarmEnabled = !mAlarmEnabled; + mParent->updated(); +} + +void Alarm::setEnabled(bool enable) +{ + mAlarmEnabled = enable; + mParent->updated(); +} + +bool Alarm::enabled() const +{ + return mAlarmEnabled; +} + +void Alarm::setStartOffset( const Duration &offset ) +{ + mOffset = offset; + mEndOffset = false; + mHasTime = false; + mParent->updated(); +} + +Duration Alarm::startOffset() const +{ + return (mHasTime || mEndOffset) ? 0 : mOffset; +} + +bool Alarm::hasStartOffset() const +{ + return !mHasTime && !mEndOffset; +} + +bool Alarm::hasEndOffset() const +{ + return !mHasTime && mEndOffset; +} + +void Alarm::setEndOffset( const Duration &offset ) +{ + mOffset = offset; + mEndOffset = true; + mHasTime = false; + mParent->updated(); +} + +Duration Alarm::endOffset() const +{ + return (mHasTime || !mEndOffset) ? 0 : mOffset; +} + +void Alarm::setParent( Incidence *parent ) +{ + mParent = parent; +} diff --git a/libkcal/alarm.h b/libkcal/alarm.h new file mode 100644 index 0000000..ae2eca3 --- a/dev/null +++ b/libkcal/alarm.h @@ -0,0 +1,245 @@ +/* + This file is part of libkcal. + Copyright (c) 2001 Cornelius Schumacher + + 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_ALARM_H +#define KCAL_ALARM_H + +#include +#include + +#include "customproperties.h" +#include "duration.h" +#include "person.h" + +namespace KCal { + +class Incidence; + +/** + This class represents an alarm notification. +*/ +class Alarm : public CustomProperties +{ + public: + enum Type { Invalid, Display, Procedure, Email, Audio }; + typedef QValueList List; + + /** Construct a new alarm with variables initialized to "sane" values. */ + explicit Alarm(Incidence *parent); + /** Destruct Alarm object. */ + ~Alarm(); + + /** Compare this alarm with another one. */ + bool operator==(const Alarm &) const; + bool operator!=(const Alarm &a) const { return !operator==(a); } + + /** Set the type of the alarm. + If the specified type is different from the current type of the alarm, + the alarm's type-specific properties are initialised to null. + @param type type of alarm. + */ + void setType(Type type); + /** Return the type of the alarm */ + Type type() const; + + /** Set the alarm to be a display alarm. + @param text text to display when the alarm is triggered. + */ + void setDisplayAlarm(const QString &text); + /** Set the text to be displayed when the alarm is triggered. + Ignored if the alarm is not a display alarm. + */ + void setText(const QString &text); + /** Return the text string that displays when the alarm is triggered. */ + QString text() const; + + /** Set the alarm to be an audio alarm. + @param audioFile optional file to play when the alarm is triggered. + */ + void setAudioAlarm(const QString &audioFile = QString::null); + /** Set the file to play when the audio alarm is triggered. + Ignored if the alarm is not an audio alarm. + */ + void setAudioFile(const QString &audioFile); + /** Return the name of the audio file for the alarm. + @return The audio file for the alarm, or QString::null if not an audio alarm. + */ + QString audioFile() const; + + /** Set the alarm to be a procedure alarm. + @param programFile program to execute when the alarm is triggered. + @param arguments arguments to supply to programFile. + */ + void setProcedureAlarm(const QString &programFile, const QString &arguments = QString::null); + /** Set the program file to execute when the alarm is triggered. + Ignored if the alarm is not a procedure alarm. + */ + void setProgramFile(const QString &programFile); + /** Return the name of the program file to execute when the alarm is triggered. + @return the program file name, or QString::null if not a procedure alarm. + */ + QString programFile() const; + /** Set the arguments to the program to execute when the alarm is triggered. + Ignored if the alarm is not a procedure alarm. + */ + void setProgramArguments(const QString &arguments); + /** Return the arguments to the program to run when the alarm is triggered. + @return the program arguments, or QString::null if not a procedure alarm. + */ + QString programArguments() const; + + /** Set the alarm to be an email alarm. + @param subject subject line of email. + @param text body of email. + @param addressees email addresses of recipient(s). + @param attachments optional names of files to attach to the email. + */ + void setEmailAlarm(const QString &subject, const QString &text, const QValueList &addressees, + const QStringList &attachments = QStringList()); + + /** Send mail to this address when the alarm is triggered. + Ignored if the alarm is not an email alarm. + */ + void setMailAddress(const Person &mailAlarmAddress); + /** Send mail to these addresses when the alarm is triggered. + Ignored if the alarm is not an email alarm. + */ + void setMailAddresses(const QValueList &mailAlarmAddresses); + /** Add this address to the list of addresses to send mail to when the alarm is triggered. + Ignored if the alarm is not an email alarm. + */ + void addMailAddress(const Person &mailAlarmAddress); + /** return the addresses to send mail to when an alarm goes off */ + QValueList mailAddresses() const; + + /** Set the subject line of the mail. + Ignored if the alarm is not an email alarm. + */ + void setMailSubject(const QString &mailAlarmSubject); + /** return the subject line of the mail */ + QString mailSubject() const; + + /** Attach this filename to the email. + Ignored if the alarm is not an email alarm. + */ + void setMailAttachment(const QString &mailAttachFile); + /** Attach these filenames to the email. + Ignored if the alarm is not an email alarm. + */ + void setMailAttachments(const QStringList &mailAttachFiles); + /** Add this filename to the list of files to attach to the email. + Ignored if the alarm is not an email alarm. + */ + void addMailAttachment(const QString &mailAttachFile); + /** return the filenames to attach to the email */ + QStringList mailAttachments() const; + + /** Set the email body text. + Ignored if the alarm is not an email alarm. + */ + void setMailText(const QString &text); + /** Return the email body text. + @return the body text, or QString::null if not an email alarm. + */ + QString mailText() const; + + /** set the time to trigger an alarm */ + void setTime(const QDateTime &alarmTime); + /** return the date/time when an alarm goes off */ + QDateTime time() const; + /** Return true, if the alarm has an explicit date/time. */ + bool hasTime() const; + + /** Set offset of alarm in time relative to the start of the event. */ + void setStartOffset(const Duration &); + /** Return offset of alarm in time relative to the start of the event. + * If the alarm's time is not defined in terms of an offset relative + * to the start of the event, returns zero. + */ + Duration startOffset() const; + /** Return whether the alarm is defined in terms of an offset relative + * to the start of the event. + */ + bool hasStartOffset() const; + + /** Set offset of alarm in time relative to the end of the event. */ + void setEndOffset(const Duration &); + /** Return offset of alarm in time relative to the end of the event. + * If the alarm's time is not defined in terms of an offset relative + * to the end of the event, returns zero. + */ + Duration endOffset() const; + /** Return whether the alarm is defined in terms of an offset relative + * to the end of the event. + */ + bool hasEndOffset() const; + + /** Set the interval between snoozes for the alarm. + @param snoozeTime the time in minutes between snoozes. + */ + void setSnoozeTime(int alarmSnoozeTime); + /** Get how long the alarm snooze interval is. + @return the number of minutes between snoozes. + */ + int snoozeTime() const; + + /** set how many times an alarm is to repeat itself (w/snoozes) */ + void setRepeatCount(int alarmRepeatCount); + /** get how many times an alarm repeats */ + int repeatCount() const; + + /** toggles the value of alarm to be either on or off. + set's the alarm time to be x minutes before dtStart time. */ + void toggleAlarm(); + + /** set the alarm enabled status */ + void setEnabled(bool enable); + /** get the alarm enabled status */ + bool enabled() const; + + /** Set the alarm's parent incidence */ + void setParent( Incidence * ); + /** get the alarm's parent incidence */ + Incidence *parent() const { return mParent; } + + private: + Incidence *mParent; // the incidence which this alarm belongs to + Type mType; // type of alarm + QString mDescription; // text to display/email body/procedure arguments + QString mFile; // procedure program to run/optional audio file to play + QStringList mMailAttachFiles; // filenames to attach to email + QValueList mMailAddresses; // who to mail for reminder + QString mMailSubject; // subject of email + + int mAlarmSnoozeTime; // number of minutes after alarm to + // snooze before ringing again + int mAlarmRepeatCount; // number of times for alarm to repeat + // after the initial time + + QDateTime mAlarmTime; // time at which to trigger the alarm + Duration mOffset; // time relative to incidence DTSTART to trigger the alarm + bool mEndOffset; // if true, mOffset relates to DTEND, not DTSTART + bool mHasTime; // use mAlarmTime, not mOffset + bool mAlarmEnabled; +}; + +} + +#endif diff --git a/libkcal/attachment.cpp b/libkcal/attachment.cpp new file mode 100644 index 0000000..1ead923 --- a/dev/null +++ b/libkcal/attachment.cpp @@ -0,0 +1,86 @@ +/* + This file is part of libkcal. + Copyright (c) 2002 Michael Brade + + 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 QString& uri, const QString& mime) +{ + mMimeType = mime; + mData = uri; + mBinary = false; +} + +Attachment::Attachment(const char *base64, const QString& mime) +{ + mMimeType = mime; + mData = QString::fromUtf8(base64); + mBinary = true; +} + +bool Attachment::isURI() const +{ + return !mBinary; +} + +QString Attachment::uri() const +{ + if (!mBinary) + return mData; + else + return QString::null; +} + +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; +} + diff --git a/libkcal/attachment.h b/libkcal/attachment.h new file mode 100644 index 0000000..cdf2458 --- a/dev/null +++ b/libkcal/attachment.h @@ -0,0 +1,69 @@ +/* + This file is part of libkcal. + Copyright (c) 2002 Michael Brade + + 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 _ATTACHMENT_H +#define _ATTACHMENT_H + +#include + + +namespace KCal { + +/** + * This class represents information related to an attachment. + */ +class Attachment +{ +public: + /** + * Create a Reference to some URI. + * @param uri the uri this attachment refers to + * @param mime the mime type of the resource being linked to + */ + Attachment(const QString& uri, const QString& mime = QString::null); + + /** + * Create a binary attachment. + * @param base64 the attachment in base64 format + * @param mime the mime type of the attachment + */ + Attachment(const char *base64, const QString& mime = QString::null); + + /* The VALUE parameter in Cal */ + bool isURI() const; + QString uri() const; + void setURI(const QString& uri); + + bool isBinary() const; + char *data() const; + void setData(const char *base64); + + /* The optional FMTTYPE parameter in iCal */ + QString mimeType() const; + void setMimeType(const QString& mime); +private: + QString mMimeType; + QString mData; + bool mBinary; +}; + +} + +#endif diff --git a/libkcal/attendee.cpp b/libkcal/attendee.cpp new file mode 100644 index 0000000..41c6fcd --- a/dev/null +++ b/libkcal/attendee.cpp @@ -0,0 +1,167 @@ +/* + This file is part of libkcal. + Copyright (c) 2001 Cornelius Schumacher + + 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 + +#include +#include + +#include "attendee.h" + +using namespace KCal; + +Attendee::Attendee(const QString &name, const QString &email, bool _rsvp, Attendee::PartStat s, + Attendee::Role r,const QString &u) : + Person(name,email) +{ + mFlag = TRUE; + mRSVP = _rsvp; + mStatus = s; + mRole = r; + mUid = u; +} + +Attendee::~Attendee() +{ +} + + +bool KCal::operator==( const Attendee& a1, const Attendee& a2 ) +{ + return ( operator==( (const Person&)a1, (const Person&) a2 ) && + a1.RSVP() == a2.RSVP() && + a1.role() == a2.role() && + a1.status() == a2.status() && + a1.uid() == a2.uid() ); +} + + +void Attendee::setStatus(Attendee::PartStat s) +{ + mStatus = s; +} + +Attendee::PartStat Attendee::status() const +{ + return mStatus; +} + +QString Attendee::statusStr() const +{ + return statusName(mStatus); +} + +QString Attendee::statusName( Attendee::PartStat s ) +{ + switch (s) { + default: + case NeedsAction: + return i18n("Needs Action"); + break; + case Accepted: + return i18n("Accepted"); + break; + case Declined: + return i18n("Declined"); + break; + case Tentative: + return i18n("Tentative"); + break; + case Delegated: + return i18n("Delegated"); + break; + case Completed: + return i18n("Completed"); + break; + case InProcess: + return i18n("In Process"); + break; + } +} + +QStringList Attendee::statusList() +{ + QStringList list; + list << statusName(NeedsAction); + list << statusName(Accepted); + list << statusName(Declined); + list << statusName(Tentative); + list << statusName(Delegated); + list << statusName(Completed); + list << statusName(InProcess); + + return list; +} + + +void Attendee::setRole(Attendee::Role r) +{ + mRole = r; +} + +Attendee::Role Attendee::role() const +{ + return mRole; +} + +QString Attendee::roleStr() const +{ + return roleName(mRole); +} + +void Attendee::setUid(QString uid) +{ + mUid = uid; +} + +QString Attendee::uid() const +{ + return mUid; +} + +QString Attendee::roleName( Attendee::Role r ) +{ + switch (r) { + case Chair: + return i18n("Chair"); + break; + default: + case ReqParticipant: + return i18n("Participant"); + break; + case OptParticipant: + return i18n("Optional Participant"); + break; + case NonParticipant: + return i18n("Observer"); + break; + } +} + +QStringList Attendee::roleList() +{ + QStringList list; + list << roleName(ReqParticipant); + list << roleName(OptParticipant); + list << roleName(NonParticipant); + list << roleName(Chair); + + return list; +} diff --git a/libkcal/attendee.h b/libkcal/attendee.h new file mode 100644 index 0000000..1bd2ff3 --- a/dev/null +++ b/libkcal/attendee.h @@ -0,0 +1,96 @@ +/* + This file is part of libkcal. + Copyright (c) 2001 Cornelius Schumacher + + 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 _ATTENDEE_H +#define _ATTENDEE_H + +#include + +#include "person.h" + +namespace KCal { + +/** + This class represents information related to an attendee of an event. +*/ +class Attendee : public Person +{ + public: + enum PartStat { NeedsAction, Accepted, Declined, Tentative, + Delegated, Completed, InProcess }; + enum Role { ReqParticipant, OptParticipant, NonParticipant, Chair }; + + /** + Create Attendee. + + @param name Name + @param email Email address + @param rsvp Request for reply + @param status Status (see enum for list) + @param role Role + */ + Attendee(const QString& name, const QString &email, + bool rsvp=false, PartStat status=NeedsAction, + Role role=ReqParticipant,const QString& u=QString::null); + /** Destruct Attendee */ + virtual ~Attendee(); + + /** Set role of Attendee. List of roles still has to be documented. */ + void setRole( Role ); + /** Return role of Attendee. */ + Role role() const; + /** Return role as clear text string */ + QString roleStr() const; + static QString roleName( Role ); + static QStringList roleList(); + + /** Holds the uid of the attendee, if applicable **/ + QString uid() const; + void setUid (QString); + + /** Set status. See enum for definitions of possible values */ + void setStatus(PartStat s); + /** Return status. */ + PartStat status() const; + /** Return status as human-readable string. */ + QString statusStr() const; + static QString statusName( PartStat ); + static QStringList statusList(); + + /** Set if Attendee is asked to reply. */ + void setRSVP(bool r) { mRSVP = r; } + /** Return, if Attendee is asked to reply. */ + bool RSVP() const { return mRSVP; } + + private: + bool mRSVP; + Role mRole; + PartStat mStatus; + QString mUid; + + // used to tell whether we have need to mail this person or not. + bool mFlag; +}; + + bool operator==( const Attendee& a1, const Attendee& a2 ); + +} + +#endif diff --git a/libkcal/calendar.cpp b/libkcal/calendar.cpp new file mode 100644 index 0000000..dc198bd --- a/dev/null +++ b/libkcal/calendar.cpp @@ -0,0 +1,426 @@ +/* + This file is part of libkcal. + Copyright (c) 1998 Preston Brown + Copyright (c) 2000,2001 Cornelius Schumacher + + 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 +#include + +#include +#include +#include + +#include "exceptions.h" +#include "calfilter.h" + +#include "calendar.h" + +using namespace KCal; + +Calendar::Calendar() +{ + + init(); + setTimeZoneId( i18n (" 00:00 Europe/London(UTC)") ); +} + +Calendar::Calendar( const QString &timeZoneId ) +{ + + init(); + setTimeZoneId(timeZoneId); +} + +void Calendar::init() +{ + mObserver = 0; + mNewObserver = false; + + mModified = false; + + // Setup default filter, which does nothing + mDefaultFilter = new CalFilter; + mFilter = mDefaultFilter; + mFilter->setEnabled(false); + + // initialize random numbers. This is a hack, and not + // even that good of one at that. +// srandom(time(0)); + + // user information... + setOwner(i18n("Unknown Name")); + setEmail(i18n("unknown@nowhere")); + +#if 0 + tmpStr = KOPrefs::instance()->mTimeZone; +// kdDebug(5800) << "Calendar::Calendar(): TimeZone: " << tmpStr << endl; + int dstSetting = KOPrefs::instance()->mDaylightSavings; + extern long int timezone; + struct tm *now; + time_t curtime; + curtime = time(0); + now = localtime(&curtime); + int hourOff = - ((timezone / 60) / 60); + if (now->tm_isdst) + hourOff += 1; + QString tzStr; + tzStr.sprintf("%.2d%.2d", + hourOff, + abs((timezone / 60) % 60)); + + // if no time zone was in the config file, write what we just discovered. + if (tmpStr.isEmpty()) { +// KOPrefs::instance()->mTimeZone = tzStr; + } else { + tzStr = tmpStr; + } + + // if daylight savings has changed since last load time, we need + // to rewrite these settings to the config file. + if ((now->tm_isdst && !dstSetting) || + (!now->tm_isdst && dstSetting)) { + KOPrefs::instance()->mTimeZone = tzStr; + KOPrefs::instance()->mDaylightSavings = now->tm_isdst; + } + + setTimeZone(tzStr); +#endif + +// KOPrefs::instance()->writeConfig(); +} + +Calendar::~Calendar() +{ + delete mDefaultFilter; +} + +const QString &Calendar::getOwner() const +{ + return mOwner; +} + +void Calendar::setOwner(const QString &os) +{ + int i; + mOwner = os; + i = mOwner.find(','); + if (i != -1) + mOwner = mOwner.left(i); + + setModified( true ); +} + +void Calendar::setTimeZone(const QString & tz) +{ + bool neg = FALSE; + int hours, minutes; + QString tmpStr(tz); + + if (tmpStr.left(1) == "-") + neg = TRUE; + if (tmpStr.left(1) == "-" || tmpStr.left(1) == "+") + tmpStr.remove(0, 1); + hours = tmpStr.left(2).toInt(); + if (tmpStr.length() > 2) + minutes = tmpStr.right(2).toInt(); + else + minutes = 0; + mTimeZone = (60*hours+minutes); + if (neg) + mTimeZone = -mTimeZone; + mLocalTime = false; + + setModified( true ); +} + +QString Calendar::getTimeZoneStr() const +{ + if (mLocalTime) + return ""; + QString tmpStr; + int hours = abs(mTimeZone / 60); + int minutes = abs(mTimeZone % 60); + bool neg = mTimeZone < 0; + + tmpStr.sprintf("%c%.2d%.2d", + (neg ? '-' : '+'), + hours, minutes); + return tmpStr; +} + +void Calendar::setTimeZone(int tz) +{ + mTimeZone = tz; + mLocalTime = false; + + setModified( true ); +} + +int Calendar::getTimeZone() const +{ + return mTimeZone; +} + +void Calendar::setTimeZoneId(const QString &id) +{ + mTimeZoneId = id; + mLocalTime = false; + mTimeZone = KGlobal::locale()->timezoneOffset(mTimeZoneId); + if ( mTimeZone > 1000) + setLocalTime(); + //qDebug("Calendar::setTimeZoneOffset %s %d ",mTimeZoneId.latin1(), mTimeZone); + setModified( true ); +} + +QString Calendar::timeZoneId() const +{ + return mTimeZoneId; +} + +void Calendar::setLocalTime() +{ + //qDebug("Calendar::setLocalTime() "); + mLocalTime = true; + mTimeZone = 0; + mTimeZoneId = ""; + + setModified( true ); +} + +bool Calendar::isLocalTime() const +{ + return mLocalTime; +} + +const QString &Calendar::getEmail() +{ + return mOwnerEmail; +} + +void Calendar::setEmail(const QString &e) +{ + mOwnerEmail = e; + + setModified( true ); +} + +void Calendar::setFilter(CalFilter *filter) +{ + mFilter = filter; +} + +CalFilter *Calendar::filter() +{ + return mFilter; +} + +QPtrList Calendar::incidences() +{ + QPtrList incidences; + + Incidence *i; + + QPtrList e = events(); + for( i = e.first(); i; i = e.next() ) incidences.append( i ); + + QPtrList t = todos(); + for( i = t.first(); i; i = t.next() ) incidences.append( i ); + + QPtrList j = journals(); + for( i = j.first(); i; i = j.next() ) incidences.append( i ); + + return incidences; +} + +QPtrList Calendar::rawIncidences() +{ + QPtrList incidences; + + Incidence *i; + + QPtrList e = rawEvents(); + for( i = e.first(); i; i = e.next() ) incidences.append( i ); + + QPtrList t = rawTodos(); + for( i = t.first(); i; i = t.next() ) incidences.append( i ); + + QPtrList j = journals(); + for( i = j.first(); i; i = j.next() ) incidences.append( i ); + + return incidences; +} + +QPtrList Calendar::events( const QDate &date, bool sorted ) +{ + QPtrList el = rawEventsForDate(date,sorted); + mFilter->apply(&el); + return el; +} + +QPtrList Calendar::events( const QDateTime &qdt ) +{ + QPtrList el = rawEventsForDate(qdt); + mFilter->apply(&el); + return el; +} + +QPtrList Calendar::events( const QDate &start, const QDate &end, + bool inclusive) +{ + QPtrList el = rawEvents(start,end,inclusive); + mFilter->apply(&el); + return el; +} + +QPtrList Calendar::events() +{ + QPtrList el = rawEvents(); + mFilter->apply(&el); + return el; +} + + +bool Calendar::addIncidence(Incidence *i) +{ + Incidence::AddVisitor v(this); + + return i->accept(v); +} +void Calendar::deleteIncidence(Incidence *in) +{ + if ( in->type() == "Event" ) + deleteEvent( (Event*) in ); + else if ( in->type() =="Todo" ) + deleteTodo( (Todo*) in); + else if ( in->type() =="Journal" ) + deleteJournal( (Journal*) in ); +} + +Incidence* Calendar::incidence( const QString& uid ) +{ + Incidence* i; + + if( (i = todo( uid )) != 0 ) + return i; + if( (i = event( uid )) != 0 ) + return i; + if( (i = journal( uid )) != 0 ) + return i; + + return 0; +} + +QPtrList Calendar::todos() +{ + QPtrList tl = rawTodos(); + mFilter->apply( &tl ); + return tl; +} + +// When this is called, the todo have already been added to the calendar. +// This method is only about linking related todos +void Calendar::setupRelations( Incidence *incidence ) +{ + QString uid = incidence->uid(); + //qDebug("Calendar::setupRelations "); + // First, go over the list of orphans and see if this is their parent + while( Incidence* i = mOrphans[ uid ] ) { + mOrphans.remove( uid ); + i->setRelatedTo( incidence ); + incidence->addRelation( i ); + mOrphanUids.remove( i->uid() ); + } + + // Now see about this incidences parent + if( !incidence->relatedTo() && !incidence->relatedToUid().isEmpty() ) { + // This incidence has a uid it is related to, but is not registered to it yet + // Try to find it + Incidence* parent = this->incidence( incidence->relatedToUid() ); + if( parent ) { + // Found it + incidence->setRelatedTo( parent ); + parent->addRelation( incidence ); + } else { + // Not found, put this in the mOrphans list + mOrphans.insert( incidence->relatedToUid(), incidence ); + mOrphanUids.insert( incidence->uid(), incidence ); + } + } +} + +// If a task with subtasks is deleted, move it's subtasks to the orphans list +void Calendar::removeRelations( Incidence *incidence ) +{ + // qDebug("Calendar::removeRelations "); + QString uid = incidence->uid(); + + QPtrList relations = incidence->relations(); + for( Incidence* i = relations.first(); i; i = relations.next() ) + if( !mOrphanUids.find( i->uid() ) ) { + mOrphans.insert( uid, i ); + mOrphanUids.insert( i->uid(), i ); + i->setRelatedTo( 0 ); + i->setRelatedToUid( uid ); + } + + // If this incidence is related to something else, tell that about it + if( incidence->relatedTo() ) + incidence->relatedTo()->removeRelation( incidence ); + + // Remove this one from the orphans list + if( mOrphanUids.remove( uid ) ) + // This incidence is located in the orphans list - it should be removed + if( !( incidence->relatedTo() != 0 && mOrphans.remove( incidence->relatedTo()->uid() ) ) ) { + // Removing wasn't that easy + for( QDictIterator it( mOrphans ); it.current(); ++it ) { + if( it.current()->uid() == uid ) { + mOrphans.remove( it.currentKey() ); + break; + } + } + } +} + +void Calendar::registerObserver( Observer *observer ) +{ + mObserver = observer; + mNewObserver = true; +} + +void Calendar::setModified( bool modified ) +{ + if ( mObserver ) mObserver->calendarModified( modified, this ); + if ( modified != mModified || mNewObserver ) { + mNewObserver = false; + // if ( mObserver ) mObserver->calendarModified( modified, this ); + mModified = modified; + } +} + +void Calendar::setLoadedProductId( const QString &id ) +{ + mLoadedProductId = id; +} + +QString Calendar::loadedProductId() +{ + return mLoadedProductId; +} + +#include "calendar.moc" diff --git a/libkcal/calendar.h b/libkcal/calendar.h new file mode 100644 index 0000000..7a85e74 --- a/dev/null +++ b/libkcal/calendar.h @@ -0,0 +1,349 @@ +/* + This file is part of libkcal. + Copyright (c) 1998 Preston Brown + Copyright (c) 2001 Cornelius Schumacher + + 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 CALENDAR_H +#define CALENDAR_H + +#include +#include +#include +#include +#include + +#include "customproperties.h" +#include "event.h" +#include "todo.h" +#include "journal.h" + +#define _TIME_ZONE "-0500" /* hardcoded, overridden in config file. */ + +class KConfig; + +namespace KCal { + +class CalFilter; + +/** + This is the main "calendar" object class for KOrganizer. It holds + information like all appointments/events, user information, etc. etc. + one calendar is associated with each CalendarView (@see calendarview.h). + This is an abstract base class defining the interface to a calendar. It is + implemented by subclasses like @see CalendarLocal, which use different + methods to store and access the data. + + Ownership of events etc. is handled by the following policy: As soon as an + event (or any other subclass of IncidenceBase) object is added to the + Calendar by addEvent() it is owned by the Calendar object. The Calendar takes + care of deleting it. All Events returned by the query functions are returned + as pointers, that means all changes to the returned events are immediately + visible in the Calendar. You shouldn't delete any Event object you get from + Calendar. +*/ +class Calendar : public QObject, public CustomProperties, + public IncidenceBase::Observer +{ + Q_OBJECT +public: + Calendar(); + Calendar(const QString &timeZoneId); + virtual ~Calendar(); + void deleteIncidence(Incidence *in); + /** + Clears out the current calendar, freeing all used memory etc. + */ + virtual void close() = 0; + + /** + Sync changes in memory to persistant storage. + */ + virtual void save() = 0; + + virtual bool isSaving() { return false; } + + /** + Return the owner of the calendar's full name. + */ + const QString &getOwner() const; + /** + Set the owner of the calendar. Should be owner's full name. + */ + void setOwner( const QString &os ); + /** + Return the email address of the calendar owner. + */ + const QString &getEmail(); + /** + Set the email address of the calendar owner. + */ + void setEmail( const QString & ); + + /** + Set time zone from a timezone string (e.g. -2:00) + */ + void setTimeZone( const QString &tz ); + /** + Set time zone from a minutes value (e.g. -60) + */ + void setTimeZone( int tz ); + /** + Return time zone as offest in minutes. + */ + int getTimeZone() const; + /** + Compute an ISO 8601 format string from the time zone. + */ + QString getTimeZoneStr() const; + /** + Set time zone id (see /usr/share/zoneinfo/zone.tab for list of legal + values). + */ + void setTimeZoneId( const QString & ); + /** + Return time zone id. + */ + QString timeZoneId() const; + /** + Use local time, not UTC or a time zone. + */ + void setLocalTime(); + /** + Return whether local time is being used. + */ + bool isLocalTime() const; + + /** + Add an incidence to calendar. + + @return true on success, false on error. + */ + virtual bool addIncidence( Incidence * ); + /** + Return filtered list of all incidences of this calendar. + */ + virtual QPtrList incidences(); + + /** + Return unfiltered list of all incidences of this calendar. + */ + virtual QPtrList rawIncidences(); + + /** + Adds a Event to this calendar object. + @param anEvent a pointer to the event to add + + @return true on success, false on error. + */ + virtual bool addEventNoDup( Event *event ) = 0; + virtual bool addEvent( Event *anEvent ) = 0; + /** + Delete event from calendar. + */ + virtual void deleteEvent( Event * ) = 0; + /** + Retrieves an event on the basis of the unique string ID. + */ + virtual Event *event( const QString &UniqueStr ) = 0; + virtual Event *event( int ) = 0; + /** + Builds and then returns a list of all events that match for the + date specified. useful for dayView, etc. etc. + The calendar filter is applied. + */ + QPtrList events( const QDate &date, bool sorted = false); + /** + Get events, which occur on the given date. + The calendar filter is applied. + */ + QPtrList events( const QDateTime &qdt ); + /** + Get events in a range of dates. If inclusive is set to true, only events + are returned, which are completely included in the range. + The calendar filter is applied. + */ + QPtrList events( const QDate &start, const QDate &end, + bool inclusive = false); + /** + Return filtered list of all events in calendar. + */ + virtual QPtrList events(); + /** + Return unfiltered list of all events in calendar. + */ + virtual QPtrList rawEvents() = 0; + + /** + Add a todo to the todolist. + + @return true on success, false on error. + */ + virtual bool addTodo( Todo *todo ) = 0; + virtual bool addTodoNoDup( Todo *todo ) = 0; + /** + Remove a todo from the todolist. + */ + virtual void deleteTodo( Todo * ) = 0; + virtual void deleteJournal( Journal * ) = 0; + /** + Return filterd list of todos. + */ + virtual QPtrList todos(); + /** + Searches todolist for an event with this unique string identifier, + returns a pointer or null. + */ + virtual Todo *todo( const QString &uid ) = 0; + virtual Todo *todo( int ) = 0; + /** + Returns list of todos due on the specified date. + */ + virtual QPtrList todos( const QDate &date ) = 0; + /** + Return unfiltered list of todos. + */ + virtual QPtrList rawTodos() = 0; + + /** + Add a Journal entry to calendar. + + @return true on success, false on error. + */ + virtual bool addJournal( Journal * ) = 0; + /** + Return Journal for given date. + */ + virtual Journal *journal( const QDate & ) = 0; + /** + Return Journal with given UID. + */ + virtual Journal *journal( const QString &UID ) = 0; + /** + Return list of all Journal entries. + */ + virtual QPtrList journals() = 0; + + /** + Searches all incidence types for an incidence with this unique + string identifier, returns a pointer or null. + */ + Incidence* incidence( const QString&UID ); + + /** + Setup relations for an incidence. + */ + virtual void setupRelations( Incidence * ); + /** + Remove all relations to an incidence + */ + virtual void removeRelations( Incidence * ); + + /** + Set calendar filter, which filters events for the events() functions. + The Filter object is owned by the caller. + */ + void setFilter( CalFilter * ); + /** + Return calendar filter. + */ + CalFilter *filter(); + virtual QDateTime nextAlarm( int daysTo ) = 0; + virtual QString nextSummary( ) const = 0; + virtual void reInitAlarmSettings() = 0; + virtual QDateTime nextAlarmEventDateTime() const = 0; + virtual void checkAlarmForIncidence( Incidence *, bool ) = 0; + /** + Return all alarms, which ocur in the given time interval. + */ + virtual Alarm::List alarms( const QDateTime &from, + const QDateTime &to ) = 0; + + class Observer { + public: + virtual void calendarModified( bool, Calendar * ) = 0; + }; + + void registerObserver( Observer * ); + + void setModified( bool ); + + /** + Set product id returned by loadedProductId(). This function is only + useful for the calendar loading code. + */ + void setLoadedProductId( const QString & ); + /** + Return product id taken from file that has been loaded. Returns + QString::null, if no calendar has been loaded. + */ + QString loadedProductId(); + + signals: + void calendarChanged(); + void calendarSaved(); + void calendarLoaded(); + void addAlarm(const QDateTime &qdt, const QString ¬i ); + void removeAlarm(const QDateTime &qdt, const QString ¬i ); + + protected: + /** + Get unfiltered events, which occur on the given date. + */ + virtual QPtrList rawEventsForDate( const QDateTime &qdt ) = 0; + /** + Get unfiltered events, which occur on the given date. + */ + virtual QPtrList rawEventsForDate( const QDate &date, + bool sorted = false ) = 0; + /** + Get events in a range of dates. If inclusive is set to true, only events + are returned, which are completely included in the range. + */ + virtual QPtrList rawEvents( const QDate &start, const QDate &end, + bool inclusive = false ) = 0; + Incidence *mNextAlarmIncidence; + +private: + void init(); + + QString mOwner; // who the calendar belongs to + QString mOwnerEmail; // email address of the owner + int mTimeZone; // timezone OFFSET from GMT (MINUTES) + bool mLocalTime; // use local time, not UTC or a time zone + + CalFilter *mFilter; + CalFilter *mDefaultFilter; + + QString mTimeZoneId; + + Observer *mObserver; + bool mNewObserver; + + bool mModified; + + QString mLoadedProductId; + + // This list is used to put together related todos + QDict mOrphans; + QDict mOrphanUids; +}; + +} + +#endif diff --git a/libkcal/calendar.moc b/libkcal/calendar.moc new file mode 100644 index 0000000..e69de29 --- a/dev/null +++ b/libkcal/calendar.moc diff --git a/libkcal/calendarlocal.cpp b/libkcal/calendarlocal.cpp new file mode 100644 index 0000000..8ff8b14 --- a/dev/null +++ b/libkcal/calendarlocal.cpp @@ -0,0 +1,655 @@ +/* + This file is part of libkcal. + + Copyright (c) 1998 Preston Brown + Copyright (c) 2001,2003 Cornelius Schumacher + + 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 +#include +#include + +#include +#include +#include +#include + +#include "vcaldrag.h" +#include "vcalformat.h" +#include "icalformat.h" +#include "exceptions.h" +#include "incidence.h" +#include "journal.h" +#include "filestorage.h" +#include "calfilter.h" + +#include "calendarlocal.h" + +// #ifndef DESKTOP_VERSION +// #include +// #endif +using namespace KCal; + +CalendarLocal::CalendarLocal() + : Calendar() +{ + init(); +} + +CalendarLocal::CalendarLocal(const QString &timeZoneId) + : Calendar(timeZoneId) +{ + init(); +} + +void CalendarLocal::init() +{ + mNextAlarmIncidence = 0; +} + + +CalendarLocal::~CalendarLocal() +{ + close(); +} + +bool CalendarLocal::load( const QString &fileName ) +{ + FileStorage storage( this, fileName ); + return storage.load(); +} + +bool CalendarLocal::save( const QString &fileName, CalFormat *format ) +{ + FileStorage storage( this, fileName, format ); + return storage.save(); +} + +void CalendarLocal::close() +{ + mEventList.setAutoDelete( true ); + mTodoList.setAutoDelete( true ); + mJournalList.setAutoDelete( false ); + + mEventList.clear(); + mTodoList.clear(); + mJournalList.clear(); + + mEventList.setAutoDelete( false ); + mTodoList.setAutoDelete( false ); + mJournalList.setAutoDelete( false ); + + setModified( false ); +} +bool CalendarLocal::addEventNoDup( Event *event ) +{ + Event * eve; + for ( eve = mEventList.first(); eve ; eve = mEventList.next() ) { + if ( *eve == *event ) { + //qDebug("CalendarLocal::Duplicate event found! Not inserted! "); + return false; + } + } + return addEvent( event ); +} + +bool CalendarLocal::addEvent( Event *event ) +{ + insertEvent( event ); + + event->registerObserver( this ); + + setModified( true ); + + return true; +} + +void CalendarLocal::deleteEvent( Event *event ) +{ + + + if ( mEventList.removeRef( event ) ) { + setModified( true ); + } +} + + +Event *CalendarLocal::event( const QString &uid ) +{ + + Event *event; + + for ( event = mEventList.first(); event; event = mEventList.next() ) { + if ( event->uid() == uid ) { + return event; + } + } + + return 0; +} +bool CalendarLocal::addTodoNoDup( Todo *todo ) +{ + Todo * eve; + for ( eve = mTodoList.first(); eve ; eve = mTodoList.next() ) { + if ( *eve == *todo ) { + //qDebug("duplicate todo found! not inserted! "); + return false; + } + } + return addTodo( todo ); +} +bool CalendarLocal::addTodo( Todo *todo ) +{ + mTodoList.append( todo ); + + todo->registerObserver( this ); + + // Set up subtask relations + setupRelations( todo ); + + setModified( true ); + + return true; +} + +void CalendarLocal::deleteTodo( Todo *todo ) +{ + // Handle orphaned children + removeRelations( todo ); + + if ( mTodoList.removeRef( todo ) ) { + setModified( true ); + } +} + +QPtrList CalendarLocal::rawTodos() +{ + return mTodoList; +} +Todo *CalendarLocal::todo( int id ) +{ + Todo *todo; + for ( todo = mTodoList.first(); todo; todo = mTodoList.next() ) { + if ( todo->zaurusId() == id ) return todo; + } + + return 0; +} + +Event *CalendarLocal::event( int id ) +{ + Event *todo; + for ( todo = mEventList.first(); todo; todo = mEventList.next() ) { + if ( todo->zaurusId() == id ) return todo; + } + + return 0; +} +Todo *CalendarLocal::todo( const QString &uid ) +{ + Todo *todo; + for ( todo = mTodoList.first(); todo; todo = mTodoList.next() ) { + if ( todo->uid() == uid ) return todo; + } + + return 0; +} +QString CalendarLocal::nextSummary() const +{ + return mNextSummary; +} +QDateTime CalendarLocal::nextAlarmEventDateTime() const +{ + return mNextAlarmEventDateTime; +} +void CalendarLocal::checkAlarmForIncidence( Incidence * incidence, bool deleted) +{ + //mNextAlarmIncidence + //mNextAlarmDateTime + //return mNextSummary; + //return mNextAlarmEventDateTime; + bool newNextAlarm = false; + bool computeNextAlarm = false; + bool ok; + int offset; + QDateTime nextA; + // QString nextSum; + //QDateTime nextEvent; + if ( mNextAlarmIncidence == 0 || incidence == 0 ) { + computeNextAlarm = true; + } else { + if ( ! deleted ) { + nextA = incidence->getNextAlarmDateTime(& ok, &offset ) ; + if ( ok ) { + if ( nextA < mNextAlarmDateTime ) { + deRegisterAlarm(); + mNextAlarmDateTime = nextA; + mNextSummary = incidence->summary(); + mNextAlarmEventDateTime = nextA.addSecs(offset ) ; + mNextAlarmEventDateTimeString = KGlobal::locale()->formatDateTime(mNextAlarmEventDateTime); + newNextAlarm = true; + mNextAlarmIncidence = incidence; + } else { + if ( incidence == mNextAlarmIncidence ) { + computeNextAlarm = true; + } + } + } else { + if ( mNextAlarmIncidence == incidence ) { + computeNextAlarm = true; + } + } + } else { // deleted + if ( incidence == mNextAlarmIncidence ) { + computeNextAlarm = true; + } + } + } + if ( computeNextAlarm ) { + deRegisterAlarm(); + nextA = nextAlarm( 1000 ); + if (! mNextAlarmIncidence ) { + return; + } + newNextAlarm = true; + } + if ( newNextAlarm ) + registerAlarm(); +} +QString CalendarLocal:: getAlarmNotification() +{ + QString ret; + // this should not happen + if (! mNextAlarmIncidence ) + return "cal_alarm"+ mNextSummary.left( 25 )+"\n"+mNextAlarmEventDateTimeString; + Alarm* alarm = mNextAlarmIncidence->alarms().first(); + if ( alarm->type() == Alarm::Procedure ) { + ret = "proc_alarm" + alarm->programFile()+"+++"; + } else { + ret = "audio_alarm" +alarm->audioFile() +"+++"; + } + ret += "cal_alarm"+ mNextSummary.left( 25 ); + if ( mNextSummary.length() > 25 ) + ret += "\n" + mNextSummary.mid(25, 25 ); + ret+= "\n"+mNextAlarmEventDateTimeString; + return ret; +} + +void CalendarLocal::registerAlarm() +{ + mLastAlarmNotificationString = getAlarmNotification(); + // qDebug("++ register Alarm %s %s",mNextAlarmDateTime.toString().latin1(), mLastAlarmNotificationString.latin1() ); + emit addAlarm ( mNextAlarmDateTime, mLastAlarmNotificationString ); +// #ifndef DESKTOP_VERSION +// AlarmServer::addAlarm ( mNextAlarmDateTime,"koalarm", mLastAlarmNotificationString.latin1() ); +// #endif +} +void CalendarLocal::deRegisterAlarm() +{ + if ( mLastAlarmNotificationString.isNull() ) + return; + //qDebug("-- deregister Alarm %s ", mLastAlarmNotificationString.latin1() ); + + emit removeAlarm ( mNextAlarmDateTime, mLastAlarmNotificationString ); +// #ifndef DESKTOP_VERSION +// AlarmServer::deleteAlarm (mNextAlarmDateTime ,"koalarm" ,mLastAlarmNotificationString.latin1() ); +// #endif +} + +QPtrList CalendarLocal::todos( const QDate &date ) +{ + QPtrList todos; + + Todo *todo; + for ( todo = mTodoList.first(); todo; todo = mTodoList.next() ) { + if ( todo->hasDueDate() && todo->dtDue().date() == date ) { + todos.append( todo ); + } + } + + filter()->apply( &todos ); + return todos; +} +void CalendarLocal::reInitAlarmSettings() +{ + if ( !mNextAlarmIncidence ) { + nextAlarm( 1000 ); + } + deRegisterAlarm(); + mNextAlarmIncidence = 0; + checkAlarmForIncidence( 0, false ); + +} + + + +QDateTime CalendarLocal::nextAlarm( int daysTo ) +{ + QDateTime nextA = QDateTime::currentDateTime().addDays( daysTo ); + QDateTime start = QDateTime::currentDateTime().addSecs( 30 ); + QDateTime next; + Event *e; + bool ok; + bool found = false; + int offset; + mNextAlarmIncidence = 0; + for( e = mEventList.first(); e; e = mEventList.next() ) { + next = e->getNextAlarmDateTime(& ok, &offset ) ; + if ( ok ) { + if ( next < nextA ) { + nextA = next; + found = true; + mNextSummary = e->summary(); + mNextAlarmEventDateTime = next.addSecs(offset ) ; + mNextAlarmIncidence = (Incidence *) e; + } + } + } + Todo *t; + for( t = mTodoList.first(); t; t = mTodoList.next() ) { + next = t->getNextAlarmDateTime(& ok, &offset ) ; + if ( ok ) { + if ( next < nextA ) { + nextA = next; + found = true; + mNextSummary = t->summary(); + mNextAlarmEventDateTime = next.addSecs(offset ); + mNextAlarmIncidence = (Incidence *) t; + } + } + } + if ( mNextAlarmIncidence ) { + mNextAlarmEventDateTimeString = KGlobal::locale()->formatDateTime(mNextAlarmEventDateTime); + mNextAlarmDateTime = nextA; + } + return nextA; +} +Alarm::List CalendarLocal::alarmsTo( const QDateTime &to ) +{ + return alarms( QDateTime( QDate( 1900, 1, 1 ) ), to ); +} + +Alarm::List CalendarLocal::alarms( const QDateTime &from, const QDateTime &to ) +{ + kdDebug(5800) << "CalendarLocal::alarms(" << from.toString() << " - " + << to.toString() << ")\n"; + + Alarm::List alarms; + + Event *e; + + for( e = mEventList.first(); e; e = mEventList.next() ) { + if ( e->doesRecur() ) appendRecurringAlarms( alarms, e, from, to ); + else appendAlarms( alarms, e, from, to ); + } + + Todo *t; + for( t = mTodoList.first(); t; t = mTodoList.next() ) { + appendAlarms( alarms, t, from, to ); + } + + return alarms; +} + +void CalendarLocal::appendAlarms( Alarm::List &alarms, Incidence *incidence, + const QDateTime &from, const QDateTime &to ) +{ + QPtrList alarmList = incidence->alarms(); + Alarm *alarm; + for( alarm = alarmList.first(); alarm; alarm = alarmList.next() ) { +// kdDebug(5800) << "CalendarLocal::appendAlarms() '" << alarm->text() +// << "': " << alarm->time().toString() << " - " << alarm->enabled() << endl; + if ( alarm->enabled() ) { + if ( alarm->time() >= from && alarm->time() <= to ) { + kdDebug(5800) << "CalendarLocal::appendAlarms() '" << incidence->summary() + << "': " << alarm->time().toString() << endl; + alarms.append( alarm ); + } + } + } +} + +void CalendarLocal::appendRecurringAlarms( Alarm::List &alarms, + Incidence *incidence, + const QDateTime &from, + const QDateTime &to ) +{ + + QPtrList alarmList = incidence->alarms(); + Alarm *alarm; + QDateTime qdt; + for( alarm = alarmList.first(); alarm; alarm = alarmList.next() ) { + if (incidence->recursOn(from.date())) { + qdt.setTime(alarm->time().time()); + qdt.setDate(from.date()); + } + else qdt = alarm->time(); + // qDebug("1 %s %s %s", qdt.toString().latin1(), from.toString().latin1(), to.toString().latin1()); + if ( alarm->enabled() ) { + if ( qdt >= from && qdt <= to ) { + alarms.append( alarm ); + } + } + } +} + + +/****************************** PROTECTED METHODS ****************************/ + +// after changes are made to an event, this should be called. +void CalendarLocal::update( IncidenceBase *incidence ) +{ + incidence->setSyncStatus( Event::SYNCMOD ); + incidence->setLastModified( QDateTime::currentDateTime() ); + // we should probably update the revision number here, + // or internally in the Event itself when certain things change. + // need to verify with ical documentation. + + setModified( true ); +} + +void CalendarLocal::insertEvent( Event *event ) +{ + if ( mEventList.findRef( event ) < 0 ) mEventList.append( event ); +} + + +QPtrList CalendarLocal::rawEventsForDate( const QDate &qd, bool sorted ) +{ + QPtrList eventList; + + Event *event; + for( event = mEventList.first(); event; event = mEventList.next() ) { + if ( event->doesRecur() ) { + if ( event->isMultiDay() ) { + int extraDays = event->dtStart().date().daysTo( event->dtEnd().date() ); + int i; + for ( i = 0; i <= extraDays; i++ ) { + if ( event->recursOn( qd.addDays( -i ) ) ) { + eventList.append( event ); + break; + } + } + } else { + if ( event->recursOn( qd ) ) + eventList.append( event ); + } + } else { + if ( event->dtStart().date() <= qd && event->dtEnd().date() >= qd ) { + eventList.append( event ); + } + } + } + + if ( !sorted ) { + return eventList; + } + + // kdDebug(5800) << "Sorting events for date\n" << endl; + // now, we have to sort it based on dtStart.time() + QPtrList eventListSorted; + Event *sortEvent; + for ( event = eventList.first(); event; event = eventList.next() ) { + sortEvent = eventListSorted.first(); + int i = 0; + while ( sortEvent && event->dtStart().time()>=sortEvent->dtStart().time() ) + { + i++; + sortEvent = eventListSorted.next(); + } + eventListSorted.insert( i, event ); + } + return eventListSorted; +} + + +QPtrList CalendarLocal::rawEvents( const QDate &start, const QDate &end, + bool inclusive ) +{ + Event *event = 0; + + QPtrList eventList; + + // Get non-recurring events + for( event = mEventList.first(); event; event = mEventList.next() ) { + if ( event->doesRecur() ) { + QDate rStart = event->dtStart().date(); + bool found = false; + if ( inclusive ) { + if ( rStart >= start && rStart <= end ) { + // Start date of event is in range. Now check for end date. + // if duration is negative, event recurs forever, so do not include it. + if ( event->recurrence()->duration() == 0 ) { // End date set + QDate rEnd = event->recurrence()->endDate(); + if ( rEnd >= start && rEnd <= end ) { // End date within range + found = true; + } + } else if ( event->recurrence()->duration() > 0 ) { // Duration set + // TODO: Calculate end date from duration. Should be done in Event + // For now exclude all events with a duration. + } + } + } else { + bool founOne; + QDate next = event->getNextOccurence( start, &founOne ).date(); + if ( founOne ) { + if ( next <= end ) { + found = true; + } + } + + /* + // crap !!! + if ( rStart <= end ) { // Start date not after range + if ( rStart >= start ) { // Start date within range + found = true; + } else if ( event->recurrence()->duration() == -1 ) { // Recurs forever + found = true; + } else if ( event->recurrence()->duration() == 0 ) { // End date set + QDate rEnd = event->recurrence()->endDate(); + if ( rEnd >= start && rEnd <= end ) { // End date within range + found = true; + } + } else { // Duration set + // TODO: Calculate end date from duration. Should be done in Event + // For now include all events with a duration. + found = true; + } + } + */ + + } + + if ( found ) eventList.append( event ); + } else { + QDate s = event->dtStart().date(); + QDate e = event->dtEnd().date(); + + if ( inclusive ) { + if ( s >= start && e <= end ) { + eventList.append( event ); + } + } else { + if ( ( s >= start && s <= end ) || ( e >= start && e <= end ) ) { + eventList.append( event ); + } + } + } + } + + return eventList; +} + +QPtrList CalendarLocal::rawEventsForDate( const QDateTime &qdt ) +{ + return rawEventsForDate( qdt.date() ); +} + +QPtrList CalendarLocal::rawEvents() +{ + return mEventList; +} + +bool CalendarLocal::addJournal(Journal *journal) +{ + if ( journal->dtStart().isValid()) + kdDebug(5800) << "Adding Journal on " << journal->dtStart().toString() << endl; + else + kdDebug(5800) << "Adding Journal without a DTSTART" << endl; + + mJournalList.append(journal); + + journal->registerObserver( this ); + + setModified( true ); + + return true; +} + +void CalendarLocal::deleteJournal( Journal *journal ) +{ + if ( mJournalList.removeRef(journal) ) { + setModified( true ); + } +} + +Journal *CalendarLocal::journal( const QDate &date ) +{ +// kdDebug(5800) << "CalendarLocal::journal() " << date.toString() << endl; + + for ( Journal *it = mJournalList.first(); it; it = mJournalList.next() ) + if ( it->dtStart().date() == date ) + return it; + + return 0; +} + +Journal *CalendarLocal::journal( const QString &uid ) +{ + for ( Journal *it = mJournalList.first(); it; it = mJournalList.next() ) + if ( it->uid() == uid ) + return it; + + return 0; +} + +QPtrList CalendarLocal::journals() +{ + return mJournalList; +} + diff --git a/libkcal/calendarlocal.h b/libkcal/calendarlocal.h new file mode 100644 index 0000000..a17cf11 --- a/dev/null +++ b/libkcal/calendarlocal.h @@ -0,0 +1,216 @@ +/* + This file is part of libkcal. + + Copyright (c) 1998 Preston Brown + Copyright (c) 2001,2003 Cornelius Schumacher + + 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_CALENDARLOCAL_H +#define KCAL_CALENDARLOCAL_H + +#include "calendar.h" + +namespace KCal { + +class CalFormat; + +/** + This class provides a calendar stored as a local file. +*/ +class CalendarLocal : public Calendar +{ + public: + /** + Constructs a new calendar, with variables initialized to sane values. + */ + CalendarLocal(); + /** + Constructs a new calendar, with variables initialized to sane values. + */ + CalendarLocal( const QString &timeZoneId ); + ~CalendarLocal(); + + /** + Loads a calendar on disk in vCalendar or iCalendar format into the current + calendar. Any information already present is lost. + @return true, if successfull, false on error. + @param fileName the name of the calendar on disk. + */ + bool load( const QString &fileName ); + /** + Writes out the calendar to disk in the specified \a format. + CalendarLocal takes ownership of the CalFormat object. + @return true, if successfull, false on error. + @param fileName the name of the file + */ + bool save( const QString &fileName, CalFormat *format = 0 ); + + /** + Clears out the current calendar, freeing all used memory etc. etc. + */ + void close(); + + void save() {} + + /** + Add Event to calendar. + */ + bool addEventNoDup( Event *event ); + bool addEvent( Event *event ); + /** + Deletes an event from this calendar. + */ + void deleteEvent( Event *event ); + + /** + Retrieves an event on the basis of the unique string ID. + */ + Event *event( const QString &uid ); + /** + Return unfiltered list of all events in calendar. + */ + QPtrList rawEvents(); + + /** + Add a todo to the todolist. + */ + bool addTodo( Todo *todo ); + bool addTodoNoDup( Todo *todo ); + /** + Remove a todo from the todolist. + */ + void deleteTodo( Todo * ); + /** + Searches todolist for an event with this unique string identifier, + returns a pointer or null. + */ + Todo *todo( const QString &uid ); + /** + Return list of all todos. + */ + QPtrList rawTodos(); + /** + Returns list of todos due on the specified date. + */ + QPtrList todos( const QDate &date ); + /** + Return list of all todos. + + Workaround because compiler does not recognize function of base class. + */ + QPtrList todos() { return Calendar::todos(); } + + /** + Add a Journal entry to calendar. + */ + bool addJournal( Journal * ); + /** + Remove a Journal from the calendar. + */ + void deleteJournal( Journal * ); + /** + Return Journal for given date. + */ + Journal *journal( const QDate & ); + /** + Return Journal with given UID. + */ + Journal *journal( const QString &uid ); + /** + Return list of all Journals stored in calendar. + */ + QPtrList journals(); + + /** + Return all alarms, which ocur in the given time interval. + */ + Alarm::List alarms( const QDateTime &from, const QDateTime &to ); + + /** + Return all alarms, which ocur before given date. + */ + Alarm::List alarmsTo( const QDateTime &to ); + + QDateTime nextAlarm( int daysTo ) ; + QDateTime nextAlarmEventDateTime() const; + void checkAlarmForIncidence( Incidence *, bool deleted ) ; + void registerAlarm(); + void deRegisterAlarm(); + QString getAlarmNotification(); + QString nextSummary() const ; + /** + This method should be called whenever a Event is modified directly + via it's pointer. It makes sure that the calendar is internally + consistent. + */ + void update( IncidenceBase *incidence ); + + /** + Builds and then returns a list of all events that match for the + date specified. useful for dayView, etc. etc. + */ + QPtrList rawEventsForDate( const QDate &date, bool sorted = false ); + /** + Get unfiltered events for date \a qdt. + */ + QPtrList rawEventsForDate( const QDateTime &qdt ); + /** + Get unfiltered events in a range of dates. If inclusive is set to true, + only events are returned, which are completely included in the range. + */ + QPtrList rawEvents( const QDate &start, const QDate &end, + bool inclusive = false ); + Todo *CalendarLocal::todo( int uid ); + Event *CalendarLocal::event( int uid ); + + + + protected: + + // Event* mNextAlarmEvent; + QString mNextSummary; + QString mNextAlarmEventDateTimeString; + QString mLastAlarmNotificationString; + QDateTime mNextAlarmEventDateTime; + QDateTime mNextAlarmDateTime; + void reInitAlarmSettings(); + + /** Notification function of IncidenceBase::Observer. */ + void incidenceUpdated( IncidenceBase *i ) { update( i ); } + + /** inserts an event into its "proper place" in the calendar. */ + void insertEvent( Event *event ); + + /** Append alarms of incidence in interval to list of alarms. */ + void appendAlarms( Alarm::List &alarms, Incidence *incidence, + const QDateTime &from, const QDateTime &to ); + + /** Append alarms of recurring events in interval to list of alarms. */ + void appendRecurringAlarms( Alarm::List &alarms, Incidence *incidence, + const QDateTime &from, const QDateTime &to ); + + private: + void init(); + + QPtrList mEventList; + QPtrList mTodoList; + QPtrList mJournalList; +}; + +} + +#endif diff --git a/libkcal/calendarresources.h b/libkcal/calendarresources.h new file mode 100644 index 0000000..a218dd7 --- a/dev/null +++ b/libkcal/calendarresources.h @@ -0,0 +1,17 @@ +#ifndef MICRO_KCAL_CALENDARRESOURCES_H +#define MICRO_KCAL_CALENDARRESOURCES_H + +#include "calendar.h" +#include "resourcecalendar.h" + +namespace KCal { + +class CalendarResources : public Calendar +{ + public: + CalendarResourceManager *resourceManager() { return 0; } +}; + +} + +#endif diff --git a/libkcal/calfilter.cpp b/libkcal/calfilter.cpp new file mode 100644 index 0000000..c182db5 --- a/dev/null +++ b/libkcal/calfilter.cpp @@ -0,0 +1,201 @@ +/* + This file is part of libkcal. + Copyright (c) 2001 Cornelius Schumacher + + 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 + +#include "calfilter.h" + +using namespace KCal; + +CalFilter::CalFilter() +{ + mEnabled = true; + mCriteria = ShowPublic | ShowPrivate| ShowConfidential ; +} + +CalFilter::CalFilter(const QString &name) +{ + mName = name; + mEnabled = true; + mCriteria = ShowPublic | ShowPrivate| ShowConfidential ; +} + +CalFilter::~CalFilter() +{ +} + +void CalFilter::apply(QPtrList *eventlist) +{ + if (!mEnabled) return; + +// kdDebug(5800) << "CalFilter::apply()" << endl; + + Event *event = eventlist->first(); + while(event) { + if (!filterEvent(event)) { + eventlist->remove(); + event = eventlist->current(); + } else { + event = eventlist->next(); + } + } + +// kdDebug(5800) << "CalFilter::apply() done" << endl; +} + +// TODO: avoid duplicating apply() code +void CalFilter::apply(QPtrList *eventlist) +{ + if (!mEnabled) return; + +// kdDebug(5800) << "CalFilter::apply()" << endl; + + Todo *event = eventlist->first(); + while(event) { + if (!filterTodo(event)) { + eventlist->remove(); + event = eventlist->current(); + } else { + event = eventlist->next(); + } + } + +// kdDebug(5800) << "CalFilter::apply() done" << endl; +} + +bool CalFilter::filterEvent(Event *event) +{ +// kdDebug(5800) << "CalFilter::filterEvent(): " << event->getSummary() << endl; + + if (mCriteria & HideRecurring) { + if (event->recurrence()->doesRecur()) return false; + } + + return filterIncidence(event); +} + +bool CalFilter::filterTodo(Todo *todo) +{ +// kdDebug(5800) << "CalFilter::filterEvent(): " << event->getSummary() << endl; + + if (mCriteria & HideCompleted) { + if (todo->isCompleted()) return false; + } + + return filterIncidence(todo); +} +bool CalFilter::showCategories() +{ + return mCriteria & ShowCategories; +} +int CalFilter::getSecrecy() +{ + if ( (mCriteria & ShowPublic )) + return Incidence::SecrecyPublic; + if ( (mCriteria & ShowPrivate )) + return Incidence::SecrecyPrivate; + if ( (mCriteria & ShowConfidential )) + return Incidence::SecrecyConfidential; + return Incidence::SecrecyPublic; +} +bool CalFilter::filterIncidence(Incidence *incidence) +{ + if ( mCriteria > 7 ) { + switch (incidence->secrecy()) { + case Incidence::SecrecyPublic: + if (! (mCriteria & ShowPublic )) + return false; + break; + case Incidence::SecrecyPrivate: + if (! (mCriteria & ShowPrivate )) + return false; + break; + case Incidence::SecrecyConfidential: + if (! (mCriteria & ShowConfidential )) + return false; + break; + default: + return false; + break; + } + } + + // kdDebug(5800) << "CalFilter::filterEvent(): " << event->getSummary() << endl; + + if (mCriteria & ShowCategories) { + for (QStringList::Iterator it = mCategoryList.begin(); + it != mCategoryList.end(); ++it ) { + QStringList incidenceCategories = incidence->categories(); + for (QStringList::Iterator it2 = incidenceCategories.begin(); + it2 != incidenceCategories.end(); ++it2 ) { + if ((*it) == (*it2)) { + return true; + } + } + } + return false; + } else { + for (QStringList::Iterator it = mCategoryList.begin(); + it != mCategoryList.end(); ++it ) { + QStringList incidenceCategories = incidence->categories(); + for (QStringList::Iterator it2 = incidenceCategories.begin(); + it2 != incidenceCategories.end(); ++it2 ) { + if ((*it) == (*it2)) { + return false; + } + } + } + return true; + } + +// kdDebug(5800) << "CalFilter::filterEvent(): passed" << endl; + + return true; +} + +void CalFilter::setEnabled(bool enabled) +{ + mEnabled = enabled; +} + +bool CalFilter::isEnabled() +{ + return mEnabled; +} + +void CalFilter::setCriteria(int criteria) +{ + mCriteria = criteria; +} + +int CalFilter::criteria() +{ + return mCriteria; +} + +void CalFilter::setCategoryList(const QStringList &categoryList) +{ + mCategoryList = categoryList; +} + +QStringList CalFilter::categoryList() +{ + return mCategoryList; +} diff --git a/libkcal/calfilter.h b/libkcal/calfilter.h new file mode 100644 index 0000000..d6d4717 --- a/dev/null +++ b/libkcal/calfilter.h @@ -0,0 +1,128 @@ +/* + This file is part of libkcal. + Copyright (c) 2001 Cornelius Schumacher + + 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 _CALFILTER_H +#define _CALFILTER_H + +#include +#include + +#include "event.h" +#include "todo.h" + +namespace KCal { + +/** + Filter for calendar objects. +*/ +class CalFilter { + public: + /** Construct filter. */ + CalFilter(); + /** Construct filter with name */ + CalFilter(const QString &name); + /** Destruct filter. */ + ~CalFilter(); + + /** + Set name of filter. + */ + void setName(const QString &name) { mName = name; } + /** + Return name of filter. + */ + QString name() const { return mName; } + + /** + Apply filter to eventlist, all events not matching filter criterias are + removed from the list. + */ + void apply(QPtrList *eventlist); + + /** + Apply filter to todolist, all todos not matching filter criterias are + removed from the list. + */ + void apply(QPtrList *todolist); + + /** + Apply filter criteria on the specified event. Return true, if event passes + criteria, otherwise return false. + */ + bool filterEvent(Event *); + + /** + Apply filter criteria on the specified todo. Return true, if event passes + criteria, otherwise return false. + */ + bool filterTodo(Todo *); + + /** + Apply filter criteria on the specified incidence. Return true, if event passes + criteria, otherwise return false. + */ + bool filterIncidence(Incidence *); + + /** + Enable or disable filter. + */ + void setEnabled(bool); + /** + Return wheter the filter is enabled or not. + */ + bool isEnabled(); + bool showCategories(); + int getSecrecy(); + /** + Set list of categories, which is used for showing/hiding categories of + events. + See related functions. + */ + void setCategoryList(const QStringList &); + /** + Return category list, used for showing/hiding categories of events. + See related functions. + */ + QStringList categoryList(); + + enum { HideRecurring = 1, HideCompleted = 2, ShowCategories = 4 ,ShowPublic = 8, ShowPrivate = 16, ShowConfidential = 32 }; + + /** + Set criteria, which have to be fulfilled by events passing the filter. + */ + void setCriteria(int); + /** + Get inclusive filter criteria. + */ + int criteria(); + + private: + QString mName; + + int mCriteria; + + bool mEnabled; + + QStringList mCategoryList; +}; + +} + +#endif /* _CALFILTER_H */ diff --git a/libkcal/calformat.cpp b/libkcal/calformat.cpp new file mode 100644 index 0000000..8a3d069 --- a/dev/null +++ b/libkcal/calformat.cpp @@ -0,0 +1,98 @@ +/* + This file is part of libkcal. + Copyright (c) 2001 Cornelius Schumacher + + 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 +#include +#include + +#include "calformat.h" + +using namespace KCal; + +QString CalFormat::mApplication = QString::fromLatin1("libkcal"); +QString CalFormat::mProductId = QString::fromLatin1("-//K Desktop Environment//NONSGML libkcal 3.1//EN"); + +// An array containing the PRODID strings indexed against the calendar file format version used. +// Every time the calendar file format is changed, add an entry/entries to this list. +struct CalVersion { + int version; + QString prodId; +}; +static CalVersion prodIds[] = { + { 220, QString::fromLatin1("-//K Desktop Environment//NONSGML KOrganizer 2.2//EN") }, + { 300, QString::fromLatin1("-//K Desktop Environment//NONSGML KOrganizer 3.0//EN") }, + { 310, QString::fromLatin1("-//K Desktop Environment//NONSGML KOrganizer 3.1//EN") }, + { 0 , QString() } +}; + + +CalFormat::CalFormat() +{ + mException = 0; +} + +CalFormat::~CalFormat() +{ + delete mException; +} + +void CalFormat::clearException() +{ + delete mException; + mException = 0; +} + +void CalFormat::setException(ErrorFormat *exception) +{ + delete mException; + mException = exception; +} + +ErrorFormat *CalFormat::exception() +{ + return mException; +} + +void CalFormat::setApplication(const QString& application, const QString& productID) +{ + mApplication = application; + mProductId = productID; +} + +QString CalFormat::createUniqueId() +{ + int hashTime = QTime::currentTime().hour() + + QTime::currentTime().minute() + QTime::currentTime().second() + + QTime::currentTime().msec(); + QString uidStr = QString("%1-%2.%3") + .arg(mApplication) + .arg(KApplication::random()) + .arg(hashTime); + return uidStr; +} + +int CalFormat::calendarVersion(const char* prodId) +{ + for (const CalVersion* cv = prodIds; cv->version; ++cv) { + if (!strcmp(prodId, cv->prodId.local8Bit())) + return cv->version; + } + return 0; +} diff --git a/libkcal/calformat.h b/libkcal/calformat.h new file mode 100644 index 0000000..0c7ee7e --- a/dev/null +++ b/libkcal/calformat.h @@ -0,0 +1,111 @@ +/* + This file is part of libkcal. + Copyright (c) 2001 Cornelius Schumacher + + 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 _CALFORMAT_H +#define _CALFORMAT_H + +#include +#include +#include + +#include "exceptions.h" +#include "event.h" + +namespace KCal { + +class VCalDrag; +class Calendar; + +/** + This is the base class for calendar formats. It provides an interface for the + generation/interpretation of a textual representation of a calendar. + + @short Class providing in interface to a calendar format +*/ +class CalFormat { + public: + /** Constructs a new format. */ + CalFormat(); + /** Destruct calendar format. */ + virtual ~CalFormat(); + + /** + loads a calendar on disk into the calendar associated with this format. + Returns TRUE if successful,else returns FALSE. + @param fileName the name of the calendar on disk. + */ + virtual bool load(Calendar *, const QString &fileName) = 0; + /** writes out the calendar to disk. Returns true if + * successful and false on error. + * @param fileName the name of the file + */ + virtual bool save(Calendar *, const QString &fileName) = 0; + + /** + Parse string and populate calendar with that information. + */ + virtual bool fromString(Calendar *, const QString & ) = 0; + /** + Return calendar information as string. + */ + virtual QString toString(Calendar *) = 0; + + /** Clear exception status of this format object */ + void clearException(); + /** + Return exception, if there is any, containing information about the last + error that occured. + */ + ErrorFormat *exception(); + + /** Set the application name for use in unique IDs and error messages, + * and product ID for incidence PRODID property + */ + static void setApplication(const QString& app, const QString& productID); + /** Return the application name used in unique IDs and error messages */ + static const QString& application() { return mApplication; } + /** Return the PRODID string to write into calendar files */ + static const QString& productId() { return mProductId; } + /** Return the KDE calendar format version indicated by a PRODID property */ + static int calendarVersion(const char* prodId); + /** Return the PRODID string loaded from calendar file */ + const QString &loadedProductId() { return mLoadedProductId; } + + /** Create a unique id string. */ + static QString createUniqueId(); + + /** + Set exception for this object. This is used by the functions of this + class to report errors. + */ + void setException(ErrorFormat *error); + + protected: + QString mLoadedProductId; // PRODID string loaded from calendar file + + private: + ErrorFormat *mException; + + static QString mApplication; // name of application for unique ID strings + static QString mProductId; // PRODID string to write to calendar files +}; + +} + +#endif diff --git a/libkcal/calstorage.h b/libkcal/calstorage.h new file mode 100644 index 0000000..72972ea --- a/dev/null +++ b/libkcal/calstorage.h @@ -0,0 +1,52 @@ +/* + This file is part of libkcal. + Copyright (c) 2002 Cornelius Schumacher + + 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_CALSTORAGE_H +#define KCAL_CALSTORAGE_H + +namespace KCal { + +class Calendar; + +/** + This class provides the interface to the storage of a calendar. +*/ +class CalStorage +{ + public: + CalStorage( Calendar *calendar ) + { + mCalendar = calendar; + } + virtual ~CalStorage() {} + + Calendar *calendar() const { return mCalendar; } + + virtual bool open() = 0; + virtual bool load(bool = false ) = 0; + virtual bool save() = 0; + virtual bool close() = 0; + + private: + Calendar *mCalendar; +}; + +} + +#endif diff --git a/libkcal/compat.cpp b/libkcal/compat.cpp new file mode 100644 index 0000000..070e082 --- a/dev/null +++ b/libkcal/compat.cpp @@ -0,0 +1,37 @@ +/* + This file is part of libkcal. + Copyright (c) 2002 Cornelius Schumacher + + 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 "compat.h" + +#include + +#include + +using namespace KCal; + +Compat *CompatFactory::createCompat( const QString & ) +{ + return new Compat; +} + +void CompatPre31::fixFloatingEnd( QDate &endDate ) +{ + endDate = endDate.addDays( 1 ); +} diff --git a/libkcal/compat.h b/libkcal/compat.h new file mode 100644 index 0000000..42d44fa --- a/dev/null +++ b/libkcal/compat.h @@ -0,0 +1,53 @@ +/* + This file is part of libkcal. + Copyright (c) 2002 Cornelius Schumacher + + 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_COMPAT_H +#define KCAL_COMPAT_H + +#include +#include + +namespace KCal { + +class Compat; + +class CompatFactory +{ + public: + static Compat *createCompat( const QString &productId ); +}; + +class Compat +{ + public: + Compat() {}; + virtual ~Compat() {}; + + virtual void fixFloatingEnd( QDate & ) {} +}; + +class CompatPre31 : public Compat +{ + public: + void fixFloatingEnd( QDate & ); +}; + +} + +#endif diff --git a/libkcal/customproperties.cpp b/libkcal/customproperties.cpp new file mode 100644 index 0000000..adc1710 --- a/dev/null +++ b/libkcal/customproperties.cpp @@ -0,0 +1,114 @@ +/* + This file is part of libkcal. + Copyright (c) 2002 David Jarvie + + 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 "customproperties.h" + +using namespace KCal; + +CustomProperties::CustomProperties() +{ +} + +CustomProperties::CustomProperties(const CustomProperties &cp) + : mProperties(cp.mProperties) +{ +} + +CustomProperties::~CustomProperties() +{ +} + +void CustomProperties::setCustomProperty(const QCString &app, const QCString &key, + const QString &value) +{ + if (value.isNull() || key.isEmpty() || app.isEmpty()) + return; + QCString property = "X-KDE-" + app + "-" + key; + if (!checkName(property)) + return; + mProperties[property] = value; +} + +void CustomProperties::removeCustomProperty(const QCString &app, const QCString &key) +{ + removeNonKDECustomProperty(QCString("X-KDE-" + app + "-" + key)); +} + +QString CustomProperties::customProperty(const QCString &app, const QCString &key) const +{ + return nonKDECustomProperty(QCString("X-KDE-" + app + "-" + key)); +} + +void CustomProperties::setNonKDECustomProperty(const QCString &name, const QString &value) +{ + if (value.isNull() || !checkName(name)) + return; + mProperties[name] = value; +} + +void CustomProperties::removeNonKDECustomProperty(const QCString &name) +{ + QMap::Iterator it = mProperties.find(name); + if (it != mProperties.end()) + mProperties.remove(it); +} + +QString CustomProperties::nonKDECustomProperty(const QCString &name) const +{ + QMap::ConstIterator it = mProperties.find(name); + if (it == mProperties.end()) + return QString::null; + return it.data(); +} + +void CustomProperties::setCustomProperties(const QMap &properties) +{ + for (QMap::ConstIterator it = properties.begin(); it != properties.end(); ++it) { + // Validate the property name and convert any null string to empty string + if (checkName(it.key())) { + mProperties[it.key()] = it.data().isNull() ? QString("") : it.data(); + } + } +} + +QMap CustomProperties::customProperties() const +{ + return mProperties; +} + +bool CustomProperties::checkName(const QCString &name) +{ + // Check that the property name starts with 'X-' and contains + // only the permitted characters + const char* n = name; + int len = name.length(); + if (len < 2 || n[0] != 'X' || n[1] != '-') + return false; + for (int i = 2; i < len; ++i) { + char ch = n[i]; + if (ch >= 'A' && ch <= 'Z' + || ch >= 'a' && ch <= 'z' + || ch >= '0' && ch <= '9' + || ch == '-') + continue; + return false; // invalid character found + } + return true; +} diff --git a/libkcal/customproperties.h b/libkcal/customproperties.h new file mode 100644 index 0000000..0cbfdcd --- a/dev/null +++ b/libkcal/customproperties.h @@ -0,0 +1,97 @@ +/* + This file is part of libkcal. + Copyright (c) 2002 David Jarvie + + 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_CUSTOM_PROPERTIES_H +#define KCAL_CUSTOM_PROPERTIES_H + +#include +#include + +namespace KCal { + +/** + This class represents custom calendar properties. + It is used as a base class for classes which represent calendar components. + A custom property name written by libkcal has the form X-KDE-APP-KEY where + APP represents the application name, and KEY distinguishes individual + properties for the application. + In keeping with RFC2445, property names must be composed only of the + characters A-Z, a-z, 0-9 and '-'. +*/ +class CustomProperties +{ + public: + /** Construct a new empty custom properties instance */ + CustomProperties(); + CustomProperties(const CustomProperties &); + ~CustomProperties(); + + /** Create or modify a custom calendar property. + @param app Application name as it appears in the custom property name. + @param key Property identifier specific to the application. + @param value The property's value. A call with a value of QString::null + will be ignored. + */ + void setCustomProperty(const QCString &app, const QCString &key, + const QString &value); + /** Delete a custom calendar property. + @param app Application name as it appears in the custom property name. + @param key Property identifier specific to the application. + */ + void removeCustomProperty(const QCString &app, const QCString &key); + /** Return the value of a custom calendar property. + @param app Application name as it appears in the custom property name. + @param key Property identifier specific to the application. + @return Property value, or QString::null if (and only if) the property does not exist. + */ + QString customProperty(const QCString &app, const QCString &key) const; + + /** Create or modify a non-KDE or non-standard custom calendar property. + @param name Full property name + @param value The property's value. A call with a value of QString::null + will be ignored. + */ + void setNonKDECustomProperty(const QCString &name, const QString &value); + /** Delete a non-KDE or non-standard custom calendar property. + @param name Full property name + */ + void removeNonKDECustomProperty(const QCString &name); + /** Return the value of a non-KDE or non-standard custom calendar property. + @param name Full property name + @return Property value, or QString::null if (and only if) the property does not exist. + */ + QString nonKDECustomProperty(const QCString& name) const; + + /** Initialise the alarm's custom calendar properties to the specified + key/value pairs. + */ + void setCustomProperties(const QMap &properties); + /** Return all custom calendar property key/value pairs. */ + QMap customProperties() const; + + private: + static bool checkName(const QCString& name); + + QMap mProperties; // custom calendar properties +}; + +} + +#endif diff --git a/libkcal/dndfactory.h b/libkcal/dndfactory.h new file mode 100644 index 0000000..6b73f34 --- a/dev/null +++ b/libkcal/dndfactory.h @@ -0,0 +1,62 @@ +/* + This file is part of libkcal. + Copyright (c) 1998 Preston Brown + Copyright (c) 2001,2002 Cornelius Schumacher + + 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. +*/ + +// $Id$ + +#ifndef KCAL_DNDFACTORY_H +#define KCAL_DNDFACTORY_H + +#include "vcalformat.h" + +class QDropEvent; + +namespace KCal { + +/** + This class implements functions to create Drag and Drop objects used for + Drag-and-Drop and Copy-and-Paste. + + @short vCalendar Drag-and-Drop object factory. +*/ +class DndFactory { + public: + DndFactory( Calendar * ) {} + + /** create an object to be used with the Xdnd Drag And Drop protocol. */ + ICalDrag *createDrag(Event *, QWidget *) { return 0; } + /** create an object to be used with the Xdnd Drag And Drop protocol. */ + ICalDrag *createDragTodo(Todo *, QWidget *) { return 0; } + /** Create Todo object from drop event */ + Todo *createDropTodo(QDropEvent *) { return 0; } + /** Create Event object from drop event */ + Event *createDrop(QDropEvent *) { return 0; } + + /** cut event to clipboard */ + void cutEvent(Event *) {} + /** cut, copy, and paste operations follow. */ + bool copyEvent(Event *) { return false; } + /** pastes the event and returns a pointer to the new event pasted. */ + Event *pasteEvent(const QDate &, const QTime *newTime = 0) { return 0; } +}; + +} + +#endif diff --git a/libkcal/dummyscheduler.cpp b/libkcal/dummyscheduler.cpp new file mode 100644 index 0000000..ae40e6d --- a/dev/null +++ b/libkcal/dummyscheduler.cpp @@ -0,0 +1,119 @@ +/* + This file is part of libkcal. + Copyright (c) 2001 Cornelius Schumacher + + 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. +*/ + +// +// DummyScheduler - iMIP implementation of iTIP methods +// + +#include +#include + +#include + +#include "event.h" +#include "icalformat.h" + +#include "dummyscheduler.h" + +using namespace KCal; + +DummyScheduler::DummyScheduler(Calendar *calendar) + : Scheduler(calendar) +{ +} + +DummyScheduler::~DummyScheduler() +{ +} + +bool DummyScheduler::publish (IncidenceBase *incidence,const QString &recipients) +{ + QString messageText = mFormat->createScheduleMessage(incidence, + Scheduler::Publish); + + return saveMessage(messageText); +} + +bool DummyScheduler::performTransaction(IncidenceBase *incidence,Method method,const QString &recipients) +{ + QString messageText = mFormat->createScheduleMessage(incidence,method); + + return saveMessage(messageText); +} + +bool DummyScheduler::performTransaction(IncidenceBase *incidence,Method method) +{ + QString messageText = mFormat->createScheduleMessage(incidence,method); + + return saveMessage(messageText); +} + +bool DummyScheduler::saveMessage(const QString &message) +{ + QFile f("dummyscheduler.store"); + if (f.open(IO_WriteOnly | IO_Append)) { + QTextStream t(&f); + t << message << endl; + f.close(); + return true; + } else { + return false; + } +} + +QPtrList DummyScheduler::retrieveTransactions() +{ + QPtrList messageList; + + QFile f("dummyscheduler.store"); + if (!f.open(IO_ReadOnly)) { + kdDebug(5800) << "DummyScheduler::retrieveTransactions(): Can't open file" + << endl; + } else { + QTextStream t(&f); + QString messageString; + QString messageLine = t.readLine(); + while (!messageLine.isNull()) { +// kdDebug(5800) << "++++++++" << messageLine << endl; + messageString += messageLine + "\n"; + if (messageLine.find("END:VCALENDAR") >= 0) { + kdDebug(5800) << "---------------" << messageString << endl; + ScheduleMessage *message = mFormat->parseScheduleMessage(mCalendar, + messageString); + kdDebug(5800) << "--Parsed" << endl; + if (message) { + messageList.append(message); + } else { + QString errorMessage; + if (mFormat->exception()) { + errorMessage = mFormat->exception()->message(); + } + kdDebug(5800) << "DummyScheduler::retrieveTransactions() Error parsing " + "message: " << errorMessage << endl; + } + messageString=""; + } + messageLine = t.readLine(); + } + f.close(); + } + + return messageList; +} diff --git a/libkcal/dummyscheduler.h b/libkcal/dummyscheduler.h new file mode 100644 index 0000000..df42153 --- a/dev/null +++ b/libkcal/dummyscheduler.h @@ -0,0 +1,51 @@ +/* + This file is part of libkcal. + Copyright (c) 2001 Cornelius Schumacher + + 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 DUMMYSCHEDULER_H +#define DUMMYSCHEDULER_H +// +// Dummy implementation of iTIP methods +// + +#include "scheduler.h" + +namespace KCal { + +/** + This class implements the iTIP interface as a primitive local version for + testing. It uses a file dummyscheduler.store as inbox/outbox. +*/ +class DummyScheduler : public Scheduler { + public: + DummyScheduler(Calendar *); + virtual ~DummyScheduler(); + + bool publish (IncidenceBase *incidence,const QString &recipients); + bool performTransaction(IncidenceBase *incidence,Method method); + bool performTransaction(IncidenceBase *incidence,Method method,const QString &recipients); + QPtrList retrieveTransactions(); + + protected: + bool saveMessage(const QString &); +}; + +} + +#endif // DUMMYSCHEDULER_H + diff --git a/libkcal/duration.cpp b/libkcal/duration.cpp new file mode 100644 index 0000000..3d57136 --- a/dev/null +++ b/libkcal/duration.cpp @@ -0,0 +1,59 @@ +/* + This file is part of libkcal. + Copyright (c) 2001 Cornelius Schumacher + + 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 +#include + +#include "duration.h" + +using namespace KCal; + +Duration::Duration() +{ + mSeconds = 0; +} + +Duration::Duration( const QDateTime &start, const QDateTime &end ) +{ + mSeconds = start.secsTo( end ); +} + +Duration::Duration( int seconds ) +{ + mSeconds = seconds; +} + + +bool KCal::operator==( const Duration& d1, const Duration& d2 ) +{ + return ( d1.asSeconds() == d2.asSeconds() ); +} + + + +QDateTime Duration::end( const QDateTime &start ) const +{ + return start.addSecs( mSeconds ); +} + +int Duration::asSeconds() const +{ + return mSeconds; +} diff --git a/libkcal/duration.h b/libkcal/duration.h new file mode 100644 index 0000000..81274dd --- a/dev/null +++ b/libkcal/duration.h @@ -0,0 +1,48 @@ +/* + This file is part of libkcal. + Copyright (c) 2001 Cornelius Schumacher + + 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_DURATION_H +#define KCAL_DURATION_H + +#include + +namespace KCal { + +class Duration +{ + public: + Duration(); + Duration( const QDateTime &start, const QDateTime &end ); + Duration( int seconds ); + + QDateTime end( const QDateTime &start ) const; + + int asSeconds() const; + + private: + int mSeconds; +}; + + bool operator==( const Duration&, const Duration& ); + inline bool operator!=( const Duration &d1, const Duration &d2 ) + { return !operator==( d1, d2 ); } + +} + +#endif diff --git a/libkcal/event.cpp b/libkcal/event.cpp new file mode 100644 index 0000000..dd67252 --- a/dev/null +++ b/libkcal/event.cpp @@ -0,0 +1,178 @@ +/* + This file is part of libkcal. + Copyright (c) 2001 Cornelius Schumacher + + 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 +#include +#include + +#include "event.h" + +using namespace KCal; + +Event::Event() : + mHasEndDate( false ), mTransparency( Opaque ) +{ +} + +Event::Event(const Event &e) : Incidence(e) +{ + mDtEnd = e.mDtEnd; + mHasEndDate = e.mHasEndDate; + mTransparency = e.mTransparency; +} + +Event::~Event() +{ +} + +Incidence *Event::clone() +{ + kdDebug(5800) << "Event::clone()" << endl; + return new Event(*this); +} + +bool KCal::operator==( const Event& e1, const Event& e2 ) +{ + return operator==( (const Incidence&)e1, (const Incidence&)e2 ) && + e1.dtEnd() == e2.dtEnd() && + e1.hasEndDate() == e2.hasEndDate() && + e1.transparency() == e2.transparency(); +} + + + +void Event::setDtEnd(const QDateTime &dtEnd) +{ + if (mReadOnly) return; + + mDtEnd = getEvenTime( dtEnd ); + + setHasEndDate(true); + setHasDuration(false); + + updated(); +} + +QDateTime Event::dtEnd() const +{ + if (hasEndDate()) return mDtEnd; + if (hasDuration()) return dtStart().addSecs(duration()); + + kdDebug(5800) << "Warning! Event '" << summary() + << "' does have neither end date nor duration." << endl; + return dtStart(); +} + +QString Event::dtEndTimeStr() const +{ + return KGlobal::locale()->formatTime(mDtEnd.time()); +} + +QString Event::dtEndDateStr(bool shortfmt) const +{ + return KGlobal::locale()->formatDate(mDtEnd.date(),shortfmt); +} + +QString Event::dtEndStr(bool shortfmt) const +{ + return KGlobal::locale()->formatDateTime(mDtEnd, shortfmt); +} + +void Event::setHasEndDate(bool b) +{ + mHasEndDate = b; +} + +bool Event::hasEndDate() const +{ + return mHasEndDate; +} + +bool Event::isMultiDay() const +{ + bool multi = !(dtStart().date() == dtEnd().date()); + return multi; +} + +void Event::setTransparency(Event::Transparency transparency) +{ + if (mReadOnly) return; + mTransparency = transparency; + updated(); +} + +Event::Transparency Event::transparency() const +{ + return mTransparency; +} + +void Event::setDuration(int seconds) +{ + setHasEndDate(false); + Incidence::setDuration(seconds); +} +QDateTime Event::getNextAlarmDateTime( bool * ok, int * offset ) const +{ + + bool yes; + QDateTime incidenceStart = getNextOccurence( QDateTime::currentDateTime(), &yes ); + if ( ! yes || cancelled() ) { + *ok = false; + return QDateTime (); + } + + bool enabled = false; + Alarm* alarm; + int off; + QDateTime alarmStart = QDateTime::currentDateTime().addDays( 3650 );; + // if ( QDateTime::currentDateTime() > incidenceStart ){ +// *ok = false; +// return incidenceStart; +// } + for (QPtrListIterator it(mAlarms); (alarm = it.current()) != 0; ++it) { + if (alarm->enabled()) { + if ( alarm->hasTime () ) { + if ( alarm->time() < alarmStart ) { + alarmStart = alarm->time(); + enabled = true; + off = alarmStart.secsTo( incidenceStart ); + } + + } else { + int secs = alarm->startOffset().asSeconds(); + if ( incidenceStart.addSecs( secs ) < alarmStart ) { + alarmStart = incidenceStart.addSecs( secs ); + enabled = true; + off = -secs; + } + } + } + } + if ( enabled ) { + if ( alarmStart > QDateTime::currentDateTime() ) { + *ok = true; + * offset = off; + return alarmStart; + } + } + *ok = false; + return QDateTime (); + +} diff --git a/libkcal/event.h b/libkcal/event.h new file mode 100644 index 0000000..2a8bd95 --- a/dev/null +++ b/libkcal/event.h @@ -0,0 +1,88 @@ +/* + This file is part of libkcal. + Copyright (c) 2001 Cornelius Schumacher + + 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 EVENT_H +#define EVENT_H +// +// Event component, representing a VEVENT object +// + +#include "incidence.h" +namespace KCal { + +/** + This class provides an Event in the sense of RFC2445. +*/ +class Event : public Incidence +{ + public: + enum Transparency { Opaque, Transparent }; + typedef ListBase List; + Event(); + Event(const Event &); + ~Event(); + + QCString type() const { return "Event"; } + + Incidence *clone(); + QDateTime getNextAlarmDateTime( bool * ok, int * offset ) const; + + /** for setting an event's ending date/time with a QDateTime. */ + void setDtEnd(const QDateTime &dtEnd); + /** Return the event's ending date/time as a QDateTime. */ + virtual QDateTime dtEnd() const; + /** returns an event's end time as a string formatted according to the + users locale settings */ + QString dtEndTimeStr() const; + /** returns an event's end date as a string formatted according to the + users locale settings */ + QString dtEndDateStr(bool shortfmt=true) const; + /** returns an event's end date and time as a string formatted according + to the users locale settings */ + QString dtEndStr(bool shortfmt=true) const; + void setHasEndDate(bool); + /** Return whether the event has an end date/time. */ + bool hasEndDate() const; + + /** Return true if the event spans multiple days, otherwise return false. */ + bool isMultiDay() const; + + /** set the event's time transparency level. */ + void setTransparency(Transparency transparency); + /** get the event's time transparency level. */ + Transparency transparency() const; + + void setDuration(int seconds); + + private: + bool accept(Visitor &v) { return v.visit(this); } + + QDateTime mDtEnd; + bool mHasEndDate; + Transparency mTransparency; +}; + +bool operator==( const Event&, const Event& ); + + +} + + +#endif diff --git a/libkcal/exceptions.cpp b/libkcal/exceptions.cpp new file mode 100644 index 0000000..bc298f9 --- a/dev/null +++ b/libkcal/exceptions.cpp @@ -0,0 +1,90 @@ +/* + This file is part of libkcal. + Copyright (c) 2001 Cornelius Schumacher + + 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 + +#include "calformat.h" +#include "exceptions.h" + +using namespace KCal; + +Exception::Exception(const QString &message) +{ + mMessage = message; +} + +Exception::~Exception() +{ +} + +QString Exception::message() +{ + if (mMessage.isEmpty()) return i18n("%1 Error").arg(CalFormat::application()); + else return mMessage; +} + + +ErrorFormat::ErrorFormat(ErrorCodeFormat code,const QString &message) : + Exception(message) +{ + mCode = code; +} + +QString ErrorFormat::message() +{ + QString message = ""; + + switch (mCode) { + case LoadError: + message = i18n("Load Error"); + break; + case SaveError: + message = i18n("Save Error"); + break; + case ParseErrorIcal: + message = i18n("Parse Error in libical"); + break; + case ParseErrorKcal: + message = i18n("Parse Error in libkcal"); + break; + case NoCalendar: + message = i18n("No calendar component found."); + break; + case CalVersion1: + message = i18n("vCalendar Version 1.0 detected."); + break; + case CalVersion2: + message = i18n("iCalendar Version 2.0 detected."); + break; + case Restriction: + message = i18n("Restriction violation"); + default: + break; + } + + if (!mMessage.isEmpty()) message += ": " + mMessage; + + return message; +} + +ErrorFormat::ErrorCodeFormat ErrorFormat::errorCode() +{ + return mCode; +} diff --git a/libkcal/exceptions.h b/libkcal/exceptions.h new file mode 100644 index 0000000..4b75df8 --- a/dev/null +++ b/libkcal/exceptions.h @@ -0,0 +1,75 @@ +/* + This file is part of libkcal. + Copyright (c) 2001 Cornelius Schumacher + + 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_EXCEPTIONS_H +#define KCAL_EXCEPTIONS_H +// +// Exception classes of libkcal. +// +// We don't use actual C++ exceptions right now. These classes are currently +// returned by an error function, but we can build upon them, when we start +// to use C++ exceptions. + +#include + +namespace KCal { + +/** + KOrganizer exceptions base class. This is currently used as a fancy kind of error code not as an + C++ exception. +*/ +class Exception { + public: + /** Construct exception with descriptive message \a message. */ + Exception(const QString &message=QString::null); + virtual ~Exception(); + + /** Return descriptive message of exception. */ + virtual QString message(); + + protected: + QString mMessage; +}; + +/** Calendar format related error class */ +class ErrorFormat : public Exception { + public: + enum ErrorCodeFormat { LoadError, SaveError, + ParseErrorIcal, ParseErrorKcal, + NoCalendar, + CalVersion1,CalVersion2, + CalVersionUnknown, + Restriction }; + + /** Create format error exception. */ + ErrorFormat(ErrorCodeFormat code,const QString &message = QString::null); + + /** Return format error message. */ + QString message(); + /** Return format error code. */ + ErrorCodeFormat errorCode(); + + private: + ErrorCodeFormat mCode; +}; + +} + +#endif diff --git a/libkcal/filestorage.cpp b/libkcal/filestorage.cpp new file mode 100644 index 0000000..00c15d9 --- a/dev/null +++ b/libkcal/filestorage.cpp @@ -0,0 +1,140 @@ +/* + This file is part of libkcal. + Copyright (c) 2002 Cornelius Schumacher + + 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 + +#include +#include +#include + +#include + +#include "calendar.h" +#include "vcaldrag.h" +#include "vcalformat.h" +#include "icalformat.h" + +#include "filestorage.h" + +using namespace KCal; + +FileStorage::FileStorage( Calendar *cal, const QString &fileName, + CalFormat *format ) + : CalStorage( cal ), + mFileName( fileName ), + mSaveFormat( format ) +{ +} + +FileStorage::~FileStorage() +{ + delete mSaveFormat; +} + +void FileStorage::setFileName( const QString &fileName ) +{ + mFileName = fileName; +} + +QString FileStorage::fileName()const +{ + return mFileName; +} + + +void FileStorage::setSaveFormat( CalFormat *format ) +{ + delete mSaveFormat; + mSaveFormat = format; +} + +CalFormat *FileStorage::saveFormat()const +{ + return mSaveFormat; +} + + +bool FileStorage::open() +{ + return true; +} + +bool FileStorage::load( bool quick ) +{ + kdDebug(5800) << "FileStorage::load(): '" << mFileName << "'" << endl; + + // do we want to silently accept this, or make some noise? Dunno... + // it is a semantical thing vs. a practical thing. + if (mFileName.isEmpty()) return false; + + // Always try to load with iCalendar. It will detect, if it is actually a + // vCalendar file. + ICalFormat iCal (quick ); + + bool success = iCal.load( calendar(), mFileName); + + if ( !success ) { + if ( iCal.exception() ) { +// kdDebug(5800) << "---Error: " << mFormat->exception()->errorCode() << endl; + if ( iCal.exception()->errorCode() == ErrorFormat::CalVersion1 ) { + // Expected non vCalendar file, but detected vCalendar + kdDebug(5800) << "FileStorage::load() Fallback to VCalFormat" << endl; + VCalFormat vCal; + success = vCal.load( calendar(), mFileName ); + calendar()->setLoadedProductId( vCal.productId() ); + } else { + return false; + } + } else { + kdDebug(5800) << "Warning! There should be set an exception." << endl; + return false; + } + } else { +// kdDebug(5800) << "---Success" << endl; + calendar()->setLoadedProductId( iCal.loadedProductId() ); + } + + calendar()->setModified( false ); + + return true; +} + +bool FileStorage::save() +{ + if ( mFileName.isEmpty() ) return false; + + bool success; + + if ( mSaveFormat ) { + success = mSaveFormat->save( calendar(), mFileName); + } else { + ICalFormat iCal; + success = iCal.save( calendar(), mFileName); + } + + if ( success ) calendar()->setModified( false ); + + return success; +} + +bool FileStorage::close() +{ + return true; +} diff --git a/libkcal/filestorage.h b/libkcal/filestorage.h new file mode 100644 index 0000000..e9dc15e --- a/dev/null +++ b/libkcal/filestorage.h @@ -0,0 +1,58 @@ +/* + This file is part of libkcal. + Copyright (c) 2002 Cornelius Schumacher + + 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_FILESTORAGE_H +#define KCAL_FILESTORAGE_H + +#include "calstorage.h" + +namespace KCal { + +/** + This class provides a calendar storage as a local file. +*/ +class FileStorage : public CalStorage +{ + public: + FileStorage( Calendar *, const QString &fileName = QString::null, + CalFormat *format = 0 ); + virtual ~FileStorage(); + + void setFileName( const QString &mFileName ); + QString fileName()const; + + /** + FileStorage takes ownership of format object. + */ + void setSaveFormat( CalFormat * ); + CalFormat *saveFormat()const; + + bool open(); + bool load(bool quick = false ); + bool save(); + bool close(); + + private: + QString mFileName; + CalFormat *mSaveFormat; +}; + +} + +#endif diff --git a/libkcal/freebusy.cpp b/libkcal/freebusy.cpp new file mode 100644 index 0000000..ba15d6d --- a/dev/null +++ b/libkcal/freebusy.cpp @@ -0,0 +1,184 @@ +/* + This file is part of libkcal. + Copyright (c) 2001 Cornelius Schumacher + + 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 + +#include "freebusy.h" + +using namespace KCal; + +FreeBusy::FreeBusy() +{ +} + +FreeBusy::FreeBusy(const QDateTime &start, const QDateTime &end) +{ + setDtStart(start); + setDtEnd(end); +} + +FreeBusy::FreeBusy( Calendar *calendar, const QDateTime &start, const QDateTime &end ) +{ + kdDebug() << "FreeBusy::FreeBusy" << endl; + mCalendar = calendar; + + setDtStart(start); + setDtEnd(end); + + //Gets all the events in the calendar + QPtrList eventList = mCalendar->events(); + Event *event; + + int extraDays, i, x, duration; + duration = start.daysTo(end); + QDate day; + QDateTime tmpStart; + QDateTime tmpEnd; + //Loops through every event in the calendar + for( event = eventList.first(); event; event = eventList.next() ) { + //This whole for loop is for recurring events, it loops through + //each of the days of the freebusy request + + //First check if this is transparent. If it is, it shouldn't be in the + //freebusy list + if ( event->transparency() == Event::Transparent ) + // Transparent + continue; + + for(i=0; i<=duration; i++) { + day=(start.addDays(i).date()); + tmpStart.setDate(day); + tmpEnd.setDate(day); + + if( (*(event->recurrence())).doesRecur() ) { + if ( event->isMultiDay() ) { + extraDays = event->dtStart().date().daysTo(event->dtEnd().date()); + for (x=0; x<=extraDays; x++) { + if ( event->recursOn(day.addDays(-x))) { + tmpStart.setDate(day.addDays(-x)); + tmpStart.setTime(event->dtStart().time()); + tmpEnd=tmpStart.addSecs( (event->duration()) ); + + addLocalPeriod( tmpStart, tmpEnd ); + break; + } + } + } else { + if (event->recursOn(day)) { + tmpStart.setTime(event->dtStart().time()); + tmpEnd.setTime(event->dtEnd().time()); + + addLocalPeriod (tmpStart, tmpEnd); + } + } + } + + } + //Non-reocurring events + addLocalPeriod(event->dtStart(), event->dtEnd()); + } + + sortList(); +} + +FreeBusy::~FreeBusy() +{ +} + +bool FreeBusy::setDtEnd( const QDateTime &end ) +{ + mDtEnd = end; + return true; +} + +QDateTime FreeBusy::dtEnd() const +{ + return mDtEnd; +} + +QValueList FreeBusy::busyPeriods() const +{ + return mBusyPeriods; +} + +bool FreeBusy::addLocalPeriod(const QDateTime &eventStart, const QDateTime &eventEnd ) { + QDateTime tmpStart; + QDateTime tmpEnd; + + //Check to see if the start *or* end of the event is + //between the start and end of the freebusy dates. + if (!((((this->dtStart()).secsTo(eventStart)>=0)&&(eventStart.secsTo(this->dtEnd())>=0)) + ||(((this->dtStart()).secsTo(eventEnd) >= 0)&&(eventEnd.secsTo(this->dtEnd()) >= 0)))) + return false; + + if ( eventStart.secsTo(this->dtStart())>=0) { + tmpStart = this->dtStart(); + } else { + tmpStart = eventStart; + } + + if ( eventEnd.secsTo(this->dtEnd())<=0 ) { + tmpEnd = this->dtEnd(); + } else { + tmpEnd = eventEnd; + } + + Period p(tmpStart, tmpEnd); + mBusyPeriods.append( p ); + + return true; +} + +FreeBusy::FreeBusy(QValueList busyPeriods) +{ + mBusyPeriods = busyPeriods; +} + +void FreeBusy::sortList() +{ + typedef QValueList PeriodList; + + PeriodList::Iterator tmpPeriod, earlyPeriod; + PeriodList sortedList; + QDateTime earlyTime; + + while( mBusyPeriods.count() > 0 ) { + earlyTime=(*mBusyPeriods.begin()).start(); + for (tmpPeriod=mBusyPeriods.begin(); tmpPeriod!=mBusyPeriods.end(); tmpPeriod++) { + if (earlyTime.secsTo((*tmpPeriod).start()) <= 0) { + earlyTime=(*tmpPeriod).start(); + earlyPeriod=tmpPeriod; + } + } + //Move tmpPeriod to sortedList + Period tmpPeriod( (*earlyPeriod).start(), (*earlyPeriod).end() ); + sortedList.append( tmpPeriod ); + mBusyPeriods.remove( earlyPeriod ); + } + mBusyPeriods=sortedList; +} + +void FreeBusy::addPeriod(const QDateTime &start, const QDateTime &end) +{ + Period p(start, end); + mBusyPeriods.append( p ); + + sortList(); +} diff --git a/libkcal/freebusy.h b/libkcal/freebusy.h new file mode 100644 index 0000000..054feda --- a/dev/null +++ b/libkcal/freebusy.h @@ -0,0 +1,72 @@ +/* + This file is part of libkcal. + Copyright (c) 2001 Cornelius Schumacher + + 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_FREEBUSY_H +#define KCAL_FREEBUSY_H +// +// FreeBusy - information about free/busy times +// + +#include +#include +#include + +#include "period.h" +#include "calendar.h" + +#include "incidencebase.h" + +namespace KCal { + +/** + This class provides information about free/busy time of a calendar user. +*/ +class FreeBusy : public IncidenceBase +{ + public: + FreeBusy(); + FreeBusy(const QDateTime &start, const QDateTime &end); + FreeBusy(Calendar *calendar, const QDateTime &start, const QDateTime &end); + FreeBusy(QValueList busyPeriods); + + ~FreeBusy(); + + QCString type() const { return "FreeBusy"; } + + virtual QDateTime dtEnd() const; + bool setDtEnd( const QDateTime &end ); + + QValueList busyPeriods() const; + + void addPeriod(const QDateTime &start, const QDateTime &end); + void sortList(); + + private: + + //This is used for creating a freebusy object for the current user + bool addLocalPeriod(const QDateTime &start, const QDateTime &end); + + QDateTime mDtEnd; + QValueList mBusyPeriods; + Calendar *mCalendar; +}; + +} + +#endif diff --git a/libkcal/icaldrag.cpp b/libkcal/icaldrag.cpp new file mode 100644 index 0000000..446a115 --- a/dev/null +++ b/libkcal/icaldrag.cpp @@ -0,0 +1,58 @@ +/* + This file is part of libkcal. + Copyright (c) 1998 Preston Brown + Copyright (c) 2001 Cornelius Schumacher + + 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 "icaldrag.h" + +#include "icalformat.h" + +#include + +using namespace KCal; + +ICalDrag::ICalDrag( Calendar *cal, QWidget *parent, const char *name ) + : QStoredDrag( "text/calendar", parent, name ) +{ + ICalFormat icf; + QString scal = icf.toString( cal ); + + setEncodedData( scal.utf8() ); +} + +bool ICalDrag::canDecode( QMimeSource *me ) +{ + return me->provides( "text/calendar" ); +} + +bool ICalDrag::decode( QMimeSource *de, Calendar *cal ) +{ + bool success = false; + + QByteArray payload = de->encodedData( "text/calendar" ); + if ( payload.size() ) { + QString txt = QString::fromUtf8( payload.data() ); + + ICalFormat icf; + success = icf.fromString( cal, txt ); + } + + return success; +} + diff --git a/libkcal/icaldrag.h b/libkcal/icaldrag.h new file mode 100644 index 0000000..fdf32b7 --- a/dev/null +++ b/libkcal/icaldrag.h @@ -0,0 +1,46 @@ +/* + This file is part of libkcal. + Copyright (c) 1998 Preston Brown + Copyright (c) 2001 Cornelius Schumacher + + 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 ICALDRAG_H +#define ICALDRAG_H + +#include +#include "calendar.h" + +namespace KCal { + +/** iCalendar drag&drop class. */ +class ICalDrag : public QStoredDrag +{ + public: + /** Create a drag&drop object for iCalendar component \a ical. */ + ICalDrag( Calendar *cal, QWidget *parent = 0, const char *name = 0 ); + ~ICalDrag() {}; + + /** Return, if drag&drop object can be decode to iCalendar. */ + static bool canDecode( QMimeSource * ); + /** Decode drag&drop object to iCalendar component \a cal. */ + static bool decode( QMimeSource *e, Calendar *cal ); +}; + +} + +#endif diff --git a/libkcal/icalformat.cpp b/libkcal/icalformat.cpp new file mode 100644 index 0000000..5893db5 --- a/dev/null +++ b/libkcal/icalformat.cpp @@ -0,0 +1,478 @@ +/* + This file is part of libkcal. + Copyright (c) 2001 Cornelius Schumacher + + 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 +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +extern "C" { + #include + #include + #include + #include +} + +#include "calendar.h" +#include "calendarlocal.h" +#include "journal.h" + +#include "icalformat.h" +#include "icalformatimpl.h" + +#define _ICAL_VERSION "2.0" + +using namespace KCal; + +ICalFormat::ICalFormat(bool quick ) +{ + mQuicksave = false; //quick; + mImpl = new ICalFormatImpl( this ); + tzOffsetMin = 0; + //qDebug("new ICalFormat() "); +} + +ICalFormat::~ICalFormat() +{ + delete mImpl; + //qDebug("delete ICalFormat "); +} + +bool ICalFormat::load( Calendar *calendar, const QString &fileName) +{ + + clearException(); + + QFile file( fileName ); + if (!file.open( IO_ReadOnly ) ) { + setException(new ErrorFormat(ErrorFormat::LoadError)); + return false; + } + QTextStream ts( &file ); + QString text; +#if 0 + if ( !mQuicksave ) { + qDebug("KO: No quickload!"); + ts.setEncoding( QTextStream::Latin1 ); + text = ts.read(); + } else { + ts.setCodec( QTextCodec::codecForName("utf8") ); + text = ts.read(); + } +#endif + ts.setEncoding( QTextStream::Latin1 ); + text = ts.read(); + file.close(); + + return fromString( calendar, text ); +} + +//#include +bool ICalFormat::save( Calendar *calendar, const QString &fileName ) +{ + //kdDebug(5800) << "ICalFormat::save(): " << fileName << endl; + //qDebug("ICalFormat::save "); + clearException(); + QString text = toString( calendar ); + //return false; + // qDebug("to string takes ms: %d ",is.elapsed() ); + if ( text.isNull() ) return false; + + // TODO: write backup file + //is.restart(); + QFile file( fileName ); + if (!file.open( IO_WriteOnly ) ) { + setException(new ErrorFormat(ErrorFormat::SaveError, + i18n("Could not open file '%1'").arg(fileName))); + return false; + } + QTextStream ts( &file ); + +// #ifdef DESKTOP_VERSION +// mQuicksave = false; +// #endif +// if ( mQuicksave ) { +// ts << text.utf8(); +// } else { +// ts.setEncoding( QTextStream::Latin1 ); +// ts << text; +// //ts << text.latin1(); +// } + ts.setEncoding( QTextStream::Latin1 ); + ts << text; + file.close(); + //qDebug("saving file takes ms: %d ", is.elapsed() ); + return true; +} + +bool ICalFormat::fromString( Calendar *cal, const QString &text ) +{ + setTimeZone( cal->timeZoneId(), !cal->isLocalTime() ); + // qDebug("ICalFormat::fromString tz: %s ", cal->timeZoneId().latin1()); + // Get first VCALENDAR component. + // TODO: Handle more than one VCALENDAR or non-VCALENDAR top components + icalcomponent *calendar; + + //calendar = icalcomponent_new_from_string( text.local8Bit().data()); + // good calendar = icalcomponent_new_from_string( text.utf8().data()); + calendar = icalcomponent_new_from_string( (char*)text.latin1()); + if (!calendar) { + setException(new ErrorFormat(ErrorFormat::ParseErrorIcal)); + return false; + } + + bool success = true; + + if (icalcomponent_isa(calendar) != ICAL_VCALENDAR_COMPONENT) { + setException(new ErrorFormat(ErrorFormat::NoCalendar)); + success = false; + } else { + // put all objects into their proper places + if ( !mImpl->populate( cal, calendar ) ) { + if ( !exception() ) { + setException(new ErrorFormat(ErrorFormat::ParseErrorKcal)); + } + success = false; + } else + mLoadedProductId = mImpl->loadedProductId(); + } + + icalcomponent_free( calendar ); + + return success; +} + +Incidence *ICalFormat::fromString( const QString &text ) +{ + CalendarLocal cal( mTimeZoneId ); + fromString(&cal, text); + + Incidence *ical = 0; + QPtrList elist = cal.events(); + if ( elist.count() > 0 ) { + ical = elist.first(); + } else { + QPtrList tlist = cal.todos(); + if ( tlist.count() > 0 ) { + ical = tlist.first(); + } else { + QPtrList jlist = cal.journals(); + if ( jlist.count() > 0 ) { + ical = jlist.first(); + } + } + } + return ical; +} +#include + +QString ICalFormat::toString( Calendar *cal ) +{ + + setTimeZone( cal->timeZoneId(), !cal->isLocalTime() ); + + icalcomponent *calendar = mImpl->createCalendarComponent(cal); + + icalcomponent *component; + + // todos + QPtrList todoList = cal->rawTodos(); + QPtrListIterator qlt(todoList); + for (; qlt.current(); ++qlt) { + component = mImpl->writeTodo(qlt.current()); + icalcomponent_add_component(calendar,component); + //qDebug(" todos "); + qApp->processEvents(); + } + // events + QPtrList events = cal->rawEvents(); + Event *ev; + for(ev=events.first();ev;ev=events.next()) { + component = mImpl->writeEvent(ev); + icalcomponent_add_component(calendar,component); + //qDebug("events "); + qApp->processEvents(); + } + + // journals + QPtrList journals = cal->journals(); + Journal *j; + for(j=journals.first();j;j=journals.next()) { + component = mImpl->writeJournal(j); + icalcomponent_add_component(calendar,component); + //qDebug("journals "); + qApp->processEvents(); + } + const char *text; + QString ret =""; + text = icalcomponent_as_ical_string( calendar ); + qApp->processEvents(); + + // text = "BEGIN:VCALENDAR\nPRODID\n :-//K Desktop Environment//NONSGML libkcal 3.1//EN\nVERSION\n :2.0\nBEGIN:VEVENT\nDTSTAMP\n :20031231T213514Z\nORGANIZER\n :MAILTO:lutz@putz.de\nCREATED\n :20031231T213513Z\nUID\n :libkcal-1295166342.120\nSEQUENCE\n :0\nLAST-MODIFIED\n :20031231T213513Z\nSUMMARY\n :test1\nCLASS\n :PUBLIC\nPRIORITY\n :3\nDTSTART\n :20040101T090000Z\nDTEND\n :20040101T110000Z\nTRANSP\n :OPAQUE\nEND:VEVENT\nEND:VCALENDAR\n"; + + + if ( text ) { + ret = QString ( text ); + } + icalcomponent_free( calendar ); + + if (!text) { + setException(new ErrorFormat(ErrorFormat::SaveError, + i18n("libical error"))); + return QString::null; + } + + return ret; +} + +QString ICalFormat::toICalString( Incidence *incidence ) +{ + CalendarLocal cal( mTimeZoneId ); + cal.addIncidence( incidence->clone() ); + return toString( &cal ); +} + +QString ICalFormat::toString( Incidence *incidence ) +{ + icalcomponent *component; + + component = mImpl->writeIncidence( incidence ); + + const char *text = icalcomponent_as_ical_string( component ); + + icalcomponent_free( component ); + + return QString::fromLocal8Bit( text ); +} + +QString ICalFormat::toString( Recurrence *recurrence ) +{ + icalproperty *property; + property = mImpl->writeRecurrenceRule( recurrence ); + const char *text = icalproperty_as_ical_string( property ); + icalproperty_free( property ); + return QString::fromLocal8Bit( text ); +} +/* +bool ICalFormat::fromString( Recurrence * recurrence, const QString& rrule ) +{ + bool success = true; + icalerror_clear_errno(); + struct icalrecurrencetype recur = icalrecurrencetype_from_string( rrule ); + if ( icalerrno != ICAL_NO_ERROR ) { + kdDebug() << "Recurrence parsing error: " << icalerror_strerror( icalerrno ) << endl; + success = false; + } + + if ( success ) { + mImpl->readRecurrence( recur, recurrence ); + } + + return success; +} +*/ + +QString ICalFormat::createScheduleMessage(IncidenceBase *incidence, + Scheduler::Method method) +{ + icalcomponent *message = mImpl->createScheduleComponent(incidence,method); + + QString messageText = icalcomponent_as_ical_string(message); + + + + return messageText; +} + +ScheduleMessage *ICalFormat::parseScheduleMessage( Calendar *cal, + const QString &messageText ) +{ + setTimeZone( cal->timeZoneId(), !cal->isLocalTime() ); + clearException(); + + if (messageText.isEmpty()) return 0; + + icalcomponent *message; + message = icalparser_parse_string(messageText.local8Bit()); + + if (!message) return 0; + + icalproperty *m = icalcomponent_get_first_property(message, + ICAL_METHOD_PROPERTY); + + if (!m) return 0; + + icalcomponent *c; + + IncidenceBase *incidence = 0; + c = icalcomponent_get_first_component(message,ICAL_VEVENT_COMPONENT); + if (c) { + incidence = mImpl->readEvent(c); + } + + if (!incidence) { + c = icalcomponent_get_first_component(message,ICAL_VTODO_COMPONENT); + if (c) { + incidence = mImpl->readTodo(c); + } + } + + if (!incidence) { + c = icalcomponent_get_first_component(message,ICAL_VFREEBUSY_COMPONENT); + if (c) { + incidence = mImpl->readFreeBusy(c); + } + } + + if (!incidence) { + kdDebug() << "ICalFormat:parseScheduleMessage: object is not a freebusy, event or todo" << endl; + return 0; + } + + kdDebug(5800) << "ICalFormat::parseScheduleMessage() getting method..." << endl; + + icalproperty_method icalmethod = icalproperty_get_method(m); + Scheduler::Method method; + + switch (icalmethod) { + case ICAL_METHOD_PUBLISH: + method = Scheduler::Publish; + break; + case ICAL_METHOD_REQUEST: + method = Scheduler::Request; + break; + case ICAL_METHOD_REFRESH: + method = Scheduler::Refresh; + break; + case ICAL_METHOD_CANCEL: + method = Scheduler::Cancel; + break; + case ICAL_METHOD_ADD: + method = Scheduler::Add; + break; + case ICAL_METHOD_REPLY: + method = Scheduler::Reply; + break; + case ICAL_METHOD_COUNTER: + method = Scheduler::Counter; + break; + case ICAL_METHOD_DECLINECOUNTER: + method = Scheduler::Declinecounter; + break; + default: + method = Scheduler::NoMethod; + kdDebug(5800) << "ICalFormat::parseScheduleMessage(): Unknow method" << endl; + break; + } + + + if (!icalrestriction_check(message)) { + setException(new ErrorFormat(ErrorFormat::Restriction, + Scheduler::translatedMethodName(method) + ": " + + mImpl->extractErrorProperty(c))); + return 0; + } + + icalcomponent *calendarComponent = mImpl->createCalendarComponent(cal); + + Incidence *existingIncidence = cal->event(incidence->uid()); + if (existingIncidence) { + // TODO: check, if cast is required, or if it can be done by virtual funcs. + if (existingIncidence->type() == "Todo") { + Todo *todo = static_cast(existingIncidence); + icalcomponent_add_component(calendarComponent, + mImpl->writeTodo(todo)); + } + if (existingIncidence->type() == "Event") { + Event *event = static_cast(existingIncidence); + icalcomponent_add_component(calendarComponent, + mImpl->writeEvent(event)); + } + } else { + calendarComponent = 0; + } + + + icalclass result = icalclassify(message,calendarComponent,(char *)""); + + + ScheduleMessage::Status status; + + switch (result) { + case ICAL_PUBLISH_NEW_CLASS: + status = ScheduleMessage::PublishNew; + break; + case ICAL_OBSOLETE_CLASS: + status = ScheduleMessage::Obsolete; + break; + case ICAL_REQUEST_NEW_CLASS: + status = ScheduleMessage::RequestNew; + break; + case ICAL_REQUEST_UPDATE_CLASS: + status = ScheduleMessage::RequestUpdate; + break; + case ICAL_UNKNOWN_CLASS: + default: + status = ScheduleMessage::Unknown; + break; + } + + return new ScheduleMessage(incidence,method,status); +} + +void ICalFormat::setTimeZone( const QString &id, bool utc ) +{ + + + mTimeZoneId = id; + mUtc = utc; + + tzOffsetMin = KGlobal::locale()->timezoneOffset(mTimeZoneId); + + //qDebug("ICalFormat::setTimeZoneOffset %s %d ",mTimeZoneId.latin1(), tzOffsetMin); +} + +QString ICalFormat::timeZoneId() const +{ + return mTimeZoneId; +} + +bool ICalFormat::utc() const +{ + return mUtc; +} +int ICalFormat::timeOffset() +{ + return tzOffsetMin; +} +const char *ICalFormat::tzString() +{ + const char* ret = (const char* ) mTzString; + return ret; +} diff --git a/libkcal/icalformat.h b/libkcal/icalformat.h new file mode 100644 index 0000000..236efbf --- a/dev/null +++ b/libkcal/icalformat.h @@ -0,0 +1,116 @@ +/* + This file is part of libkcal. + Copyright (c) 2001 Cornelius Schumacher + + 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 ICALFORMAT_H +#define ICALFORMAT_H + +#include + +#include "scheduler.h" + +#include "calformat.h" + +namespace KCal { + +class ICalFormatImpl; + +/** + This class implements the iCalendar format. It provides methods for + loading/saving/converting iCalendar format data into the internal KOrganizer + representation as Calendar and Events. + + @short iCalendar format implementation +*/ +class ICalFormat : public CalFormat { + public: + /** Create new iCalendar format. */ + ICalFormat( bool quick = false ); + virtual ~ICalFormat(); + + /** + Loads a calendar on disk in iCalendar format into calendar. + Returns true if successful, else returns false. Provides more error + information by exception(). + @param calendar Calendar object to be filled. + @param fileName The name of the calendar file on disk. + */ + bool load( Calendar *, const QString &fileName ); + /** + Writes out the calendar to disk in iCalendar format. Returns true if + successful and false on error. + + @param calendar The Calendar object to be written. + @param fileName The name of the calendar file on disk. + */ + bool save( Calendar *, const QString &fileName ); + + /** + Parse string and populate calendar with that information. + */ + bool fromString( Calendar *, const QString & ); + /** + Parse string and return first ical component. + */ + Incidence *fromString( const QString & ); + /** + Return calendar information as string. + */ + QString toString( Calendar * ); + /** + Return incidence as full iCalendar formatted text. + */ + QString toICalString( Incidence * ); + /** + Return incidence as iCalendar formatted text. + */ + QString toString( Incidence * ); + /** + Return recurrence as iCalendar formatted text. + */ + QString toString( Recurrence * ); + /** + Parse string and fill recurrence object with + that information + */ + //bool fromString ( Recurrence *, const QString& ); + + /** Create a scheduling message for event \a e using method \m */ + QString createScheduleMessage(IncidenceBase *e,Scheduler::Method m); + /** Parse scheduling message provided as string \s */ + ScheduleMessage *parseScheduleMessage( Calendar *, const QString &s); + + /** Set id of used time zone and whether this time zone is UTC or not. */ + void setTimeZone( const QString &id, bool utc ); + QString timeZoneId() const; + int timeOffset(); + const char * tzString(); + bool utc() const; + + private: + ICalFormatImpl *mImpl; + bool mQuicksave; + QString mTimeZoneId; + QCString mTzString; + int tzOffsetMin; + bool mUtc; +}; + +} + +#endif diff --git a/libkcal/icalformatimpl.cpp b/libkcal/icalformatimpl.cpp new file mode 100644 index 0000000..e5c27a0 --- a/dev/null +++ b/libkcal/icalformatimpl.cpp @@ -0,0 +1,2173 @@ +/* + This file is part of libkcal. + Copyright (c) 2001 Cornelius Schumacher + + 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 +#include +#include +#include + +#include +#include +#include + +extern "C" { + #include + #include + #include + #include +} + +#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("TRANSPARENT")); + break; + case Event::Opaque: + icalcomponent_add_property(vevent, icalproperty_new_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 list = freebusy->busyPeriods(); + QValueList::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->zaurusId() >= 0) { + incidence->setNonKDECustomProperty("X-ZAURUSID", QString::number(incidence->zaurusId())); + } + + if (incidence->zaurusUid() > 0) { + incidence->setNonKDECustomProperty("X-ZAURUSUID", QString::number(incidence->zaurusUid())); + } + if (incidence->zaurusStat() > 0) { + incidence->setNonKDECustomProperty("X-ZAURUSSTAT", QString::number(incidence->zaurusStat())); + } + + 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 + const char *classStr; + switch (incidence->secrecy()) { + case Incidence::SecrecyPublic: + classStr = "PUBLIC"; + break; + case Incidence::SecrecyConfidential: + classStr = "CONFIDENTIAL"; + break; + case Incidence::SecrecyPrivate: + default: + classStr = "PRIVATE"; + break; + } + icalcomponent_add_property(parent,icalproperty_new_class(classStr)); + + // 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->relatedTo()) { + icalcomponent_add_property(parent,icalproperty_new_relatedto( + incidence->relatedTo()->uid().utf8())); + } + + // recurrence rule stuff + Recurrence *recur = incidence->recurrence(); + if (recur->doesRecur()) { + + icalcomponent_add_property(parent,writeRecurrenceRule(recur)); + } + + // recurrence excpetion dates + DateList dateList = incidence->exDates(); + DateList::ConstIterator exIt; + for(exIt = dateList.begin(); exIt != dateList.end(); ++exIt) { + icalcomponent_add_property(parent,icalproperty_new_exdate( + writeICalDate(*exIt))); + } + + // attachments + QPtrList attachments = incidence->attachments(); + for (Attachment *at = attachments.first(); at; at = attachments.next()) + icalcomponent_add_property(parent,writeAttachment(at)); + + // alarms + QPtrList 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)); + } + } + + // 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 al = incidenceBase->attendees(); + QPtrListIterator 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 custom = properties->customProperties(); + for (QMap::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) +{ + icalattachtype* attach = icalattachtype_new(); + if (att->isURI()) + icalattachtype_set_url(attach, att->uri().utf8().data()); + else + icalattachtype_set_base64(attach, att->data(), 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 tmpPositions; + QPtrList 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(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; + icalattachtype *attach = 0; + + switch (alarm->type()) { + case Alarm::Procedure: + action = ICAL_ACTION_PROCEDURE; + attach = icalattachtype_new(); + icalattachtype_set_url(attach,QFile::encodeName(alarm->programFile()).data()); + icalcomponent_add_property(a,icalproperty_new_attach(attach)); + icalattachtype_free(attach); + if (!alarm->programArguments().isEmpty()) { + icalcomponent_add_property(a,icalproperty_new_description(alarm->programArguments().utf8())); + } + break; + case Alarm::Audio: + action = ICAL_ACTION_AUDIO; + if (!alarm->audioFile().isEmpty()) { + attach = icalattachtype_new(); + icalattachtype_set_url(attach,QFile::encodeName( alarm->audioFile() ).data()); + icalcomponent_add_property(a,icalproperty_new_attach(attach)); + icalattachtype_free(attach); + } + break; + case Alarm::Email: { + action = ICAL_ACTION_EMAIL; + QValueList addresses = alarm->mailAddresses(); + for (QValueList::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 = icalattachtype_new(); + icalattachtype_set_url(attach,QFile::encodeName( *at ).data()); + icalcomponent_add_property(a,icalproperty_new_attach(attach)); + icalattachtype_free(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 custom = alarm->customProperties(); + for (QMap::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 + transparency = QString::fromUtf8(icalproperty_get_transp(p)); + if( transparency == "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); + + 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) +{ + icalattachtype *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); + + if (v == ICAL_VALUE_BINARY && e == ICAL_ENCODING_BASE64) + attachment = new Attachment(icalattachtype_get_base64(a)); + else if ((v == ICAL_VALUE_NONE || v == ICAL_VALUE_URI) && (e == ICAL_ENCODING_NONE || e == ICAL_ENCODING_8BIT)) { + attachment = new Attachment(QString(icalattachtype_get_url(a))); + } else { + kdWarning(5800) << "Unsupported attachment format, discarding it!" << endl; + return 0; + } + + icalparameter *p = icalproperty_get_first_parameter(attach, ICAL_FMTTYPE_PARAMETER); + if (p) + attachment->setMimeType(QString(icalparameter_get_fmttype(p))); + + return attachment; +} +#include +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; + +#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: + text = icalproperty_get_class(p); + if (strcmp(text,"PUBLIC") == 0) { + incidence->setSecrecy(Incidence::SecrecyPublic); + } else if (strcmp(text,"CONFIDENTIAL") == 0) { + 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-ZAURUSID"); + if (!kp.isNull()) { + incidence->setZaurusId(kp.toInt()); + } + + kp = incidence->nonKDECustomProperty("X-ZAURUSUID"); + if (!kp.isNull()) { + incidence->setZaurusUid(kp.toInt()); + } + + kp = incidence->nonKDECustomProperty("X-ZAURUSSTAT"); + if (!kp.isNull()) { + incidence->setZaurusStat(kp.toInt()); + } + + // Cancel backwards compatibility mode for subsequent changes by the application + 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 customProperties; + + icalproperty *p = icalcomponent_get_first_property(parent,ICAL_X_PROPERTY); + + while (p) { + + QString value = QString::fromUtf8(icalproperty_get_x(p)); + customProperties[icalproperty_get_name(p)] = value; + + 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; + } + } + + 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) { + 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) { + 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 { + 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: { + icalattachtype *attach = icalproperty_get_attach(p); + QString url = QFile::decodeName(icalattachtype_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.weeks = seconds % gSecondsPerWeek; + seconds -= d.weeks * gSecondsPerWeek; + d.days = seconds % gSecondsPerDay; + seconds -= d.days * gSecondsPerDay; + d.hours = seconds % gSecondsPerHour; + seconds -= d.hours * gSecondsPerHour; + d.minutes = seconds % gSecondsPerMinute; + seconds -= d.minutes * gSecondsPerMinute; + d.seconds = seconds; + d.is_neg = 0; + + 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(_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() ) { + ev->setRelatedTo(cal->event(ev->relatedToUid())); + } + Todo *todo; + for ( todo=mTodosRelate.first(); todo != 0; todo=mTodosRelate.next() ) { + todo->setRelatedTo(cal->todo(todo->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; + + + 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) + " "); + } + } + 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) + " "); + } + } + 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) + " "); + } + } + 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) + " "); + } + } + 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) { + out.append(QString::number(i) + " "); + } + } +} + +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: + + return message; + } + + icalcomponent_add_property(message,icalproperty_new_method(icalmethod)); + + // TODO: check, if dynamic cast is required + if(incidence->type() == "Todo") { + Todo *todo = static_cast(incidence); + icalcomponent_add_component(message,writeTodo(todo)); + } + if(incidence->type() == "Event") { + Event *event = static_cast(incidence); + icalcomponent_add_component(message,writeEvent(event)); + } + if(incidence->type() == "FreeBusy") { + FreeBusy *freebusy = static_cast(incidence); + icalcomponent_add_component(message,writeFreeBusy(freebusy, method)); + } + + return message; +} diff --git a/libkcal/icalformatimpl.h b/libkcal/icalformatimpl.h new file mode 100644 index 0000000..2f32365 --- a/dev/null +++ b/libkcal/icalformatimpl.h @@ -0,0 +1,109 @@ +/* + This file is part of libkcal. + Copyright (c) 2001 Cornelius Schumacher + + 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 ICALFORMATIMPL_H +#define ICALFORMATIMPL_H + +#include + +#include "scheduler.h" +#include "freebusy.h" + +extern "C" { + #include + #include +} + +namespace KCal { + +class Compat; + +/** + This class provides the libical dependent functions for ICalFormat. +*/ +class ICalFormatImpl { + public: + /** Create new iCal format for calendar object */ + ICalFormatImpl( ICalFormat *parent ); + virtual ~ICalFormatImpl(); + + bool populate( Calendar *, icalcomponent *fs); + + icalcomponent *writeIncidence(Incidence *incidence); + icalcomponent *writeTodo(Todo *todo); + icalcomponent *writeEvent(Event *event); + icalcomponent *writeFreeBusy(FreeBusy *freebusy, + Scheduler::Method method); + icalcomponent *writeJournal(Journal *journal); + void writeIncidence(icalcomponent *parent,Incidence *incidence); + icalproperty *writeAttendee(Attendee *attendee); + icalproperty *writeAttachment(Attachment *attach); + icalproperty *writeRecurrenceRule(Recurrence *); + icalproperty *writeAlarm(Alarm *alarm); + + QString extractErrorProperty(icalcomponent *); + Todo *readTodo(icalcomponent *vtodo); + Event *readEvent(icalcomponent *vevent); + FreeBusy *readFreeBusy(icalcomponent *vfreebusy); + Journal *readJournal(icalcomponent *vjournal); + Attendee *readAttendee(icalproperty *attendee); + Attachment *readAttachment(icalproperty *attach); + void readIncidence(icalcomponent *parent,Incidence *incidence); + void readRecurrenceRule(struct icalrecurrencetype rrule,Incidence *event); + void readRecurrence( const struct icalrecurrencetype &r, Recurrence* recur,Incidence *event ); + void readAlarm(icalcomponent *alarm,Incidence *incidence); + /** Return the PRODID string loaded from calendar file */ + const QString &loadedProductId() { return mLoadedProductId; } + + icaltimetype writeICalDate(const QDate &); + QDate readICalDate(icaltimetype); + icaltimetype writeICalDateTime(const QDateTime &); + QDateTime readICalDateTime(icaltimetype); + icaldurationtype writeICalDuration(int seconds); + int readICalDuration(icaldurationtype); + icalcomponent *createCalendarComponent(Calendar * = 0); + icalcomponent *createScheduleComponent(IncidenceBase *,Scheduler::Method); + + private: + void writeIncidenceBase(icalcomponent *parent,IncidenceBase *); + void readIncidenceBase(icalcomponent *parent,IncidenceBase *); + void writeCustomProperties(icalcomponent *parent,CustomProperties *); + void readCustomProperties(icalcomponent *parent,CustomProperties *); + void dumpIcalRecurrence(icalrecurrencetype); + + ICalFormat *mParent; + Calendar *mCalendar; + + QString mLoadedProductId; // PRODID string loaded from calendar file + int mCalendarVersion; // determines backward compatibility mode on read + + QPtrList mEventsRelate; // events with relations + QPtrList mTodosRelate; // todos with relations + + static const int mSecondsPerWeek; + static const int mSecondsPerDay; + static const int mSecondsPerHour; + static const int mSecondsPerMinute; + + Compat *mCompat; +}; + +} + +#endif diff --git a/libkcal/icalformatimpl.h.bup b/libkcal/icalformatimpl.h.bup new file mode 100644 index 0000000..37cf857 --- a/dev/null +++ b/libkcal/icalformatimpl.h.bup @@ -0,0 +1,109 @@ +/* + This file is part of libkcal. + Copyright (c) 2001 Cornelius Schumacher + + 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 ICALFORMATIMPL_H +#define ICALFORMATIMPL_H + +#include + +#include "scheduler.h" +#include "freebusy.h" + +extern "C" { + #include + #include +} + +namespace KCal { + +class Compat; + +/** + This class provides the libical dependent functions for ICalFormat. +*/ +class ICalFormatImpl { + public: + /** Create new iCal format for calendar object */ + ICalFormatImpl( ICalFormat *parent ); + virtual ~ICalFormatImpl(); + + bool populate( Calendar *, icalcomponent *fs); + + icalcomponent *writeIncidence(Incidence *incidence); + icalcomponent *writeTodo(Todo *todo); + icalcomponent *writeEvent(Event *event); + icalcomponent *writeFreeBusy(FreeBusy *freebusy, + Scheduler::Method method); + icalcomponent *writeJournal(Journal *journal); + void writeIncidence(icalcomponent *parent,Incidence *incidence); + icalproperty *writeAttendee(Attendee *attendee); + icalproperty *writeAttachment(Attachment *attach); + icalproperty *writeRecurrenceRule(Recurrence *); + icalproperty *writeAlarm(Alarm *alarm); + + QString extractErrorProperty(icalcomponent *); + Todo *readTodo(icalcomponent *vtodo); + Event *readEvent(icalcomponent *vevent); + FreeBusy *readFreeBusy(icalcomponent *vfreebusy); + Journal *readJournal(icalcomponent *vjournal); + Attendee *readAttendee(icalproperty *attendee); + Attachment *readAttachment(icalproperty *attach); + void readIncidence(icalcomponent *parent,Incidence *incidence); + void readRecurrenceRule(icalproperty *rrule,Incidence *event); + void readRecurrence( const struct icalrecurrencetype &r, Recurrence* recur ); + void readAlarm(icalcomponent *alarm,Incidence *incidence); + /** Return the PRODID string loaded from calendar file */ + const QString &loadedProductId() { return mLoadedProductId; } + + icaltimetype writeICalDate(const QDate &); + QDate readICalDate(icaltimetype); + icaltimetype writeICalDateTime(const QDateTime &); + QDateTime readICalDateTime(icaltimetype); + icaldurationtype writeICalDuration(int seconds); + int readICalDuration(icaldurationtype); + icalcomponent *createCalendarComponent(Calendar * = 0); + icalcomponent *createScheduleComponent(IncidenceBase *,Scheduler::Method); + + private: + void writeIncidenceBase(icalcomponent *parent,IncidenceBase *); + void readIncidenceBase(icalcomponent *parent,IncidenceBase *); + void writeCustomProperties(icalcomponent *parent,CustomProperties *); + void readCustomProperties(icalcomponent *parent,CustomProperties *); + void dumpIcalRecurrence(icalrecurrencetype); + + ICalFormat *mParent; + Calendar *mCalendar; + + QString mLoadedProductId; // PRODID string loaded from calendar file + int mCalendarVersion; // determines backward compatibility mode on read + + QPtrList mEventsRelate; // events with relations + QPtrList mTodosRelate; // todos with relations + + static const int mSecondsPerWeek; + static const int mSecondsPerDay; + static const int mSecondsPerHour; + static const int mSecondsPerMinute; + + Compat *mCompat; +}; + +} + +#endif diff --git a/libkcal/imipscheduler.cpp b/libkcal/imipscheduler.cpp new file mode 100644 index 0000000..e186f8e --- a/dev/null +++ b/libkcal/imipscheduler.cpp @@ -0,0 +1,58 @@ +/* + This file is part of libkcal. + Copyright (c) 2001 Cornelius Schumacher + + 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. +*/ + +// +// IMIPScheduler - iMIP implementation of iTIP methods +// + +#include "event.h" +#include "icalformat.h" + +#include "imipscheduler.h" + +using namespace KCal; + +IMIPScheduler::IMIPScheduler(Calendar *calendar) + : Scheduler(calendar) +{ +} + +IMIPScheduler::~IMIPScheduler() +{ +} + +bool IMIPScheduler::publish (IncidenceBase *incidence,const QString &recipients) +{ + return false; +} + +bool IMIPScheduler::performTransaction(IncidenceBase *incidence,Method method) +{ + mFormat->createScheduleMessage(incidence,method); + + return false; +} + +QPtrList IMIPScheduler::retrieveTransactions() +{ + QPtrList messageList; + + return messageList; +} diff --git a/libkcal/imipscheduler.h b/libkcal/imipscheduler.h new file mode 100644 index 0000000..f142060 --- a/dev/null +++ b/libkcal/imipscheduler.h @@ -0,0 +1,49 @@ +/* + This file is part of libkcal. + Copyright (c) 2001 Cornelius Schumacher + + 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 IMIPSCHEDULER_H +#define IMIPSCHEDULER_H +// +// iMIP implementation of iTIP methods +// + +#include + +#include "scheduler.h" + +namespace KCal { + +/* + This class implements the iTIP interface using the email interface specified + as iMIP. +*/ +class IMIPScheduler : public Scheduler { + public: + IMIPScheduler(Calendar *); + virtual ~IMIPScheduler(); + + bool publish (IncidenceBase *incidence,const QString &recipients); + bool performTransaction(IncidenceBase *incidence,Method method); + QPtrList retrieveTransactions(); +}; + +} + +#endif // IMIPSCHEDULER_H + diff --git a/libkcal/incidence.cpp b/libkcal/incidence.cpp new file mode 100644 index 0000000..d9bda64 --- a/dev/null +++ b/libkcal/incidence.cpp @@ -0,0 +1,594 @@ +/* + This file is part of libkcal. + Copyright (c) 2001 Cornelius Schumacher + + 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 +#include +#include + +#include "calformat.h" + +#include "incidence.h" +#include "todo.h" + +using namespace KCal; + +Incidence::Incidence() : + IncidenceBase(), + mRelatedTo(0), mSecrecy(SecrecyPublic), mPriority(3) +{ + mRecurrence = new Recurrence(this); + mCancelled = false; + recreate(); + mHasStartDate = true; + mAlarms.setAutoDelete(true); + mAttachments.setAutoDelete(true); +} + +Incidence::Incidence( const Incidence &i ) : IncidenceBase( i ) +{ +// TODO: reenable attributes currently commented out. + mRevision = i.mRevision; + mCreated = i.mCreated; + mDescription = i.mDescription; + mSummary = i.mSummary; + mCategories = i.mCategories; +// Incidence *mRelatedTo; Incidence *mRelatedTo; + mRelatedTo = 0; + mRelatedToUid = i.mRelatedToUid; +// QPtrList mRelations; QPtrList mRelations; + mExDates = i.mExDates; + mAttachments = i.mAttachments; + mResources = i.mResources; + mSecrecy = i.mSecrecy; + mPriority = i.mPriority; + mLocation = i.mLocation; + mCancelled = i.mCancelled; + mHasStartDate = i.mHasStartDate; + QPtrListIterator 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); + + mRecurrence = new Recurrence( *(i.mRecurrence), this ); +} + +Incidence::~Incidence() +{ + + Incidence *ev; + QPtrList Relations = relations(); + for (ev=Relations.first();ev;ev=Relations.next()) { + if (ev->relatedTo() == this) ev->setRelatedTo(0); + } + if (relatedTo()) relatedTo()->removeRelation(this); + delete mRecurrence; + +} + +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 a1( i1.alarms() ); + QPtrListIterator a2( i2.alarms() ); + for( ; a1.current() && a2.current(); ++a1, ++a2 ) { + if( *a1.current() == *a2.current() ) { + continue; + } + else { + return false; + } + } +#endif + + if ( ! operator==( (const IncidenceBase&)i1, (const IncidenceBase&)i2 ) ) + return false; + if ( i1.hasStartDate() == i2.hasStartDate() ) { + if ( i1.hasStartDate() ) { + if ( i1.dtStart() != i2.dtStart() ) + return false; + } + } else { + return false; + } + if (!( *i1.recurrence() == *i2.recurrence()) ) { + qDebug("recurrence is NOT equal "); + return false; + } + return + // i1.created() == i2.created() && + stringCompare( i1.description(), i2.description() ) && + stringCompare( i1.summary(), i2.summary() ) && + i1.categories() == i2.categories() && + // no need to compare mRelatedTo + stringCompare( i1.relatedToUid(), i2.relatedToUid() ) && + // i1.relations() == i2.relations() && + i1.exDates() == i2.exDates() && + i1.attachments() == i2.attachments() && + i1.resources() == i2.resources() && + i1.secrecy() == i2.secrecy() && + i1.priority() == i2.priority() && + stringCompare( i1.location(), i2.location() ); +} + + +void Incidence::recreate() +{ + setCreated(QDateTime::currentDateTime()); + + setUid(CalFormat::createUniqueId()); + + setRevision(0); + + setLastModified(QDateTime::currentDateTime()); +} + +void Incidence::setReadOnly( bool readOnly ) +{ + IncidenceBase::setReadOnly( readOnly ); + recurrence()->setRecurReadOnly( readOnly); +} + +void Incidence::setCreated(QDateTime created) +{ + if (mReadOnly) return; + mCreated = getEvenTime(created); +} + +QDateTime Incidence::created() const +{ + return mCreated; +} + +void Incidence::setRevision(int rev) +{ + if (mReadOnly) return; + mRevision = rev; + + updated(); +} + +int Incidence::revision() const +{ + return mRevision; +} + +void Incidence::setDtStart(const QDateTime &dtStart) +{ + + QDateTime dt = getEvenTime(dtStart); + recurrence()->setRecurStart( dt); + IncidenceBase::setDtStart( dt ); +} + +void Incidence::setDescription(const QString &description) +{ + if (mReadOnly) return; + mDescription = description; + updated(); +} + +QString Incidence::description() const +{ + return mDescription; +} + + +void Incidence::setSummary(const QString &summary) +{ + if (mReadOnly) return; + mSummary = summary; + updated(); +} + +QString Incidence::summary() const +{ + return mSummary; +} + +void Incidence::setCategories(const QStringList &categories) +{ + if (mReadOnly) return; + mCategories = categories; + updated(); +} + +// 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(); + } + + updated(); +} + +QStringList Incidence::categories() const +{ + return mCategories; +} + +QString Incidence::categoriesStr() +{ + return mCategories.join(","); +} + +void Incidence::setRelatedToUid(const QString &relatedToUid) +{ + if (mReadOnly) return; + mRelatedToUid = relatedToUid; +} + +QString Incidence::relatedToUid() const +{ + return mRelatedToUid; +} + +void Incidence::setRelatedTo(Incidence *relatedTo) +{ + //qDebug("Incidence::setRelatedTo %d ", relatedTo); + //qDebug("setRelatedTo(Incidence *relatedTo) %s %s", summary().latin1(), relatedTo->summary().latin1() ); + if (mReadOnly || mRelatedTo == relatedTo) return; + if(mRelatedTo) { + // updated(); + mRelatedTo->removeRelation(this); + } + mRelatedTo = relatedTo; + if (mRelatedTo) mRelatedTo->addRelation(this); +} + +Incidence *Incidence::relatedTo() const +{ + return mRelatedTo; +} + +QPtrList Incidence::relations() const +{ + return mRelations; +} + +void Incidence::addRelation(Incidence *event) +{ + if( mRelations.findRef( event ) == -1 ) { + mRelations.append(event); + //updated(); + } +} + +void Incidence::removeRelation(Incidence *event) +{ + + mRelations.removeRef(event); + +// if (event->getRelatedTo() == this) event->setRelatedTo(0); +} + +bool Incidence::recursOn(const QDate &qd) const +{ + if (recurrence()->recursOnPure(qd) && !isException(qd)) return true; + else return false; +} + +void Incidence::setExDates(const DateList &exDates) +{ + if (mReadOnly) return; + mExDates = exDates; + + recurrence()->setRecurExDatesCount(mExDates.count()); + + updated(); +} + +void Incidence::addExDate(const QDate &date) +{ + if (mReadOnly) return; + mExDates.append(date); + + recurrence()->setRecurExDatesCount(mExDates.count()); + + updated(); +} + +DateList Incidence::exDates() const +{ + return mExDates; +} + +bool Incidence::isException(const QDate &date) const +{ + DateList::ConstIterator it; + for( it = mExDates.begin(); it != mExDates.end(); ++it ) { + if ( (*it) == date ) { + return true; + } + } + + return false; +} + +void Incidence::addAttachment(Attachment *attachment) +{ + if (mReadOnly || !attachment) return; + mAttachments.append(attachment); + updated(); +} + +void Incidence::deleteAttachment(Attachment *attachment) +{ + mAttachments.removeRef(attachment); +} + +void Incidence::deleteAttachments(const QString& mime) +{ + Attachment *at = mAttachments.first(); + while (at) { + if (at->mimeType() == mime) + mAttachments.remove(); + else + at = mAttachments.next(); + } +} + +QPtrList Incidence::attachments() const +{ + return mAttachments; +} + +QPtrList Incidence::attachments(const QString& mime) const +{ + QPtrList attachments; + QPtrListIterator 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 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 it(mAlarms); (alarm = it.current()) != 0; ++it) { + if (alarm->enabled()) + return true; + } + return false; +} + +Recurrence *Incidence::recurrence() const +{ + return mRecurrence; +} + +void Incidence::setLocation(const QString &location) +{ + if (mReadOnly) return; + mLocation = location; + updated(); +} + +QString Incidence::location() const +{ + return mLocation; +} + +ushort Incidence::doesRecur() const +{ + if ( mRecurrence ) return mRecurrence->doesRecur(); + else return Recurrence::rNone; +} + +QDateTime Incidence::getNextOccurence( const QDateTime& dt, bool* ok ) const +{ + QDateTime incidenceStart = dt; + *ok = false; + if ( doesRecur() ) { + bool last; + recurrence()->getPreviousDateTime( incidenceStart , &last ); + int count = 0; + if ( !last ) { + while ( !last ) { + ++count; + incidenceStart = recurrence()->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 < 1980 || year > 5000 ) { + return QDateTime (); + } + incidenceStart = incidenceStart.addSecs( 1 ); + } + } + } else { + return QDateTime (); + } + } else { + if ( hasStartDate () ) { + incidenceStart = dtStart(); + + } + } + if ( incidenceStart > dt ) + *ok = true; + return incidenceStart; +} diff --git a/libkcal/incidence.h b/libkcal/incidence.h new file mode 100644 index 0000000..d1972cb --- a/dev/null +++ b/libkcal/incidence.h @@ -0,0 +1,298 @@ +/* + This file is part of libkcal. + Copyright (c) 2001 Cornelius Schumacher + + 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 INCIDENCE_H +#define INCIDENCE_H +// +// Incidence - base class of calendaring components +// + +#include +#include +#include + +#include "recurrence.h" +#include "alarm.h" +#include "attachment.h" +#include "listbase.h" +#include "incidencebase.h" + +namespace KCal { + +class Event; +class Todo; +class Journal; + +/** + This class provides the base class common to all calendar components. +*/ +class Incidence : public IncidenceBase +{ + public: + /** + This class provides the interface for a visitor of calendar components. It + serves as base class for concrete visitors, which implement certain actions on + calendar components. It allows to add functions, which operate on the concrete + types of calendar components, without changing the calendar component classes. + */ + class Visitor + { + public: + /** Destruct Incidence::Visitor */ + virtual ~Visitor() {} + + /** + Reimplement this function in your concrete subclass of IncidenceVisitor to perform actions + on an Event object. + */ + virtual bool visit(Event *) { return false; } + /** + Reimplement this function in your concrete subclass of IncidenceVisitor to perform actions + on an Todo object. + */ + virtual bool visit(Todo *) { return false; } + /** + Reimplement this function in your concrete subclass of IncidenceVisitor to perform actions + on an Journal object. + */ + virtual bool visit(Journal *) { return false; } + + protected: + /** Constructor is protected to prevent direct creation of visitor base class. */ + Visitor() {} + }; + + /** + This class implements a visitor for adding an Incidence to a resource + supporting addEvent(), addTodo() and addJournal() calls. + */ + template + class AddVisitor : public Visitor + { + public: + AddVisitor( T *r ) : mResource( r ) {} + bool visit( Event *e ) { return mResource->addEvent( e ); } + bool visit( Todo *t ) { return mResource->addTodo( t ); } + bool visit( Journal *j ) { return mResource->addJournal( j ); } + + private: + T *mResource; + }; + + /** enumeration for describing an event's secrecy. */ + enum { SecrecyPublic = 0, SecrecyPrivate = 1, SecrecyConfidential = 2 }; + typedef ListBase List; + Incidence(); + Incidence(const Incidence &); + ~Incidence(); + + /** + Accept IncidenceVisitor. A class taking part in the visitor mechanism has to + provide this implementation: + 
+        bool accept(Visitor &v) { return v.visit(this); }
+
+ */ + virtual bool accept(Visitor &) { return false; } + + virtual Incidence *clone() = 0; + + virtual QDateTime getNextAlarmDateTime( bool * ok, int * offset ) const = 0; + void setReadOnly( bool ); + + /** + Recreate event. The event is made a new unique event, but already stored + event information is preserved. Sets uniquie id, creation date, last + modification date and revision number. + */ + void recreate(); + + /** set creation date */ + void setCreated(QDateTime); + /** return time and date of creation. */ + QDateTime created() const; + + /** set the number of revisions this event has seen */ + void setRevision(int rev); + /** return the number of revisions this event has seen */ + int revision() const; + + /** Set starting date/time. */ + virtual void setDtStart(const QDateTime &dtStart); + /** Return the incidence's ending date/time as a QDateTime. */ + virtual QDateTime dtEnd() const { return QDateTime(); } + + /** sets the event's lengthy description. */ + void setDescription(const QString &description); + /** returns a reference to the event's description. */ + QString description() const; + + /** sets the event's short summary. */ + void setSummary(const QString &summary); + /** returns a reference to the event's summary. */ + QString summary() const; + + /** set event's applicable categories */ + void setCategories(const QStringList &categories); + /** set event's categories based on a comma delimited string */ + void setCategories(const QString &catStr); + /** return categories in a list */ + QStringList categories() const; + /** return categories as a comma separated string */ + QString categoriesStr(); + + /** point at some other event to which the event relates. This function should + * only be used when constructing a calendar before the related Event + * exists. */ + void setRelatedToUid(const QString &); + /** what event does this one relate to? This function should + * only be used when constructing a calendar before the related Event + * exists. */ + QString relatedToUid() const; + /** point at some other event to which the event relates */ + void setRelatedTo(Incidence *relatedTo); + /** what event does this one relate to? */ + Incidence *relatedTo() const; + /** All events that are related to this event */ + QPtrList relations() const; + /** Add an event which is related to this event */ + void addRelation(Incidence *); + /** Remove event that is related to this event */ + void removeRelation(Incidence *); + + /** returns the list of dates which are exceptions to the recurrence rule */ + DateList exDates() const; + /** sets the list of dates which are exceptions to the recurrence rule */ + void setExDates(const DateList &_exDates); + void setExDates(const char *dates); + /** Add a date to the list of exceptions of the recurrence rule. */ + void addExDate(const QDate &date); + + /** returns true if there is an exception for this date in the recurrence + rule set, or false otherwise. */ + bool isException(const QDate &qd) const; + + /** add attachment to this event */ + void addAttachment(Attachment *attachment); + /** remove and delete a specific attachment */ + void deleteAttachment(Attachment *attachment); + /** remove and delete all attachments with this mime type */ + void deleteAttachments(const QString& mime); + /** return list of all associated attachments */ + QPtrList attachments() const; + /** find a list of attachments with this mime type */ + QPtrList attachments(const QString& mime) const; + + /** sets the event's status the value specified. See the enumeration + * above for possible values. */ + void setSecrecy(int); + /** return the event's secrecy. */ + int secrecy() const; + /** return the event's secrecy in string format. */ + QString secrecyStr() const; + /** return list of all availbale secrecy classes */ + static QStringList secrecyList(); + /** return human-readable name of secrecy class */ + static QString secrecyName(int); + + /** returns TRUE if the date specified is one on which the event will + * recur. */ + bool recursOn(const QDate &qd) const; + + // VEVENT and VTODO, but not VJOURNAL (move to EventBase class?): + + /** set resources used, such as Office, Car, etc. */ + void setResources(const QStringList &resources); + /** return list of current resources */ + QStringList resources() const; + + /** set the event's priority, 0 is undefined, 1 highest (decreasing order) */ + void setPriority(int priority); + /** get the event's priority */ + int priority() const; + + /** All alarms that are associated with this incidence */ + QPtrList alarms() const; + /** Create a new alarm which is associated with this incidence */ + Alarm* newAlarm(); + /** Add an alarm which is associated with this incidence */ + void addAlarm(Alarm*); + /** Remove an alarm that is associated with this incidence */ + void removeAlarm(Alarm*); + /** Remove all alarms that are associated with this incidence */ + void clearAlarms(); + /** return whether any alarm associated with this incidence is enabled */ + bool isAlarmEnabled() const; + + /** + Return the recurrence rule associated with this incidence. If there is + none, returns an appropriate (non-0) object. + */ + Recurrence *recurrence() const; + + /** + Forward to Recurrence::doesRecur(). + */ + ushort doesRecur() const; + + /** set the event's/todo's location. Do _not_ use it with journal */ + void setLocation(const QString &location); + /** return the event's/todo's location. Do _not_ use it with journal */ + QString location() const; + /** returns TRUE or FALSE depending on whether the todo has a start date */ + bool hasStartDate() const; + /** sets the event's hasStartDate value. */ + void setHasStartDate(bool f); + QDateTime getNextOccurence( const QDateTime& dt, bool* yes ) const; + bool cancelled() const; + void setCancelled( bool b ); + +protected: + QPtrList mAlarms; + private: + int mRevision; + bool mCancelled; + + // base components of jounal, event and todo + QDateTime mCreated; + QString mDescription; + QString mSummary; + QStringList mCategories; + Incidence *mRelatedTo; + QString mRelatedToUid; + QPtrList mRelations; + DateList mExDates; + QPtrList mAttachments; + QStringList mResources; + bool mHasStartDate; // if todo has associated start date + + int mSecrecy; + int mPriority; // 1 = highest, 2 = less, etc. + + //QPtrList mAlarms; + Recurrence *mRecurrence; + + QString mLocation; +}; + +bool operator==( const Incidence&, const Incidence& ); + +} + +#endif diff --git a/libkcal/incidencebase.cpp b/libkcal/incidencebase.cpp new file mode 100644 index 0000000..9479048 --- a/dev/null +++ b/libkcal/incidencebase.cpp @@ -0,0 +1,393 @@ +/* + This file is part of libkcal. + Copyright (c) 2001 Cornelius Schumacher + + 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 +#include +#include + +#include "calformat.h" + +#include "incidencebase.h" + +using namespace KCal; + +IncidenceBase::IncidenceBase() : + mReadOnly(false), mFloats(true), mDuration(0), mHasDuration(false), + mPilotId(0), mSyncStatus(SYNCMOD) +{ + setUid(CalFormat::createUniqueId()); + mOrganizer = ""; + mFloats = false; + mDuration = 0; + mHasDuration = false; + mPilotId = 0; + mZaurusId = -1; + mZaurusUid = 0; + mZaurusStat = 0; + mSyncStatus = 0; + mAttendees.setAutoDelete( true ); +} + +IncidenceBase::IncidenceBase(const IncidenceBase &i) : + CustomProperties( i ) +{ + mReadOnly = i.mReadOnly; + mDtStart = i.mDtStart; + mDuration = i.mDuration; + mHasDuration = i.mHasDuration; + mOrganizer = i.mOrganizer; + mUid = i.mUid; + QPtrList attendees = i.attendees(); + for( Attendee *a = attendees.first(); a; a = attendees.next() ) { + mAttendees.append( new Attendee( *a ) ); + } + mFloats = i.mFloats; + mLastModified = i.mLastModified; + mPilotId = i.mPilotId; + mZaurusId = i.mZaurusId; + mZaurusUid = i.mZaurusUid; + mZaurusStat = i.mZaurusStat; + mSyncStatus = i.mSyncStatus; + + // The copied object is a new one, so it isn't observed by the observer + // of the original object. + mObservers.clear(); + + mAttendees.setAutoDelete( true ); +} + +IncidenceBase::~IncidenceBase() +{ +} + + +bool KCal::operator==( const IncidenceBase& i1, const IncidenceBase& i2 ) +{ + + if( i1.attendees().count() != i2.attendees().count() ) { + return false; // no need to check further + } + if ( i1.attendees().count() > 0 ) { + Attendee * a1 = i1.attendees().first(), *a2 =i2.attendees().first() ; + while ( a1 ) { + if ( !( (*a1) == (*a2)) ) + { + //qDebug("Attendee not equal "); + return false; + } + a1 = i1.attendees().next(); + a2 = i2.attendees().next(); + } + } + //if ( i1.dtStart() != i2.dtStart() ) + // return false; +#if 0 + qDebug("1 %d ",i1.doesFloat() == i2.doesFloat() ); + qDebug("1 %d ",i1.duration() == i2.duration() ); + qDebug("3 %d ",i1.hasDuration() == i2.hasDuration() ); + qDebug("1 %d ",i1.pilotId() == i2.pilotId() ); + qDebug("1 %d %d %d",i1.syncStatus() == i2.syncStatus() , i1.syncStatus(),i2.syncStatus() ); + qDebug("6 %d ",i1.organizer() == i2.organizer() ); + +#endif + return ( i1.organizer() == i2.organizer() && + // i1.uid() == i2.uid() && + // Don't compare lastModified, otherwise the operator is not + // of much use. We are not comparing for identity, after all. + i1.doesFloat() == i2.doesFloat() && + i1.duration() == i2.duration() && + i1.hasDuration() == i2.hasDuration() && + i1.pilotId() == i2.pilotId() );// && i1.syncStatus() == i2.syncStatus() ); + // no need to compare mObserver +} + + +QDateTime IncidenceBase::getEvenTime( QDateTime dt ) +{ + QTime t = dt.time(); + dt.setTime( QTime (t.hour (), t.minute (), t.second () ) ); + return dt; +} + + +void IncidenceBase::setUid(const QString &uid) +{ + mUid = uid; + updated(); +} + +QString IncidenceBase::uid() const +{ + return mUid; +} + +void IncidenceBase::setLastModified(const QDateTime &lm) +{ + // DON'T! updated() because we call this from + // Calendar::updateEvent(). + mLastModified = getEvenTime(lm); + //qDebug("IncidenceBase::setLastModified %s ",lm.toString().latin1()); +} + +QDateTime IncidenceBase::lastModified() const +{ + return mLastModified; +} + +void IncidenceBase::setOrganizer(const QString &o) +{ + // we don't check for readonly here, because it is + // possible that by setting the organizer we are changing + // the event's readonly status... + mOrganizer = o; + if (mOrganizer.left(7).upper() == "MAILTO:") + mOrganizer = mOrganizer.remove(0,7); + + updated(); +} + +QString IncidenceBase::organizer() const +{ + return mOrganizer; +} + +void IncidenceBase::setReadOnly( bool readOnly ) +{ + mReadOnly = readOnly; +} + +void IncidenceBase::setDtStart(const QDateTime &dtStart) +{ +// if (mReadOnly) return; + mDtStart = getEvenTime(dtStart); + updated(); +} + +QDateTime IncidenceBase::dtStart() const +{ + return mDtStart; +} + +QString IncidenceBase::dtStartTimeStr() const +{ + return KGlobal::locale()->formatTime(dtStart().time()); +} + +QString IncidenceBase::dtStartDateStr(bool shortfmt) const +{ + return KGlobal::locale()->formatDate(dtStart().date(),shortfmt); +} + +QString IncidenceBase::dtStartStr(bool shortfmt) const +{ + return KGlobal::locale()->formatDateTime(dtStart(), shortfmt); +} + + +bool IncidenceBase::doesFloat() const +{ + return mFloats; +} + +void IncidenceBase::setFloats(bool f) +{ + if (mReadOnly) return; + mFloats = f; + updated(); +} + + +void IncidenceBase::addAttendee(Attendee *a, bool doupdate) +{ + if (mReadOnly) return; + if (a->name().left(7).upper() == "MAILTO:") + a->setName(a->name().remove(0,7)); + + mAttendees.append(a); + if (doupdate) updated(); +} + +#if 0 +void IncidenceBase::removeAttendee(Attendee *a) +{ + if (mReadOnly) return; + mAttendees.removeRef(a); + updated(); +} + +void IncidenceBase::removeAttendee(const char *n) +{ + Attendee *a; + + if (mReadOnly) return; + for (a = mAttendees.first(); a; a = mAttendees.next()) + if (a->getName() == n) { + mAttendees.remove(); + break; + } +} +#endif + +void IncidenceBase::clearAttendees() +{ + if (mReadOnly) return; + mAttendees.clear(); +} + +#if 0 +Attendee *IncidenceBase::getAttendee(const char *n) const +{ + QPtrListIterator qli(mAttendees); + + qli.toFirst(); + while (qli) { + if (qli.current()->getName() == n) + return qli.current(); + ++qli; + } + return 0L; +} +#endif + +Attendee *IncidenceBase::attendeeByMail(const QString &email) +{ + QPtrListIterator qli(mAttendees); + + qli.toFirst(); + while (qli) { + if (qli.current()->email() == email) + return qli.current(); + ++qli; + } + return 0L; +} + +Attendee *IncidenceBase::attendeeByMails(const QStringList &emails, const QString& email) +{ + QPtrListIterator qli(mAttendees); + + QStringList mails = emails; + if (!email.isEmpty()) { + mails.append(email); + } + qli.toFirst(); + while (qli) { + for ( QStringList::Iterator it = mails.begin(); it != mails.end(); ++it ) { + if (qli.current()->email() == *it) + return qli.current(); + } + + ++qli; + } + return 0L; +} + +void IncidenceBase::setDuration(int seconds) +{ + mDuration = seconds; + setHasDuration(true); +} + +int IncidenceBase::duration() const +{ + return mDuration; +} + +void IncidenceBase::setHasDuration(bool b) +{ + mHasDuration = b; +} + +bool IncidenceBase::hasDuration() const +{ + return mHasDuration; +} + +void IncidenceBase::setSyncStatus(int stat) +{ + if (mReadOnly) return; + mSyncStatus = stat; +} + +int IncidenceBase::syncStatus() const +{ + return mSyncStatus; +} + +void IncidenceBase::setPilotId( int id ) +{ + if (mReadOnly) return; + mPilotId = id; +} + +int IncidenceBase::pilotId() const +{ + return mPilotId; +} +void IncidenceBase::setZaurusId( int id ) +{ + if (mReadOnly) return; + mZaurusId = id; +} + +int IncidenceBase::zaurusId() const +{ + return mZaurusId; +} + +int IncidenceBase::zaurusUid() const +{ + return mZaurusUid; +} +void IncidenceBase::setZaurusUid( int id ) +{ + if (mReadOnly) return; + mZaurusUid = id; +} + +int IncidenceBase::zaurusStat() const +{ + return mZaurusStat; +} +void IncidenceBase::setZaurusStat( int id ) +{ + if (mReadOnly) return; + mZaurusStat = id; +} + +void IncidenceBase::registerObserver( IncidenceBase::Observer *observer ) +{ + if( !mObservers.contains(observer) ) mObservers.append( observer ); +} + +void IncidenceBase::unRegisterObserver( IncidenceBase::Observer *observer ) +{ + mObservers.remove( observer ); +} + +void IncidenceBase::updated() +{ + QPtrListIterator it(mObservers); + while( it.current() ) { + Observer *o = it.current(); + ++it; + o->incidenceUpdated( this ); + } +} diff --git a/libkcal/incidencebase.h b/libkcal/incidencebase.h new file mode 100644 index 0000000..0ab7eef --- a/dev/null +++ b/libkcal/incidencebase.h @@ -0,0 +1,170 @@ +/* + This file is part of libkcal. + Copyright (c) 2001 Cornelius Schumacher + + 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_INCIDENCEBASE_H +#define KCAL_INCIDENCEBASE_H +// +// Incidence - base class of calendaring components +// + +#include +#include +#include +#include + +#include "customproperties.h" +#include "attendee.h" + +namespace KCal { + +typedef QValueList DateList; + +/** + This class provides the base class common to all calendar components. +*/ +class IncidenceBase : public CustomProperties +{ + public: + class Observer { + public: + virtual void incidenceUpdated( IncidenceBase * ) = 0; + }; + + IncidenceBase(); + IncidenceBase(const IncidenceBase &); + virtual ~IncidenceBase(); + + virtual QCString type() const = 0; + + /** Set the unique id for the event */ + void setUid(const QString &); + /** Return the unique id for the event */ + QString uid() const; + + /** Sets the time the incidence was last modified. */ + void setLastModified(const QDateTime &lm); + /** Return the time the incidence was last modified. */ + QDateTime lastModified() const; + + /** sets the organizer for the event */ + void setOrganizer(const QString &o); + QString organizer() const; + + /** Set readonly status. */ + virtual void setReadOnly( bool ); + /** Return if the object is read-only. */ + bool isReadOnly() const { return mReadOnly; } + + /** for setting the event's starting date/time with a QDateTime. */ + virtual void setDtStart(const QDateTime &dtStart); + /** returns an event's starting date/time as a QDateTime. */ + QDateTime dtStart() const; + /** returns an event's starting time as a string formatted according to the + users locale settings */ + QString dtStartTimeStr() const; + /** returns an event's starting date as a string formatted according to the + users locale settings */ + QString dtStartDateStr(bool shortfmt=true) const; + /** returns an event's starting date and time as a string formatted according + to the users locale settings */ + QString dtStartStr(bool shortfmt=true) const; + + virtual void setDuration(int seconds); + int duration() const; + void setHasDuration(bool); + bool hasDuration() const; + + /** Return true or false depending on whether the incidence "floats," + * i.e. has a date but no time attached to it. */ + bool doesFloat() const; + /** Set whether the incidence floats, i.e. has a date but no time attached to it. */ + void setFloats(bool f); + + /** + Add Attendee to this incidence. IncidenceBase takes ownership of the + Attendee object. + */ + void addAttendee(Attendee *a, bool doupdate=true ); +// void removeAttendee(Attendee *a); +// void removeAttendee(const char *n); + /** Remove all Attendees. */ + void clearAttendees(); + /** Return list of attendees. */ + QPtrList attendees() const { return mAttendees; }; + /** Return number of attendees. */ + int attendeeCount() const { return mAttendees.count(); }; + /** Return the Attendee with this email */ + Attendee* attendeeByMail(const QString &); + /** Return first Attendee with one of this emails */ + Attendee* attendeeByMails(const QStringList &, const QString& email = QString::null); + + /** pilot syncronization states */ + enum { SYNCNONE = 0, SYNCMOD = 1, SYNCDEL = 3 }; + /** Set synchronisation satus. */ + void setSyncStatus(int stat); + /** Return synchronisation status. */ + int syncStatus() const; + + /** Set Pilot Id. */ + void setPilotId(int id); + /** Return Pilot Id. */ + int pilotId() const; + + void setZaurusId(int id); + int zaurusId() const; + void setZaurusUid(int id); + int zaurusUid() const; + void setZaurusStat(int id); + int zaurusStat() const; + + void registerObserver( Observer * ); + void unRegisterObserver( Observer * ); + void updated(); + + protected: + bool mReadOnly; + QDateTime getEvenTime( QDateTime ); + + private: + // base components + QDateTime mDtStart; + QString mOrganizer; + QString mUid; + QDateTime mLastModified; + QPtrList mAttendees; + + bool mFloats; + + int mDuration; + bool mHasDuration; + int mZaurusId; + int mZaurusUid; + int mZaurusStat; + + // PILOT SYNCHRONIZATION STUFF + int mPilotId; // unique id for pilot sync + int mSyncStatus; // status (for sync) + + QPtrList mObservers; +}; + +bool operator==( const IncidenceBase&, const IncidenceBase& ); +} + +#endif diff --git a/libkcal/journal.cpp b/libkcal/journal.cpp new file mode 100644 index 0000000..351fb32 --- a/dev/null +++ b/libkcal/journal.cpp @@ -0,0 +1,49 @@ +/* + This file is part of libkcal. + Copyright (c) 2001 Cornelius Schumacher + + 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 "journal.h" + +using namespace KCal; + +Journal::Journal() +{ +} + +Journal::~Journal() +{ +} + +Incidence *Journal::clone() +{ + return new Journal(*this); +} + + +bool KCal::operator==( const Journal& j1, const Journal& j2 ) +{ + return operator==( (const Incidence&)j1, (const Incidence&)j2 ); +} + + +QDateTime Journal::getNextAlarmDateTime( bool * ok, int * offset ) const +{ + *ok = false; + return QDateTime (); +} diff --git a/libkcal/journal.h b/libkcal/journal.h new file mode 100644 index 0000000..cb90c7a --- a/dev/null +++ b/libkcal/journal.h @@ -0,0 +1,50 @@ +/* + This file is part of libkcal. + Copyright (c) 2001 Cornelius Schumacher + + 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 JOURNAL_H +#define JOURNAL_H +// +// Journal component, representing a VJOURNAL object +// + +#include "incidence.h" + +namespace KCal { + +/** + This class provides a Journal in the sense of RFC2445. +*/ +class Journal : public Incidence +{ + public: + Journal(); + ~Journal(); + + QCString type() const { return "Journal"; } + + Incidence *clone(); + QDateTime getNextAlarmDateTime( bool * ok, int * offset ) const; +private: + bool accept(Visitor &v) { return v.visit(this); } +}; + + bool operator==( const Journal&, const Journal& ); +} + +#endif diff --git a/libkcal/kcal.pro.back b/libkcal/kcal.pro.back new file mode 100644 index 0000000..a33c5f9 --- a/dev/null +++ b/libkcal/kcal.pro.back @@ -0,0 +1,84 @@ +TEMPLATE = lib +CONFIG = qt warn_on release +TARGET = kcal +INCLUDEPATH += ../microkde ../qtcompat versit +INCLUDEPATH += ../libical/src/libical +INCLUDEPATH += ../libical/src/libicalss +OBJECTS_DIR = obj/$(PLATFORM) +MOC_DIR = moc +DESTDIR = $(QPEDIR)/lib +LIBS += -lical +LIBS += -licalss + +INTERFACES = \ + +HEADERS = \ + alarm.h \ + attachment.h \ + attendee.h \ + calendar.h \ + calendarlocal.h \ + calfilter.h \ + calformat.h \ + calstorage.h \ + compat.h \ + customproperties.h \ + dummyscheduler.h \ + duration.h \ + event.h \ + exceptions.h \ + filestorage.h \ + freebusy.h \ + icaldrag.h \ + icalformat.h \ + icalformatimpl.h \ + imipscheduler.h \ + incidence.h \ + incidencebase.h \ + journal.h \ + period.h \ + person.h \ + qtopiaformat.h \ + recurrence.h \ + scheduler.h \ + todo.h \ + vcaldrag.h \ + vcalformat.h \ + versit/port.h \ + versit/vcc.h \ + versit/vobject.h \ + +SOURCES = \ + alarm.cpp \ + attachment.cpp \ + attendee.cpp \ + calendar.cpp \ + calendarlocal.cpp \ + calfilter.cpp \ + calformat.cpp \ + compat.cpp \ + customproperties.cpp \ + dummyscheduler.cpp \ + duration.cpp \ + event.cpp \ + exceptions.cpp \ + filestorage.cpp \ + freebusy.cpp \ + icaldrag.cpp \ + icalformat.cpp \ + icalformatimpl.cpp \ + imipscheduler.cpp \ + incidence.cpp \ + incidencebase.cpp \ + journal.cpp \ + period.cpp \ + person.cpp \ + qtopiaformat.cpp \ + recurrence.cpp \ + scheduler.cpp \ + todo.cpp \ + vcaldrag.cpp \ + vcalformat.cpp \ + versit/vcc.c \ + versit/vobject.c \ + diff --git a/libkcal/libkcal.pro b/libkcal/libkcal.pro new file mode 100644 index 0000000..49aa24b --- a/dev/null +++ b/libkcal/libkcal.pro @@ -0,0 +1,100 @@ +TEMPLATE = lib +CONFIG += qt warn_on +TARGET = microkcal + +include( ../variables.pri ) + +INCLUDEPATH += ../microkde versit ../microkde/kdecore +#../qtcompat +INCLUDEPATH += ../libical/src/libical +INCLUDEPATH += ../libical/src/libicalss +DESTDIR = ../bin +DEFINES += DESKTOP_VERSION +unix: { +LIBS += ../libical/lib/libical.a +LIBS += ../libical/lib/libicalss.a +OBJECTS_DIR = obj/unix +MOC_DIR = moc/unix +} +win32: { +DEFINES += _WIN32_ + +LIBS += ../libical/lib/ical.lib +LIBS += ../libical/lib/icalss.lib +OBJECTS_DIR = obj/win +MOC_DIR = moc/win + +} + +INTERFACES = \ + +HEADERS = \ + alarm.h \ + attachment.h \ + attendee.h \ + calendar.h \ + calendarlocal.h \ + calfilter.h \ + calformat.h \ + calstorage.h \ + compat.h \ + customproperties.h \ + dummyscheduler.h \ + duration.h \ + event.h \ + exceptions.h \ + filestorage.h \ + freebusy.h \ + icaldrag.h \ + icalformat.h \ + icalformatimpl.h \ + imipscheduler.h \ + incidence.h \ + incidencebase.h \ + journal.h \ + period.h \ + person.h \ + qtopiaformat.h \ + recurrence.h \ + scheduler.h \ + todo.h \ + vcaldrag.h \ + vcalformat.h \ + versit/port.h \ + versit/vcc.h \ + versit/vobject.h \ + +SOURCES = \ + alarm.cpp \ + attachment.cpp \ + attendee.cpp \ + calendar.cpp \ + calendarlocal.cpp \ + calfilter.cpp \ + calformat.cpp \ + compat.cpp \ + customproperties.cpp \ + dummyscheduler.cpp \ + duration.cpp \ + event.cpp \ + exceptions.cpp \ + filestorage.cpp \ + freebusy.cpp \ + icaldrag.cpp \ + icalformat.cpp \ + icalformatimpl.cpp \ + imipscheduler.cpp \ + incidence.cpp \ + incidencebase.cpp \ + journal.cpp \ + period.cpp \ + person.cpp \ + qtopiaformat.cpp \ + recurrence.cpp \ + scheduler.cpp \ + todo.cpp \ + vcaldrag.cpp \ + vcalformat.cpp \ + versit/vcc.c \ + versit/vobject.c \ + diff --git a/libkcal/libkcalE.pro b/libkcal/libkcalE.pro new file mode 100644 index 0000000..e27c10f --- a/dev/null +++ b/libkcal/libkcalE.pro @@ -0,0 +1,88 @@ +TEMPLATE = lib +CONFIG += qt warn_on +TARGET = microkcal + + +INCLUDEPATH += ../microkde ../qtcompat versit ../microkde/kdecore versit $(QPEDIR)/include +INCLUDEPATH += ../libical/src/libical +INCLUDEPATH += ../libical/src/libicalss +OBJECTS_DIR = obj/$(PLATFORM) +MOC_DIR = moc/$(PLATFORM) +DESTDIR = $(QPEDIR)/lib +LIBS += ../libical/lib/$(PLATFORM)/libical.a +LIBS += ../libical/lib/$(PLATFORM)/libicalss.a + +INTERFACES = \ + +HEADERS = \ + alarm.h \ + attachment.h \ + attendee.h \ + calendar.h \ + calendarlocal.h \ + calfilter.h \ + calformat.h \ + calstorage.h \ + compat.h \ + customproperties.h \ + dummyscheduler.h \ + duration.h \ + event.h \ + exceptions.h \ + filestorage.h \ + freebusy.h \ + icaldrag.h \ + icalformat.h \ + icalformatimpl.h \ + imipscheduler.h \ + incidence.h \ + incidencebase.h \ + journal.h \ + period.h \ + person.h \ + qtopiaformat.h \ + sharpformat.h \ + recurrence.h \ + scheduler.h \ + todo.h \ + vcaldrag.h \ + vcalformat.h \ + versit/port.h \ + versit/vcc.h \ + versit/vobject.h \ + +SOURCES = \ + alarm.cpp \ + attachment.cpp \ + attendee.cpp \ + calendar.cpp \ + calendarlocal.cpp \ + calfilter.cpp \ + calformat.cpp \ + compat.cpp \ + customproperties.cpp \ + dummyscheduler.cpp \ + duration.cpp \ + event.cpp \ + exceptions.cpp \ + filestorage.cpp \ + freebusy.cpp \ + icaldrag.cpp \ + icalformat.cpp \ + icalformatimpl.cpp \ + imipscheduler.cpp \ + incidence.cpp \ + incidencebase.cpp \ + journal.cpp \ + period.cpp \ + person.cpp \ + qtopiaformat.cpp \ + sharpformat.cpp \ + recurrence.cpp \ + scheduler.cpp \ + todo.cpp \ + vcaldrag.cpp \ + vcalformat.cpp \ + versit/vcc.c \ + versit/vobject.c \ + diff --git a/libkcal/listbase.h b/libkcal/listbase.h new file mode 100644 index 0000000..085b13d --- a/dev/null +++ b/libkcal/listbase.h @@ -0,0 +1,97 @@ +/* + This file is part of libkcal. + + Copyright (c) 2003 Cornelius Schumacher + + 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_LISTBASE_H +#define KCAL_LISTBASE_H + +#include + +namespace KCal { + class Event; + class Todo; +/** + This class provides a template for lists of pointers. It extends QValueList by auto delete funtionality known from QPtrList. +*/ +template +class ListBase : public QValueList +{ + public: + ListBase() + : QValueList(), mAutoDelete( false ) + { + } + + ListBase( const ListBase &l ) + : QValueList( l ), mAutoDelete( false ) + { + } + + ~ListBase() + { + if ( mAutoDelete ) { + QValueListIterator it; + for( it = QValueList::begin(); it != QValueList::end(); ++it ) { + delete *it; + } + } + } + + ListBase &operator=( const ListBase &l ) + { + if ( this == &l ) return *this; + QValueList::operator=( l ); + return *this; + } + + void setAutoDelete( bool autoDelete ) + { + mAutoDelete = autoDelete; + } + + bool removeRef( T *t ) + { + QValueListIterator it = find( t ); + if ( it == QValueList::end() ) { + return false; + } else { + if ( mAutoDelete ) delete t; + remove( it ); + return true; + } + } + void fill ( QPtrList list ) { + QPtrListIterator it (list); + T *item; + while ( (item = it.current()) != 0 ) { + append( item ); + ++it; + } + + } + + + private: + bool mAutoDelete; +}; + +} + +#endif diff --git a/libkcal/period.cpp b/libkcal/period.cpp new file mode 100644 index 0000000..d188a4c --- a/dev/null +++ b/libkcal/period.cpp @@ -0,0 +1,65 @@ +/* + This file is part of libkcal. + Copyright (c) 2001 Cornelius Schumacher + + 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 +#include + +#include "period.h" + +using namespace KCal; + +Period::Period() +{ + mHasDuration = false; +} + +Period::Period( const QDateTime &start, const QDateTime &end ) +{ + mStart = start; + mEnd = end; + mHasDuration = false; +} + +Period::Period( const QDateTime &start, const Duration &duration ) +{ + mStart = start; + mEnd = duration.end( start ); + mHasDuration = true; +} + +QDateTime Period::start() const +{ + return mStart; +} + +QDateTime Period::end()const +{ + return mEnd; +} + +Duration Period::duration() +{ + return Duration( mStart, mEnd ); +} + +bool Period::hasDuration()const +{ + return mHasDuration; +} diff --git a/libkcal/period.h b/libkcal/period.h new file mode 100644 index 0000000..9d40f12 --- a/dev/null +++ b/libkcal/period.h @@ -0,0 +1,51 @@ +/* + This file is part of libkcal. + Copyright (c) 2001 Cornelius Schumacher + + 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_PERIOD_H +#define KCAL_PERIOD_H + +#include + +#include "duration.h" + +namespace KCal { + +class Period +{ + public: + Period(); + Period( const QDateTime &start, const QDateTime &end ); + Period( const QDateTime &start, const Duration &duration ); + + QDateTime start()const; + QDateTime end()const; + Duration duration(); + + bool hasDuration()const; + + private: + QDateTime mStart; + QDateTime mEnd; + + bool mHasDuration; +}; + +} + +#endif diff --git a/libkcal/person.cpp b/libkcal/person.cpp new file mode 100644 index 0000000..aca28c2 --- a/dev/null +++ b/libkcal/person.cpp @@ -0,0 +1,77 @@ +/* + This file is part of libkcal. + Copyright (c) 2001 Cornelius Schumacher + + 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 +#include + +#include "person.h" + +using namespace KCal; + +Person::Person( const QString &fullName ) +{ + int emailPos = fullName.find( '<' ); + if ( emailPos < 0 ) { + setEmail(fullName); + } else { + setEmail(fullName.mid( emailPos + 1, fullName.length() - 1 )); + setName(fullName.left( emailPos - 2 )); + } +} + +Person::Person( const QString &name, const QString &email ) +{ + setName(name); + setEmail(email); +} + + +bool KCal::operator==( const Person& p1, const Person& p2 ) +{ + return ( p1.name() == p2.name() && + p1.email() == p2.email() ); +} + + +QString Person::fullName() const +{ + if( mName.isEmpty() ) { + return mEmail; + } else { + if( mEmail.isEmpty() ) + return mName; + else + return mName + " <" + mEmail + ">"; + } +} + +void Person::setName(const QString &name) +{ + mName = name; +} + +void Person::setEmail(const QString &email) +{ + if (email.left(7).lower() == "mailto:") { + mEmail = email.mid(7); + } else { + mEmail = email; + } +} diff --git a/libkcal/person.h b/libkcal/person.h new file mode 100644 index 0000000..c46c5f0 --- a/dev/null +++ b/libkcal/person.h @@ -0,0 +1,50 @@ +/* + This file is part of libkcal. + Copyright (c) 2001 Cornelius Schumacher + + 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_PERSON_H +#define KCAL_PERSON_H + +#include + +namespace KCal { + +class Person +{ + public: + Person() {} + Person( const QString &fullName ); + Person( const QString &name, const QString &email ); + + QString fullName( ) const; + + void setName(const QString &); + QString name() const { return mName; } + + void setEmail(const QString &); + QString email() const { return mEmail; } + + private: + QString mName; + QString mEmail; +}; + + bool operator==( const Person& p1, const Person& p2 ); +} + +#endif diff --git a/libkcal/qtopiaformat.cpp b/libkcal/qtopiaformat.cpp new file mode 100644 index 0000000..0a4a031 --- a/dev/null +++ b/libkcal/qtopiaformat.cpp @@ -0,0 +1,333 @@ +/* + This file is part of libkcal. + + Copyright (c) 2003 Cornelius Schumacher + + 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 +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include "calendar.h" +#include "calendarlocal.h" + +#include "qtopiaformat.h" + +using namespace KCal; + +class QtopiaParser : public QXmlDefaultHandler +{ + public: + QtopiaParser( Calendar *calendar ) : mCalendar( calendar ) { + oldCategories = 0; + } + + bool startElement( const QString &, const QString &, const QString & qName, + const QXmlAttributes &attributes ) + { + if ( qName == "event" ) { + Event *event = new Event; + QString uid = "Qtopia" + attributes.value( "uid" ); + // event->setUid( uid ); + + event->setSummary( attributes.value( "description" ) ); + event->setLocation( attributes.value( "location" ) ); + event->setDescription( attributes.value( "note" ) ); + event->setDtStart( toDateTime( attributes.value( "start" ) ) ); + event->setDtEnd( toDateTime( attributes.value( "end" ) ) ); + + if ( attributes.value( "type" ) == "AllDay" ) { + event->setFloats( true ); + } else { + event->setFloats( false ); + } + + QString rtype = attributes.value( "rtype" ); + if ( !rtype.isEmpty() ) { + QDate startDate = event->dtStart().date(); + + QString freqStr = attributes.value( "rfreq" ); + int freq = freqStr.toInt(); + + QString hasEndDateStr = attributes.value( "rhasenddate" ); + bool hasEndDate = hasEndDateStr == "1"; + + QString endDateStr = attributes.value( "enddt" ); + QDate endDate = toDateTime( endDateStr ).date(); + + QString weekDaysStr = attributes.value( "rweekdays" ); + int weekDaysNum = weekDaysStr.toInt(); + if ( weekDaysNum == 0 ) + weekDaysNum = (1 << (event->dtStart().date().dayOfWeek()-1)); + + QBitArray weekDays( 7 ); + weekDays.fill( false ); + int i; + for( i = 0; i < 7; ++i ) { + weekDays.setBit( i , ( 1 << i ) & weekDaysNum ); + qDebug("%d %d %d ",i, weekDaysNum, weekDays.at(i) ); + } + + QString posStr = attributes.value( "rposition" ); + int pos = posStr.toInt(); + + Recurrence *r = event->recurrence(); + + if ( rtype == "Daily" ) { + if ( hasEndDate ) r->setDaily( freq, endDate ); + else r->setDaily( freq, -1 ); + } else if ( rtype == "Weekly" ) { + // fix needed here + // rweekdays not set in XML file + if ( hasEndDate ) r->setWeekly( freq, weekDays, endDate ); + else r->setWeekly( freq, weekDays, -1 ); + } else if ( rtype == "MonthlyDate" ) { + if ( hasEndDate ) + r->setMonthly( Recurrence::rMonthlyDay, freq, endDate ); + else + r->setMonthly( Recurrence::rMonthlyDay, freq, -1 ); + r->addMonthlyDay( startDate.day() ); + } else if ( rtype == "MonthlyDay" ) { + if ( hasEndDate ) + r->setMonthly( Recurrence::rMonthlyPos, freq, endDate ); + else + r->setMonthly( Recurrence::rMonthlyPos, freq, -1 ); + QBitArray days( 7 ); + days.fill( false ); + days.setBit( startDate.dayOfWeek() - 1 ); + r->addMonthlyPos( pos, days ); + } else if ( rtype == "Yearly" ) { + if ( hasEndDate ) + r->setYearly( Recurrence::rYearlyMonth, freq, endDate ); + else + r->setYearly( Recurrence::rYearlyMonth, freq, -1 ); + r->addYearlyNum( startDate.month() ); + } + } + + QString categoryList = attributes.value( "categories" ); + event->setCategories( lookupCategories( categoryList ) ); + + QString alarmStr = attributes.value( "alarm" ); + if ( !alarmStr.isEmpty() ) { + Alarm *alarm = new Alarm( event ); + alarm->setType( Alarm::Display ); + alarm->setEnabled( true ); + int alarmOffset = alarmStr.toInt(); + alarm->setStartOffset( alarmOffset * -60 ); + event->addAlarm( alarm ); + } + // the following may not be + //Event *oldEvent = mCalendar->event( uid ); + //if ( oldEvent ) mCalendar->deleteEvent( oldEvent ); + + mCalendar->addEventNoDup( event ); + } else if ( qName == "Task" ) { + Todo *todo = new Todo; + + QString uid = "Qtopia" + attributes.value( "Uid" ); + //todo->setUid( uid ); + + QString description = attributes.value( "Description" ); + int pos = description.find( '\n' ); + if ( pos > 0 ) { + QString summary = description.left( pos ); + todo->setSummary( summary ); + todo->setDescription( description ); + } else { + todo->setSummary( description ); + } + + int priority = attributes.value( "Priority" ).toInt(); + if ( priority == 0 ) priority = 3; + todo->setPriority( priority ); + + QString categoryList = attributes.value( "Categories" ); + todo->setCategories( lookupCategories( categoryList ) ); + + QString completedStr = attributes.value( "Completed" ); + if ( completedStr == "1" ) todo->setCompleted( true ); + + QString hasDateStr = attributes.value( "HasDate" ); + if ( hasDateStr == "1" ) { + int year = attributes.value( "DateYear" ).toInt(); + int month = attributes.value( "DateMonth" ).toInt(); + int day = attributes.value( "DateDay" ).toInt(); + + todo->setDtDue( QDateTime( QDate( year, month, day ) ) ); + todo->setHasDueDate( true ); + } + + // Todo *oldTodo = mCalendar->todo( uid ); + //if ( oldTodo ) mCalendar->deleteTodo( oldTodo ); + + mCalendar->addTodoNoDup( todo ); + } else if ( qName == "Category" ) { + QString id = attributes.value( "id" ); + QString name = attributes.value( "name" ); + setCategory( id, name ); + } + + return true; + } + + bool warning ( const QXmlParseException &exception ) + { + printException( exception ); + return true; + } + + bool error ( const QXmlParseException &exception ) + { + printException( exception ); + return false; + } + + bool fatalError ( const QXmlParseException &exception ) + { + printException( exception ); + return false; + } + + QString errorString () + { + return "QtopiaParser: Error!"; + } + void setCategoriesList ( QStringList * c ) + { + oldCategories = c; + } + + protected: + void printException( const QXmlParseException &exception ) + { + kdError() << "XML Parse Error (line " << exception.lineNumber() + << ", col " << exception.columnNumber() << "): " + << exception.message() << "(public ID: '" + << exception.publicId() << "' system ID: '" + << exception.systemId() << "')" << endl; + } + + QDateTime toDateTime( const QString &value ) + { + QDateTime dt; + dt.setTime_t( value.toUInt() ); + + return dt; + } + + QStringList lookupCategories( const QString &categoryList ) + { + QStringList categoryIds = QStringList::split( ";", categoryList ); + QStringList categories; + QStringList::ConstIterator it; + for( it = categoryIds.begin(); it != categoryIds.end(); ++it ) { + QString cate = category( *it ); + if ( oldCategories ) { + if ( ! oldCategories->contains( cate ) ) + oldCategories->append( cate ); + } + categories.append(cate ); + } + return categories; + } + + private: + Calendar *mCalendar; + QStringList * oldCategories; + static QString category( const QString &id ) + { + QMap::ConstIterator it = mCategoriesMap.find( id ); + if ( it == mCategoriesMap.end() ) return id; + else return *it; + } + + static void setCategory( const QString &id, const QString &name ) + { + mCategoriesMap.insert( id, name ); + } + + static QMap mCategoriesMap; +}; + +QMap QtopiaParser::mCategoriesMap; + +QtopiaFormat::QtopiaFormat() +{ + mCategories = 0; +} + +QtopiaFormat::~QtopiaFormat() +{ +} +#include +bool QtopiaFormat::load( Calendar *calendar, const QString &fileName ) +{ + clearException(); + // qDebug("load QtopiaFormat: %s ",fileName.latin1() ); + QtopiaParser handler( calendar ); + handler.setCategoriesList( mCategories ); + QFile xmlFile( fileName ); + QXmlInputSource source( xmlFile ); + QXmlSimpleReader reader; + reader.setContentHandler( &handler ); + return reader.parse( source ); +} + +bool QtopiaFormat::save( Calendar *calendar, const QString &fileName ) +{ + + clearException(); + + QString text = toString( calendar ); + + if ( text.isNull() ) return false; + + // TODO: write backup file + + QFile file( fileName ); + if (!file.open( IO_WriteOnly ) ) { + setException(new ErrorFormat(ErrorFormat::SaveError, + i18n("Could not open file '%1'").arg(fileName))); + return false; + } + QTextStream ts( &file ); + ts << text; + file.close(); + + return true; +} + +bool QtopiaFormat::fromString( Calendar *, const QString & ) +{ + + return false; +} + +QString QtopiaFormat::toString( Calendar * ) +{ + return QString::null; +} diff --git a/libkcal/qtopiaformat.h b/libkcal/qtopiaformat.h new file mode 100644 index 0000000..2c69a4e --- a/dev/null +++ b/libkcal/qtopiaformat.h @@ -0,0 +1,53 @@ +/* + This file is part of libkcal. + + Copyright (c) 2003 Cornelius Schumacher + + 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 QTOPIAFORMAT_H +#define QTOPIAFORMAT_H + +#include + +#include "scheduler.h" + +#include "calformat.h" + +namespace KCal { + +/** + This class implements the calendar format used by Qtopia. +*/ +class QtopiaFormat : public CalFormat { + public: + /** Create new iCalendar format. */ + QtopiaFormat(); + virtual ~QtopiaFormat(); + + bool load( Calendar *, const QString &fileName ); + bool save( Calendar *, const QString &fileName ); + void setCategoriesList ( QStringList * cat ){ mCategories = cat; } + bool fromString( Calendar *, const QString & ); + QString toString( Calendar * ); + + private: + QStringList *mCategories; +}; + +} + +#endif diff --git a/libkcal/recurrence.cpp b/libkcal/recurrence.cpp new file mode 100644 index 0000000..5fc5d1f --- a/dev/null +++ b/libkcal/recurrence.cpp @@ -0,0 +1,3360 @@ +/* + This file is part of libkcal. + Copyright (c) 1998 Preston Brown + Copyright (c) 2001 Cornelius Schumacher + Copyright (c) 2002 David Jarvie + + 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 + +#include +#include +#include + +#include "incidence.h" + +#include "recurrence.h" + +using namespace KCal; + +Recurrence::Feb29Type Recurrence::mFeb29YearlyDefaultType = Recurrence::rMar1; + + +Recurrence::Recurrence(Incidence *parent, int compatVersion) +: recurs(rNone), // by default, it's not a recurring event + rWeekStart(1), // default is Monday + rDays(7), + mFloats(parent ? parent->doesFloat() : false), + mRecurReadOnly(false), + mRecurExDatesCount(0), + mFeb29YearlyType(mFeb29YearlyDefaultType), + mCompatVersion(compatVersion ? compatVersion : INT_MAX), + mCompatRecurs(rNone), + mCompatDuration(0), + mParent(parent) +{ + rMonthDays.setAutoDelete( true ); + rMonthPositions.setAutoDelete( true ); + rYearNums.setAutoDelete( true ); +} + +Recurrence::Recurrence(const Recurrence &r, Incidence *parent) +: recurs(r.recurs), + rWeekStart(r.rWeekStart), + rDays(r.rDays.copy()), + rFreq(r.rFreq), + rDuration(r.rDuration), + rEndDateTime(r.rEndDateTime), + mRecurStart(r.mRecurStart), + mFloats(r.mFloats), + mRecurReadOnly(r.mRecurReadOnly), + mRecurExDatesCount(r.mRecurExDatesCount), + mFeb29YearlyType(r.mFeb29YearlyType), + mCompatVersion(r.mCompatVersion), + mCompatRecurs(r.mCompatRecurs), + mCompatDuration(r.mCompatDuration), + mParent(parent) +{ + for (QPtrListIterator mp(r.rMonthPositions); mp.current(); ++mp) { + rMonthPos *tmp = new rMonthPos; + tmp->rPos = mp.current()->rPos; + tmp->negative = mp.current()->negative; + tmp->rDays = mp.current()->rDays.copy(); + rMonthPositions.append(tmp); + } + for (QPtrListIterator md(r.rMonthDays); md.current(); ++md) { + int *tmp = new int; + *tmp = *md.current(); + rMonthDays.append(tmp); + } + for (QPtrListIterator yn(r.rYearNums); yn.current(); ++yn) { + int *tmp = new int; + *tmp = *yn.current(); + rYearNums.append(tmp); + } + rMonthDays.setAutoDelete( true ); + rMonthPositions.setAutoDelete( true ); + rYearNums.setAutoDelete( true ); +} + +Recurrence::~Recurrence() +{ +} + + +bool Recurrence::operator==( const Recurrence& r2 ) const +{ + + // the following line is obvious + if ( recurs == rNone && r2.recurs == rNone ) + return true; + // we need the above line, because two non recurring events may + // differ in the other settings, because one (or both) + // may be not initialized properly + if ( recurs != r2.recurs + || rFreq != r2.rFreq + || rDuration != r2.rDuration + || !rDuration && rEndDateTime != r2.rEndDateTime + || mRecurStart != r2.mRecurStart + || mFloats != r2.mFloats + || mRecurReadOnly != r2.mRecurReadOnly + || mRecurExDatesCount != r2.mRecurExDatesCount ) + return false; + // no need to compare mCompat* and mParent + // OK to compare the pointers + switch ( recurs ) + { + case rWeekly: + return rDays == r2.rDays + && rWeekStart == r2.rWeekStart; + case rMonthlyPos: + return rMonthPositions.count() == r2.rMonthPositions.count(); + case rMonthlyDay: + return rMonthDays.count() == r2.rMonthDays.count(); + case rYearlyPos: + return rYearNums.count() == r2.rYearNums.count() + && rMonthPositions.count() == r2.rMonthPositions.count(); + case rYearlyMonth: + return rYearNums.count() == r2.rYearNums.count() + && mFeb29YearlyType == r2.mFeb29YearlyType; + case rYearlyDay: + return rYearNums == r2.rYearNums; + case rNone: + case rMinutely: + case rHourly: + case rDaily: + default: + return true; + } +} +/* +bool Recurrence::compareLists( const QPtrList &l1 ,const QPtrList &l2) +{ + if ( l1.count() != l2.count() ) + return false; + int count = l1.count(); + int i; + for ( i = 0; i < count ; ++i ) { + // if ( l1.at(i) != l2.at(i) ) + return false; + qDebug("compüare "); + } + return true; +} +*/ +QString Recurrence::recurrenceText() const +{ + QString recurText = i18n("No"); + if ( recurs == Recurrence::rMinutely ) + recurText = i18n("minutely"); + else if ( recurs == Recurrence::rHourly ) + recurText = i18n("hourly"); + else if ( recurs == Recurrence::rDaily ) + recurText = i18n("daily"); + else if ( recurs == Recurrence::rWeekly ) + recurText = i18n("weekly"); + else if ( recurs == Recurrence::rMonthlyPos ) + recurText = i18n("monthly"); + else if ( recurs == Recurrence::rMonthlyDay ) + recurText = i18n("day-monthly"); + else if ( recurs == Recurrence::rYearlyMonth ) + recurText = i18n("month-yearly"); + else if ( recurs == Recurrence::rYearlyDay ) + recurText = i18n("day-yearly"); + else if ( recurs == Recurrence::rYearlyPos ) + recurText = i18n("position-yearly"); + return recurText; +} + +void Recurrence::setCompatVersion(int version) +{ + mCompatVersion = version ? version : INT_MAX; +} + +ushort Recurrence::doesRecur() const +{ + return recurs; +} + +bool Recurrence::recursOnPure(const QDate &qd) const +{ + switch(recurs) { + case rMinutely: + return recursSecondly(qd, rFreq*60); + case rHourly: + return recursSecondly(qd, rFreq*3600); + case rDaily: + return recursDaily(qd); + case rWeekly: + return recursWeekly(qd); + case rMonthlyPos: + case rMonthlyDay: + return recursMonthly(qd); + case rYearlyMonth: + return recursYearlyByMonth(qd); + case rYearlyDay: + return recursYearlyByDay(qd); + case rYearlyPos: + return recursYearlyByPos(qd); + default: + return false; + case rNone: + return false; + } // case + return false; +} + +bool Recurrence::recursAtPure(const QDateTime &dt) const +{ + switch(recurs) { + case rMinutely: + return recursMinutelyAt(dt, rFreq); + case rHourly: + return recursMinutelyAt(dt, rFreq*60); + default: + if (dt.time() != mRecurStart.time()) + return false; + switch(recurs) { + case rDaily: + return recursDaily(dt.date()); + case rWeekly: + return recursWeekly(dt.date()); + case rMonthlyPos: + case rMonthlyDay: + return recursMonthly(dt.date()); + case rYearlyMonth: + return recursYearlyByMonth(dt.date()); + case rYearlyDay: + return recursYearlyByDay(dt.date()); + case rYearlyPos: + return recursYearlyByPos(dt.date()); + default: + return false; + case rNone: + return false; + } + } // case + return false; +} + +QDate Recurrence::endDate() const +{ + int count = 0; + QDate end; + if (recurs != rNone) { + if (rDuration < 0) + return QDate(); // infinite recurrence + if (rDuration == 0) + return rEndDateTime.date(); + + // The end date is determined by the recurrence count + QDate dStart = mRecurStart.date(); + switch (recurs) + { + case rMinutely: + return mRecurStart.addSecs((rDuration-1+mRecurExDatesCount)*rFreq*60).date(); + case rHourly: + return mRecurStart.addSecs((rDuration-1+mRecurExDatesCount)*rFreq*3600).date(); + case rDaily: + return dStart.addDays((rDuration-1+mRecurExDatesCount)*rFreq); + + case rWeekly: + count = weeklyCalc(END_DATE_AND_COUNT, end); + break; + case rMonthlyPos: + case rMonthlyDay: + count = monthlyCalc(END_DATE_AND_COUNT, end); + break; + case rYearlyMonth: + count = yearlyMonthCalc(END_DATE_AND_COUNT, end); + break; + case rYearlyDay: + count = yearlyDayCalc(END_DATE_AND_COUNT, end); + break; + case rYearlyPos: + count = yearlyPosCalc(END_DATE_AND_COUNT, end); + break; + default: + // catch-all. Should never get here. + kdDebug(5800) << "Control should never reach here in endDate()!" << endl; + break; + } + } + if (!count) + return QDate(); // error - there is no recurrence + return end; +} + +QDateTime Recurrence::endDateTime() const +{ + int count = 0; + QDate end; + if (recurs != rNone) { + if (rDuration < 0) + return QDateTime(); // infinite recurrence + if (rDuration == 0) + return rEndDateTime; + + // The end date is determined by the recurrence count + QDate dStart = mRecurStart.date(); + switch (recurs) + { + case rMinutely: + return mRecurStart.addSecs((rDuration-1+mRecurExDatesCount)*rFreq*60); + case rHourly: + return mRecurStart.addSecs((rDuration-1+mRecurExDatesCount)*rFreq*3600); + case rDaily: + return dStart.addDays((rDuration-1+mRecurExDatesCount)*rFreq); + + case rWeekly: + count = weeklyCalc(END_DATE_AND_COUNT, end); + break; + case rMonthlyPos: + case rMonthlyDay: + count = monthlyCalc(END_DATE_AND_COUNT, end); + break; + case rYearlyMonth: + count = yearlyMonthCalc(END_DATE_AND_COUNT, end); + break; + case rYearlyDay: + count = yearlyDayCalc(END_DATE_AND_COUNT, end); + break; + case rYearlyPos: + count = yearlyPosCalc(END_DATE_AND_COUNT, end); + break; + default: + // catch-all. Should never get here. + kdDebug(5800) << "Control should never reach here in endDate()!" << endl; + break; + } + } + if (!count) + return QDateTime(); // error - there is no recurrence + return QDateTime(end, mRecurStart.time()); +} + +int Recurrence::durationTo(const QDate &date) const +{ + QDate d = date; + return recurCalc(COUNT_TO_DATE, d); +} + +int Recurrence::durationTo(const QDateTime &datetime) const +{ + QDateTime dt = datetime; + return recurCalc(COUNT_TO_DATE, dt); +} + +void Recurrence::unsetRecurs() +{ + if (mRecurReadOnly) return; + recurs = rNone; + rMonthPositions.clear(); + rMonthDays.clear(); + rYearNums.clear(); +} + +void Recurrence::setRecurStart(const QDateTime &start) +{ + mRecurStart = start; + mFloats = false; + switch (recurs) + { + case rMinutely: + case rHourly: + break; + case rDaily: + case rWeekly: + case rMonthlyPos: + case rMonthlyDay: + case rYearlyMonth: + case rYearlyDay: + case rYearlyPos: + default: + rEndDateTime.setTime(start.time()); + break; + } +} + +void Recurrence::setRecurStart(const QDate &start) +{ + mRecurStart.setDate(start); + mRecurStart.setTime(QTime(0,0,0)); + switch (recurs) + { + case rMinutely: + case rHourly: + break; + case rDaily: + case rWeekly: + case rMonthlyPos: + case rMonthlyDay: + case rYearlyMonth: + case rYearlyDay: + case rYearlyPos: + default: + mFloats = true; + break; + } +} + +void Recurrence::setFloats(bool f) +{ + switch (recurs) + { + case rDaily: + case rWeekly: + case rMonthlyPos: + case rMonthlyDay: + case rYearlyMonth: + case rYearlyDay: + case rYearlyPos: + break; + case rMinutely: + case rHourly: + default: + return; // can't set sub-daily to floating + } + mFloats = f; + if (f) { + mRecurStart.setTime(QTime(0,0,0)); + rEndDateTime.setTime(QTime(0,0,0)); + } +} + +int Recurrence::frequency() const +{ + return rFreq; +} + +int Recurrence::duration() const +{ + return rDuration; +} + +void Recurrence::setDuration(int _rDuration) +{ + if (mRecurReadOnly) return; + if (_rDuration > 0) { + rDuration = _rDuration; + // Compatibility mode is only needed when reading the calendar in ICalFormatImpl, + // so explicitly setting the duration means no backwards compatibility is needed. + mCompatDuration = 0; + } +} + +QString Recurrence::endDateStr(bool shortfmt) const +{ + return KGlobal::locale()->formatDate(rEndDateTime.date(),shortfmt); +} + +const QBitArray &Recurrence::days() const +{ + return rDays; +} + +const QPtrList &Recurrence::monthPositions() const +{ + return rMonthPositions; +} + +const QPtrList &Recurrence::yearMonthPositions() const +{ + return rMonthPositions; +} + +const QPtrList &Recurrence::monthDays() const +{ + return rMonthDays; +} + +void Recurrence::setMinutely(int _rFreq, int _rDuration) +{ + if (mRecurReadOnly || _rDuration == 0 || _rDuration < -1) + return; + setDailySub(rMinutely, _rFreq, _rDuration); +} + +void Recurrence::setMinutely(int _rFreq, const QDateTime &_rEndDateTime) +{ + if (mRecurReadOnly) return; + rEndDateTime = _rEndDateTime; + setDailySub(rMinutely, _rFreq, 0); +} + +void Recurrence::setHourly(int _rFreq, int _rDuration) +{ + if (mRecurReadOnly || _rDuration == 0 || _rDuration < -1) + return; + setDailySub(rHourly, _rFreq, _rDuration); +} + +void Recurrence::setHourly(int _rFreq, const QDateTime &_rEndDateTime) +{ + if (mRecurReadOnly) return; + rEndDateTime = _rEndDateTime; + setDailySub(rHourly, _rFreq, 0); +} + +void Recurrence::setDaily(int _rFreq, int _rDuration) +{ + if (mRecurReadOnly || _rDuration == 0 || _rDuration < -1) + return; + setDailySub(rDaily, _rFreq, _rDuration); +} + +void Recurrence::setDaily(int _rFreq, const QDate &_rEndDate) +{ + if (mRecurReadOnly) return; + rEndDateTime.setDate(_rEndDate); + rEndDateTime.setTime(mRecurStart.time()); + setDailySub(rDaily, _rFreq, 0); +} + +void Recurrence::setWeekly(int _rFreq, const QBitArray &_rDays, + int _rDuration, int _rWeekStart) +{ + if (mRecurReadOnly || _rDuration == 0 || _rDuration < -1) + return; + recurs = rWeekly; + + rFreq = _rFreq; + rDays = _rDays; + rWeekStart = _rWeekStart; + rDuration = _rDuration; + if (mCompatVersion < 310 && _rDuration > 0) { + // Backwards compatibility for KDE < 3.1. + // rDuration was set to the number of time periods to recur, + // with week start always on a Monday. + // Convert this to the number of occurrences. + mCompatDuration = _rDuration; + int weeks = ((mCompatDuration-1+mRecurExDatesCount)*7) + (7 - mRecurStart.date().dayOfWeek()); + QDate end(mRecurStart.date().addDays(weeks * rFreq)); + rDuration = INT_MAX; // ensure that weeklyCalc() does its job correctly + rDuration = weeklyCalc(COUNT_TO_DATE, end); + } else { + mCompatDuration = 0; + } + rMonthPositions.clear(); + rMonthDays.clear(); + if (mParent) mParent->updated(); +} + +void Recurrence::setWeekly(int _rFreq, const QBitArray &_rDays, + const QDate &_rEndDate, int _rWeekStart) +{ + if (mRecurReadOnly) return; + recurs = rWeekly; + + rFreq = _rFreq; + rDays = _rDays; + rWeekStart = _rWeekStart; + rEndDateTime.setDate(_rEndDate); + rEndDateTime.setTime(mRecurStart.time()); + rDuration = 0; // set to 0 because there is an end date + mCompatDuration = 0; + rMonthPositions.clear(); + rMonthDays.clear(); + rYearNums.clear(); + if (mParent) mParent->updated(); +} + +void Recurrence::setMonthly(short type, int _rFreq, int _rDuration) +{ + if (mRecurReadOnly || _rDuration == 0 || _rDuration < -1) + return; + recurs = type; + + rFreq = _rFreq; + rDuration = _rDuration; + if (mCompatVersion < 310) + mCompatDuration = (_rDuration > 0) ? _rDuration : 0; + rYearNums.clear(); + if (mParent) mParent->updated(); +} + +void Recurrence::setMonthly(short type, int _rFreq, + const QDate &_rEndDate) +{ + if (mRecurReadOnly) return; + recurs = type; + + rFreq = _rFreq; + rEndDateTime.setDate(_rEndDate); + rEndDateTime.setTime(mRecurStart.time()); + rDuration = 0; // set to 0 because there is an end date + mCompatDuration = 0; + rYearNums.clear(); + if (mParent) mParent->updated(); +} + +void Recurrence::addMonthlyPos(short _rPos, const QBitArray &_rDays) +{ + if (recurs == rMonthlyPos) + addMonthlyPos_(_rPos, _rDays); +} + +void Recurrence::addMonthlyPos_(short _rPos, const QBitArray &_rDays) +{ + if (mRecurReadOnly + || _rPos == 0 || _rPos > 5 || _rPos < -5) // invalid week number + return; + + for (rMonthPos* it = rMonthPositions.first(); it; it = rMonthPositions.next()) { + int itPos = it->negative ? -it->rPos : it->rPos; + if (_rPos == itPos) { + // This week is already in the list. + // Combine the specified days with those in the list. + it->rDays |= _rDays; + if (mParent) mParent->updated(); + return; + } + } + // Add the new position to the list + rMonthPos *tmpPos = new rMonthPos; + if (_rPos > 0) { + tmpPos->rPos = _rPos; + tmpPos->negative = false; + } else { + tmpPos->rPos = -_rPos; // take abs() + tmpPos->negative = true; + } + tmpPos->rDays = _rDays; + tmpPos->rDays.detach(); + rMonthPositions.append(tmpPos); + + if (mCompatVersion < 310 && mCompatDuration > 0) { + // Backwards compatibility for KDE < 3.1. + // rDuration was set to the number of time periods to recur. + // Convert this to the number of occurrences. + int monthsAhead = (mCompatDuration-1+mRecurExDatesCount) * rFreq; + int month = mRecurStart.date().month() - 1 + monthsAhead; + QDate end(mRecurStart.date().year() + month/12, month%12 + 1, 31); + rDuration = INT_MAX; // ensure that recurCalc() does its job correctly + rDuration = recurCalc(COUNT_TO_DATE, end); + } + + if (mParent) mParent->updated(); +} + +void Recurrence::addMonthlyDay(short _rDay) +{ + if (mRecurReadOnly || recurs != rMonthlyDay + || _rDay == 0 || _rDay > 31 || _rDay < -31) // invalid day number + return; + for (int* it = rMonthDays.first(); it; it = rMonthDays.next()) { + if (_rDay == *it) + return; // this day is already in the list - avoid duplication + } + int *tmpDay = new int; + *tmpDay = _rDay; + rMonthDays.append(tmpDay); + + if (mCompatVersion < 310 && mCompatDuration > 0) { + // Backwards compatibility for KDE < 3.1. + // rDuration was set to the number of time periods to recur. + // Convert this to the number of occurrences. + int monthsAhead = (mCompatDuration-1+mRecurExDatesCount) * rFreq; + int month = mRecurStart.date().month() - 1 + monthsAhead; + QDate end(mRecurStart.date().year() + month/12, month%12 + 1, 31); + rDuration = INT_MAX; // ensure that recurCalc() does its job correctly + rDuration = recurCalc(COUNT_TO_DATE, end); + } + + if (mParent) mParent->updated(); +} + +void Recurrence::setYearly(int type, int _rFreq, int _rDuration) +{ + if (mRecurReadOnly || _rDuration == 0 || _rDuration < -1) + return; + if (mCompatVersion < 310) + mCompatDuration = (_rDuration > 0) ? _rDuration : 0; + setYearly_(type, mFeb29YearlyDefaultType, _rFreq, _rDuration); +} + +void Recurrence::setYearly(int type, int _rFreq, const QDate &_rEndDate) +{ + if (mRecurReadOnly) return; + rEndDateTime.setDate(_rEndDate); + rEndDateTime.setTime(mRecurStart.time()); + mCompatDuration = 0; + setYearly_(type, mFeb29YearlyDefaultType, _rFreq, 0); +} + +void Recurrence::setYearlyByDate(Feb29Type type, int _rFreq, int _rDuration) +{ + if (mRecurReadOnly || _rDuration == 0 || _rDuration < -1) + return; + if (mCompatVersion < 310) + mCompatDuration = (_rDuration > 0) ? _rDuration : 0; + setYearly_(rYearlyMonth, type, _rFreq, _rDuration); +} + +void Recurrence::setYearlyByDate(Feb29Type type, int _rFreq, const QDate &_rEndDate) +{ + if (mRecurReadOnly) return; + rEndDateTime.setDate(_rEndDate); + rEndDateTime.setTime(mRecurStart.time()); + mCompatDuration = 0; + setYearly_(rYearlyMonth, type, _rFreq, 0); +} + +void Recurrence::addYearlyMonthPos(short _rPos, const QBitArray &_rDays) +{ + if (recurs == rYearlyPos) + addMonthlyPos_(_rPos, _rDays); +} + +const QPtrList &Recurrence::yearNums() const +{ + return rYearNums; +} + +void Recurrence::addYearlyNum(short _rNum) +{ + if (mRecurReadOnly + || (recurs != rYearlyMonth && recurs != rYearlyDay && recurs != rYearlyPos) + || _rNum <= 0) // invalid day/month number + return; + + if (mCompatVersion < 310 && mCompatRecurs == rYearlyDay) { + // Backwards compatibility for KDE < 3.1. + // Dates were stored as day numbers, with a fiddle to take account of leap years. + // Convert the day number to a month. + if (_rNum <= 0 || _rNum > 366 || (_rNum == 366 && mRecurStart.date().daysInYear() < 366)) + return; // invalid day number + _rNum = QDate(mRecurStart.date().year(), 1, 1).addDays(_rNum - 1).month(); + } else + if ((recurs == rYearlyMonth || recurs == rYearlyPos) && _rNum > 12 + || recurs == rYearlyDay && _rNum > 366) + return; // invalid day number + + uint i = 0; + for (int* it = rYearNums.first(); it && _rNum >= *it; it = rYearNums.next()) { + if (_rNum == *it) + return; // this day/month is already in the list - avoid duplication + ++i; + } + + int *tmpNum = new int; + *tmpNum = _rNum; + rYearNums.insert(i, tmpNum); // insert the day/month in a sorted position + + if (mCompatVersion < 310 && mCompatDuration > 0) { + // Backwards compatibility for KDE < 3.1. + // rDuration was set to the number of time periods to recur. + // Convert this to the number of occurrences. + QDate end(mRecurStart.date().year() + (mCompatDuration-1+mRecurExDatesCount)*rFreq, 12, 31); + rDuration = INT_MAX; // ensure that recurCalc() does its job correctly + rDuration = recurCalc(COUNT_TO_DATE, end); + } + + if (mParent) mParent->updated(); +} + + +QDateTime Recurrence::getNextDateTime(const QDateTime &preDateTime, bool *last) const +{ + if (last) + *last = false; + int freq; + switch (recurs) + { + case rMinutely: + freq = rFreq * 60; + break; + case rHourly: + freq = rFreq * 3600; + break; + case rDaily: + case rWeekly: + case rMonthlyPos: + case rMonthlyDay: + case rYearlyMonth: + case rYearlyDay: + case rYearlyPos: { + QDate preDate = preDateTime.date(); + if (!mFloats && mRecurStart.time() > preDateTime.time()) + preDate = preDate.addDays(-1); + return QDateTime(getNextDateNoTime(preDate, last), mRecurStart.time()); + } + default: + return QDateTime(); + } + + // It's a sub-daily recurrence + if (preDateTime < mRecurStart) + return mRecurStart; + int count = mRecurStart.secsTo(preDateTime) / freq + 2; + if (rDuration > 0) { + if (count > rDuration) + return QDateTime(); + if (last && count == rDuration) + *last = true; + } + QDateTime endtime = mRecurStart.addSecs((count - 1)*freq); + if (rDuration == 0) { + if (endtime > rEndDateTime) + return QDateTime(); + if (last && endtime == rEndDateTime) + *last = true; + } + return endtime; +} + +QDate Recurrence::getNextDate(const QDate &preDate, bool *last) const +{ + if (last) + *last = false; + switch (recurs) + { + case rMinutely: + case rHourly: + return getNextDateTime(QDateTime(preDate, QTime(23,59,59)), last).date(); + case rDaily: + case rWeekly: + case rMonthlyPos: + case rMonthlyDay: + case rYearlyMonth: + case rYearlyDay: + case rYearlyPos: + return getNextDateNoTime(preDate, last); + default: + return QDate(); + } +} + + +QDateTime Recurrence::getPreviousDateTime(const QDateTime &afterDateTime, bool *last) const +{ + if (last) + *last = false; + int freq; + switch (recurs) + { + case rMinutely: + freq = rFreq * 60; + break; + case rHourly: + freq = rFreq * 3600; + break; + case rDaily: + case rWeekly: + case rMonthlyPos: + case rMonthlyDay: + case rYearlyMonth: + case rYearlyDay: + case rYearlyPos: { + QDate afterDate = afterDateTime.date(); + if (!mFloats && mRecurStart.time() < afterDateTime.time()) + afterDate = afterDate.addDays(1); + return QDateTime(getPreviousDateNoTime(afterDate, last), mRecurStart.time()); + } + default: + return QDateTime(); + } + + // It's a sub-daily recurrence + if (afterDateTime <= mRecurStart) + return QDateTime(); + int count = (mRecurStart.secsTo(afterDateTime) - 1) / freq + 1; + if (rDuration > 0) { + if (count > rDuration) + count = rDuration; + if (last && count == rDuration) + *last = true; + } + QDateTime endtime = mRecurStart.addSecs((count - 1)*freq); + if (rDuration == 0) { + if (endtime > rEndDateTime) + endtime = rEndDateTime; + if (last && endtime == rEndDateTime) + *last = true; + } + return endtime; +} + +QDate Recurrence::getPreviousDate(const QDate &afterDate, bool *last) const +{ + if (last) + *last = false; + switch (recurs) + { + case rMinutely: + case rHourly: + return getPreviousDateTime(QDateTime(afterDate, QTime(0,0,0)), last).date(); + case rDaily: + case rWeekly: + case rMonthlyPos: + case rMonthlyDay: + case rYearlyMonth: + case rYearlyDay: + case rYearlyPos: + return getPreviousDateNoTime(afterDate, last); + default: + return QDate(); + } +} + + +/***************************** PROTECTED FUNCTIONS ***************************/ + +bool Recurrence::recursSecondly(const QDate &qd, int secondFreq) const +{ + if ((qd >= mRecurStart.date()) && + ((rDuration > 0) && (qd <= endDate()) || + ((rDuration == 0) && (qd <= rEndDateTime.date())) || + (rDuration == -1))) { + // The date queried falls within the range of the event. + if (secondFreq < 24*3600) + return true; // the event recurs at least once each day + int after = mRecurStart.secsTo(QDateTime(qd)); + if (after / secondFreq != (after + 24*3600) / secondFreq) + return true; + } + return false; +} + +bool Recurrence::recursMinutelyAt(const QDateTime &dt, int minuteFreq) const +{ + if ((dt >= mRecurStart) && + ((rDuration > 0) && (dt <= endDateTime()) || + ((rDuration == 0) && (dt <= rEndDateTime)) || + (rDuration == -1))) { + // The time queried falls within the range of the event. + if (((mRecurStart.secsTo(dt) / 60) % minuteFreq) == 0) + return true; + } + return false; +} + +bool Recurrence::recursDaily(const QDate &qd) const +{ + QDate dStart = mRecurStart.date(); + if ((dStart.daysTo(qd) % rFreq) == 0) { + // The date is a day which recurs + if (qd >= dStart + && ((rDuration > 0 && qd <= endDate()) || + (rDuration == 0 && qd <= rEndDateTime.date()) || + rDuration == -1)) { + // The date queried falls within the range of the event. + return true; + } + } + return false; +} + +bool Recurrence::recursWeekly(const QDate &qd) const +{ + QDate dStart = mRecurStart.date(); + if ((dStart.daysTo(qd)/7) % rFreq == 0) { + // The date is in a week which recurs + if (qd >= dStart + && ((rDuration > 0 && qd <= endDate()) || + (rDuration == 0 && qd <= rEndDateTime.date()) || + rDuration == -1)) { + // The date queried falls within the range of the event. + // check if the bits set match today. + int i = qd.dayOfWeek()-1; + if (rDays.testBit((uint) i)) + return true; + } + } + return false; +} + +bool Recurrence::recursMonthly(const QDate &qd) const +{ + QDate dStart = mRecurStart.date(); + int year = qd.year(); + int month = qd.month(); + int day = qd.day(); + // calculate how many months ahead this date is from the original + // event's date + int monthsAhead = (year - dStart.year()) * 12 + (month - dStart.month()); + if ((monthsAhead % rFreq) == 0) { + // The date is in a month which recurs + if (qd >= dStart + && ((rDuration > 0 && qd <= endDate()) || + (rDuration == 0 && qd <= rEndDateTime.date()) || + rDuration == -1)) { + // The date queried falls within the range of the event. + QValueList days; + int daysInMonth = qd.daysInMonth(); + if (recurs == rMonthlyDay) + getMonthlyDayDays(days, daysInMonth); + else if (recurs == rMonthlyPos) + getMonthlyPosDays(days, daysInMonth, QDate(year, month, 1).dayOfWeek()); + for (QValueList::Iterator it = days.begin(); it != days.end(); ++it) { + if (*it == day) + return true; + } + // no dates matched + } + } + return false; +} + +bool Recurrence::recursYearlyByMonth(const QDate &qd) const +{ + QDate dStart = mRecurStart.date(); + int startDay = dStart.day(); + int qday = qd.day(); + int qmonth = qd.month(); + int qyear = qd.year(); + bool match = (qday == startDay); + if (!match && startDay == 29 && dStart.month() == 2) { + // It's a recurrence on February 29th + switch (mFeb29YearlyType) { + case rFeb28: + if (qday == 28 && qmonth == 2 && !QDate::leapYear(qyear)) + match = true; + break; + case rMar1: + if (qday == 1 && qmonth == 3 && !QDate::leapYear(qyear)) { + qmonth = 2; + match = true; + } + break; + case rFeb29: + break; + } + } + + if (match) { + // The day of the month matches. Calculate how many years ahead + // this date is from the original event's date. + int yearsAhead = (qyear - dStart.year()); + if (yearsAhead % rFreq == 0) { + // The date is in a year which recurs + if (qd >= dStart + && ((rDuration > 0 && qd <= endDate()) || + (rDuration == 0 && qd <= rEndDateTime.date()) || + rDuration == -1)) { + // The date queried falls within the range of the event. + int i = qmonth; + for (QPtrListIterator qlin(rYearNums); qlin.current(); ++qlin) { + if (i == *qlin.current()) + return true; + } + } + } + } + return false; +} + +bool Recurrence::recursYearlyByPos(const QDate &qd) const +{ + QDate dStart = mRecurStart.date(); + int year = qd.year(); + int month = qd.month(); + int day = qd.day(); + // calculate how many years ahead this date is from the original + // event's date + int yearsAhead = (year - dStart.year()); + if (yearsAhead % rFreq == 0) { + // The date is in a year which recurs + if (qd >= dStart + && ((rDuration > 0 && qd <= endDate()) || + (rDuration == 0 && qd <= rEndDateTime.date()) || + rDuration == -1)) { + // The date queried falls within the range of the event. + for (QPtrListIterator qlin(rYearNums); qlin.current(); ++qlin) { + if (month == *qlin.current()) { + // The month recurs + QValueList days; + getMonthlyPosDays(days, qd.daysInMonth(), QDate(year, month, 1).dayOfWeek()); + for (QValueList::Iterator it = days.begin(); it != days.end(); ++it) { + if (*it == day) + return true; + } + } + } + } + } + return false; +} + +bool Recurrence::recursYearlyByDay(const QDate &qd) const +{ + QDate dStart = mRecurStart.date(); + // calculate how many years ahead this date is from the original + // event's date + int yearsAhead = (qd.year() - dStart.year()); + if (yearsAhead % rFreq == 0) { + // The date is in a year which recurs + if (qd >= dStart + && ((rDuration > 0 && qd <= endDate()) || + (rDuration == 0 && qd <= rEndDateTime.date()) || + rDuration == -1)) { + // The date queried falls within the range of the event. + int i = qd.dayOfYear(); + for (QPtrListIterator qlin(rYearNums); qlin.current(); ++qlin) { + if (i == *qlin.current()) + return true; + } + } + } + return false; +} + +/* Get the date of the next recurrence, after the specified date. + * If 'last' is non-null, '*last' is set to true if the next recurrence is the + * last recurrence, else false. + * Reply = date of next recurrence, or invalid date if none. + */ +QDate Recurrence::getNextDateNoTime(const QDate &preDate, bool *last) const +{ + if (last) + *last = false; + QDate dStart = mRecurStart.date(); + if (preDate < dStart) + return dStart; + QDate earliestDate = preDate.addDays(1); + QDate nextDate; + + switch (recurs) { + case rDaily: + nextDate = dStart.addDays((dStart.daysTo(preDate)/rFreq + 1) * rFreq); + break; + + case rWeekly: { + QDate start = dStart.addDays(1 - dStart.dayOfWeek()); // start of week for dStart + int earliestDayOfWeek = earliestDate.dayOfWeek(); + int weeksAhead = start.daysTo(earliestDate) / 7; + int notThisWeek = weeksAhead % rFreq; // zero if this week is a recurring week + weeksAhead -= notThisWeek; // latest week which recurred + int weekday = 0; + // First check for any remaining day this week, if this week is a recurring week + if (!notThisWeek) + weekday = getFirstDayInWeek(earliestDayOfWeek); + // Check for a day in the next scheduled week + if (!weekday && earliestDayOfWeek > 1) + weekday = getFirstDayInWeek(rWeekStart) + rFreq*7; + if (weekday) + nextDate = start.addDays(weeksAhead*7 + weekday - 1); + break; + } + case rMonthlyDay: + case rMonthlyPos: { + int startYear = dStart.year(); + int startMonth = dStart.month(); // 1..12 + int earliestYear = earliestDate.year(); + int monthsAhead = (earliestYear - startYear)*12 + earliestDate.month() - startMonth; + int notThisMonth = monthsAhead % rFreq; // zero if this month is a recurring month + monthsAhead -= notThisMonth; // latest month which recurred + // Check for the first later day in the current month + if (!notThisMonth) + nextDate = getFirstDateInMonth(earliestDate); + if (!nextDate.isValid() && earliestDate.day() > 1) { + // Check for a day in the next scheduled month + int months = startMonth - 1 + monthsAhead + rFreq; + nextDate = getFirstDateInMonth(QDate(startYear + months/12, months%12 + 1, 1)); + } + break; + } + case rYearlyMonth: + case rYearlyPos: + case rYearlyDay: { + int startYear = dStart.year(); + int yearsAhead = earliestDate.year() - startYear; + int notThisYear = yearsAhead % rFreq; // zero if this year is a recurring year + yearsAhead -= notThisYear; // latest year which recurred + // Check for the first later date in the current year + if (!notThisYear) + nextDate = getFirstDateInYear(earliestDate); + // Check for a date in the next scheduled year + if (!nextDate.isValid() && earliestDate.dayOfYear() > 1) + nextDate = getFirstDateInYear(QDate(startYear + yearsAhead + rFreq, 1, 1)); + break; + } + case rNone: + default: + return QDate(); + } + + if (rDuration >= 0 && nextDate.isValid()) { + // Check that the date found is within the range of the recurrence + QDate end = endDate(); + if (nextDate > end) + return QDate(); + if (last && nextDate == end) + *last = true; + } + return nextDate; +} + +/* Get the date of the last previous recurrence, before the specified date. + * Reply = date of previous recurrence, or invalid date if none. + */ +QDate Recurrence::getPreviousDateNoTime(const QDate &afterDate, bool *last) const +{ + if (last) + *last = false; + QDate dStart = mRecurStart.date(); + QDate latestDate = afterDate.addDays(-1); + if (latestDate < dStart) + return QDate(); + QDate prevDate; + + switch (recurs) { + case rDaily: + prevDate = dStart.addDays((dStart.daysTo(latestDate) / rFreq) * rFreq); + break; + + case rWeekly: { + QDate start = dStart.addDays(1 - dStart.dayOfWeek()); // start of week for dStart + int latestDayOfWeek = latestDate.dayOfWeek(); + int weeksAhead = start.daysTo(latestDate) / 7; + int notThisWeek = weeksAhead % rFreq; // zero if this week is a recurring week + weeksAhead -= notThisWeek; // latest week which recurred + int weekday = 0; + // First check for any previous day this week, if this week is a recurring week + if (!notThisWeek) + weekday = getLastDayInWeek(latestDayOfWeek); + // Check for a day in the previous scheduled week + if (!weekday) { + int weekEnd = (rWeekStart + 5)%7 + 1; + if (latestDayOfWeek < weekEnd) { + if (!notThisWeek) + weeksAhead -= rFreq; + weekday = getLastDayInWeek(weekEnd); + } + } + if (weekday) + prevDate = start.addDays(weeksAhead*7 + weekday - 1); + break; + } + case rMonthlyDay: + case rMonthlyPos: { + int startYear = dStart.year(); + int startMonth = dStart.month(); // 1..12 + int latestYear = latestDate.year(); + int monthsAhead = (latestYear - startYear)*12 + latestDate.month() - startMonth; + int notThisMonth = monthsAhead % rFreq; // zero if this month is a recurring month + monthsAhead -= notThisMonth; // latest month which recurred + // Check for the last earlier day in the current month + if (!notThisMonth) + prevDate = getLastDateInMonth(latestDate); + if (!prevDate.isValid() && latestDate.day() < latestDate.daysInMonth()) { + // Check for a day in the previous scheduled month + if (!notThisMonth) + monthsAhead -= rFreq; + int months = startMonth + monthsAhead; // get the month after the one that recurs + prevDate = getLastDateInMonth(QDate(startYear + months/12, months%12 + 1, 1).addDays(-1)); + } + break; + } + case rYearlyMonth: + case rYearlyPos: + case rYearlyDay: { + int startYear = dStart.year(); + int yearsAhead = latestDate.year() - startYear; + int notThisYear = yearsAhead % rFreq; // zero if this year is a recurring year + yearsAhead -= notThisYear; // latest year which recurred + // Check for the first later date in the current year + if (!notThisYear) + prevDate = getLastDateInYear(latestDate); + if (!prevDate.isValid() && latestDate.dayOfYear() < latestDate.daysInYear()) { + // Check for a date in the next scheduled year + if (!notThisYear) + yearsAhead -= rFreq; + prevDate = getLastDateInYear(QDate(startYear + yearsAhead, 12, 31)); + } + break; + } + case rNone: + default: + return QDate(); + } + + if (prevDate.isValid()) { + // Check that the date found is within the range of the recurrence + if (prevDate < dStart) + return QDate(); + if (rDuration >= 0) { + QDate end = endDate(); + if (prevDate >= end) { + if (last) + *last = true; + return end; + } + } + } + return prevDate; +} + +void Recurrence::setDailySub(short type, int freq, int duration) +{ + recurs = type; + rFreq = freq; + rDuration = duration; + rMonthPositions.clear(); + rMonthDays.clear(); + rYearNums.clear(); + if (type != rDaily) + mFloats = false; // sub-daily types can't be floating + + if (mParent) mParent->updated(); +} + +void Recurrence::setYearly_(short type, Feb29Type feb29type, int freq, int duration) +{ + recurs = type; + if (mCompatVersion < 310 && type == rYearlyDay) { + mCompatRecurs = rYearlyDay; + recurs = rYearlyMonth; // convert old yearly-by-day to yearly-by-month + feb29type = rMar1; // retain the same day number in the year + } + + mFeb29YearlyType = feb29type; + rFreq = freq; + rDuration = duration; + if (type != rYearlyPos) + rMonthPositions.clear(); + rMonthDays.clear(); + if (mParent) mParent->updated(); +} + +int Recurrence::recurCalc(PeriodFunc func, QDateTime &endtime) const +{ + QDate enddate = endtime.date(); + switch (func) { + case END_DATE_AND_COUNT: + if (rDuration < 0) { + endtime = QDateTime(); + return 0; // infinite recurrence + } + if (rDuration == 0) { + endtime = rEndDateTime; + func = COUNT_TO_DATE; + } + break; + case COUNT_TO_DATE: + // Count recurrences up to and including the specified date/time. + if (endtime < mRecurStart) + return 0; + if (rDuration == 0 && endtime > rEndDateTime) + enddate = rEndDateTime.date(); + else if (!mFloats && mRecurStart.time() > endtime.time()) + enddate = enddate.addDays(-1); + break; + case NEXT_AFTER_DATE: + // Find next recurrence AFTER endtime + if (endtime < mRecurStart) { + endtime = mRecurStart; + return 1; + } + if (rDuration == 0 && endtime >= rEndDateTime) { + endtime = QDateTime(); + return 0; + } + if (!mFloats && mRecurStart.time() > endtime.time()) + enddate = enddate.addDays(-1); + break; + default: + endtime = QDateTime(); + return 0; + } + + int count = 0; // default = error + bool timed = false; + switch (recurs) { + case rMinutely: + timed = true; + count = secondlyCalc(func, endtime, rFreq*60); + break; + case rHourly: + timed = true; + count = secondlyCalc(func, endtime, rFreq*3600); + break; + case rDaily: + count = dailyCalc(func, enddate); + break; + case rWeekly: + count = weeklyCalc(func, enddate); + break; + case rMonthlyPos: + case rMonthlyDay: + count = monthlyCalc(func, enddate); + break; + case rYearlyMonth: + count = yearlyMonthCalc(func, enddate); + break; + case rYearlyPos: + count = yearlyPosCalc(func, enddate); + break; + case rYearlyDay: + count = yearlyDayCalc(func, enddate); + break; + default: + break; + } + + switch (func) { + case END_DATE_AND_COUNT: + case NEXT_AFTER_DATE: + if (count == 0) + endtime = QDateTime(); + else if (!timed) { + endtime.setDate(enddate); + endtime.setTime(mRecurStart.time()); + } + break; + case COUNT_TO_DATE: + break; + } + return count; +} + +int Recurrence::recurCalc(PeriodFunc func, QDate &enddate) const +{ + QDateTime endtime(enddate, QTime(23,59,59)); + switch (func) { + case END_DATE_AND_COUNT: + if (rDuration < 0) { + enddate = QDate(); + return 0; // infinite recurrence + } + if (rDuration == 0) { + enddate = rEndDateTime.date(); + func = COUNT_TO_DATE; + } + break; + case COUNT_TO_DATE: + // Count recurrences up to and including the specified date. + if (enddate < mRecurStart.date()) + return 0; + if (rDuration == 0 && enddate > rEndDateTime.date()) { + enddate = rEndDateTime.date(); + endtime.setDate(enddate); + } + break; + case NEXT_AFTER_DATE: + if (enddate < mRecurStart.date()) { + enddate = mRecurStart.date(); + return 1; + } + if (rDuration == 0 && enddate >= rEndDateTime.date()) { + enddate = QDate(); + return 0; + } + break; + default: + enddate = QDate(); + return 0; + } + + int count = 0; // default = error + bool timed = false; + switch (recurs) { + case rMinutely: + timed = true; + count = secondlyCalc(func, endtime, rFreq*60); + break; + case rHourly: + timed = true; + count = secondlyCalc(func, endtime, rFreq*3600); + break; + case rDaily: + count = dailyCalc(func, enddate); + break; + case rWeekly: + count = weeklyCalc(func, enddate); + break; + case rMonthlyPos: + case rMonthlyDay: + count = monthlyCalc(func, enddate); + break; + case rYearlyMonth: + count = yearlyMonthCalc(func, enddate); + break; + case rYearlyPos: + count = yearlyPosCalc(func, enddate); + break; + case rYearlyDay: + count = yearlyDayCalc(func, enddate); + break; + default: + break; + } + + switch (func) { + case END_DATE_AND_COUNT: + case NEXT_AFTER_DATE: + if (count == 0) + endtime = QDate(); + else if (timed) + enddate = endtime.date(); + break; + case COUNT_TO_DATE: + break; + } + return count; +} + +/* Find count and, depending on 'func', the end date/time of a secondly recurrence. + * Reply = total number of occurrences up to 'endtime', or 0 if error. + * If 'func' = END_DATE_AND_COUNT or NEXT_AFTER_DATE, 'endtime' is updated to the + * recurrence end date/time. + */ +int Recurrence::secondlyCalc(PeriodFunc func, QDateTime &endtime, int freq) const +{ + switch (func) { + case END_DATE_AND_COUNT: + endtime = mRecurStart.addSecs((rDuration + mRecurExDatesCount - 1) * freq); + return rDuration + mRecurExDatesCount; + case COUNT_TO_DATE: { + int n = mRecurStart.secsTo(endtime)/freq + 1; + if (rDuration > 0 && n > rDuration + mRecurExDatesCount) + return rDuration + mRecurExDatesCount; + return n; + } + case NEXT_AFTER_DATE: { + int count = mRecurStart.secsTo(endtime) / freq + 2; + if (rDuration > 0 && count > rDuration) + return 0; + endtime = mRecurStart.addSecs((count - 1)*freq); + return count; + } + } + return 0; +} + +/* Find count and, depending on 'func', the end date of a daily recurrence. + * Reply = total number of occurrences up to 'enddate', or 0 if error. + * If 'func' = END_DATE_AND_COUNT or NEXT_AFTER_DATE, 'enddate' is updated to the + * recurrence end date. + */ +int Recurrence::dailyCalc(PeriodFunc func, QDate &enddate) const +{ + QDate dStart = mRecurStart.date(); + switch (func) { + case END_DATE_AND_COUNT: + enddate = dStart.addDays((rDuration + mRecurExDatesCount - 1) * rFreq); + return rDuration + mRecurExDatesCount; + case COUNT_TO_DATE: { + int n = dStart.daysTo(enddate)/rFreq + 1; + if (rDuration > 0 && n > rDuration + mRecurExDatesCount) + return rDuration + mRecurExDatesCount; + return n; + } + case NEXT_AFTER_DATE: { + int count = dStart.daysTo(enddate) / rFreq + 2; + if (rDuration > 0 && count > rDuration) + return 0; + enddate = dStart.addDays((count - 1)*rFreq); + return count; + } + } + return 0; +} + +/* Find count and, depending on 'func', the end date of a weekly recurrence. + * Reply = total number of occurrences up to 'enddate', or 0 if error. + * If 'func' = END_DATE_AND_COUNT or NEXT_AFTER_DATE, 'enddate' is updated to the + * recurrence end date. + */ +int Recurrence::weeklyCalc(PeriodFunc func, QDate &enddate) const +{ + int daysPerWeek = 0; + for (int i = 0; i < 7; ++i) { + if (rDays.testBit((uint)i)) + ++daysPerWeek; + } + if (!daysPerWeek) + return 0; // there are no days to recur on + + switch (func) { + case END_DATE_AND_COUNT: + return weeklyCalcEndDate(enddate, daysPerWeek); + case COUNT_TO_DATE: + return weeklyCalcToDate(enddate, daysPerWeek); + case NEXT_AFTER_DATE: + return weeklyCalcNextAfter(enddate, daysPerWeek); + } + return 0; +} + +int Recurrence::weeklyCalcEndDate(QDate &enddate, int daysPerWeek) const +{ + int startDayOfWeek = mRecurStart.date().dayOfWeek(); // 1..7 + int countGone = 0; + int daysGone = 0; + uint countTogo = rDuration + mRecurExDatesCount; + if (startDayOfWeek != rWeekStart) { + // Check what remains of the start week + for (int i = startDayOfWeek - 1; i != rWeekStart - 1; i = (i + 1) % 7) { + ++daysGone; + if (rDays.testBit((uint)i)) { + ++countGone; + if (--countTogo == 0) + break; + } + } + daysGone += 7 * (rFreq - 1); + } + if (countTogo) { + // Skip the remaining whole weeks + // Leave at least 1 recurrence remaining, in order to get its date + int wholeWeeks = (countTogo - 1) / daysPerWeek; + daysGone += wholeWeeks * 7 * rFreq; + countGone += wholeWeeks * daysPerWeek; + countTogo -= wholeWeeks * daysPerWeek; + // Check the last week in the recurrence + for (int i = rWeekStart - 1; ; i = (i + 1) % 7) { + ++daysGone; + if (rDays.testBit((uint)i)) { + ++countGone; + if (--countTogo == 0) + break; + } + } + } + enddate = mRecurStart.date().addDays(daysGone); + return countGone; +} + +int Recurrence::weeklyCalcToDate(const QDate &enddate, int daysPerWeek) const +{ + QDate dStart = mRecurStart.date(); + int startDayOfWeek = dStart.dayOfWeek(); // 1..7 + int countGone = 0; + int daysGone = 0; + int totalDays = dStart.daysTo(enddate) + 1; + int countMax = (rDuration > 0) ? rDuration + mRecurExDatesCount : INT_MAX; + + if (startDayOfWeek != rWeekStart) { + // Check what remains of the start week + for (int i = startDayOfWeek - 1; i != rWeekStart - 1; i = (i + 1) % 7) { + if (rDays.testBit((uint)i)) { + if (++countGone >= countMax) + return countMax; + } + if (++daysGone == totalDays) + return countGone; + } + daysGone += 7 * (rFreq - 1); + if (daysGone >= totalDays) + return countGone; + } + // Skip the remaining whole weeks + int wholeWeeks = (totalDays - daysGone) / 7; + countGone += (wholeWeeks / rFreq) * daysPerWeek; + if (countGone >= countMax) + return countMax; + daysGone += wholeWeeks * 7; + if (daysGone >= totalDays // have we reached the end date? + || wholeWeeks % rFreq) // is end week a recurrence week? + return countGone; + + // Check the last week in the recurrence + for (int i = rWeekStart - 1; ; i = (i + 1) % 7) { + if (rDays.testBit((uint)i)) { + if (++countGone >= countMax) + return countMax; + } + if (++daysGone == totalDays) + return countGone; + } + return countGone; +} + +int Recurrence::weeklyCalcNextAfter(QDate &enddate, int daysPerWeek) const +{ + QDate dStart = mRecurStart.date(); + int startDayOfWeek = dStart.dayOfWeek(); // 1..7 + int totalDays = dStart.daysTo(enddate) + 1; + uint countTogo = (rDuration > 0) ? rDuration + mRecurExDatesCount : UINT_MAX; + int countGone = 0; + int daysGone = 0; + int recurWeeks; + + if (startDayOfWeek != rWeekStart) { + // Check what remains of the start week + for (int i = startDayOfWeek - 1; i != rWeekStart - 1; i = (i + 1) % 7) { + ++daysGone; + if (rDays.testBit((uint)i)) { + ++countGone; + if (daysGone > totalDays) + goto ex; + if (--countTogo == 0) + return 0; + } + } + daysGone += 7 * (rFreq - 1); + } + + // Skip the remaining whole weeks + recurWeeks = (totalDays - daysGone) / (7 * rFreq); + if (recurWeeks) { + int n = recurWeeks * daysPerWeek; + if (static_cast(n) > countTogo) + return 0; // reached end of recurrence + countGone += n; + countTogo -= n; + daysGone += recurWeeks * 7 * rFreq; + } + + // Check the last week or two in the recurrence + for ( ; ; ) { + for (int i = rWeekStart - 1; ; i = (i + 1) % 7) { + ++daysGone; + if (rDays.testBit((uint)i)) { + ++countGone; + if (daysGone > totalDays) + goto ex; + if (--countTogo == 0) + return 0; + } + } + daysGone += 7 * (rFreq - 1); + } +ex: + enddate = dStart.addDays(daysGone); + return countGone; +} + +/* Find count and, depending on 'func', the end date of a monthly recurrence. + * Reply = total number of occurrences up to 'enddate', or 0 if error. + * If 'func' = END_DATE_AND_COUNT or NEXT_AFTER_DATE, 'enddate' is updated to the + * recurrence end date. + */ +struct Recurrence::MonthlyData { + const Recurrence *recurrence; + int year; // current year + int month; // current month 0..11 + int day; // current day of month 1..31 + bool varies; // true if recurring days vary between different months + private: + QValueList days28, days29, days30, days31; // recurring days in months of each length + QValueList *recurDays[4]; + public: + MonthlyData(const Recurrence* r, const QDate &date) + : recurrence(r), year(date.year()), month(date.month()-1), day(date.day()) + { recurDays[0] = &days28; + recurDays[1] = &days29; + recurDays[2] = &days30; + recurDays[3] = &days31; + varies = (recurrence->recurs == rMonthlyPos) + ? true : recurrence->getMonthlyDayDays(days31, 31); + } + const QValueList* dayList() const { + if (!varies) + return &days31; + QDate startOfMonth(year, month + 1, 1); + int daysInMonth = startOfMonth.daysInMonth(); + QValueList* days = recurDays[daysInMonth - 28]; + if (recurrence->recurs == rMonthlyPos) + recurrence->getMonthlyPosDays(*days, daysInMonth, startOfMonth.dayOfWeek()); + else if (days->isEmpty()) + recurrence->getMonthlyDayDays(*days, daysInMonth); + return days; + } + int yearMonth() const { return year*12 + month; } + void addMonths(int diff) { month += diff; year += month / 12; month %= 12; } + QDate date() const { return QDate(year, month + 1, day); } +}; + +int Recurrence::monthlyCalc(PeriodFunc func, QDate &enddate) const +{ + if (recurs == rMonthlyPos && rMonthPositions.isEmpty() + || recurs == rMonthlyDay && rMonthDays.isEmpty()) + return 0; + + MonthlyData data(this, mRecurStart.date()); + switch (func) { + case END_DATE_AND_COUNT: + return monthlyCalcEndDate(enddate, data); + case COUNT_TO_DATE: + return monthlyCalcToDate(enddate, data); + case NEXT_AFTER_DATE: + return monthlyCalcNextAfter(enddate, data); + } + return 0; +} + +int Recurrence::monthlyCalcEndDate(QDate &enddate, MonthlyData &data) const +{ + uint countTogo = rDuration + mRecurExDatesCount; + int countGone = 0; + QValueList::ConstIterator it; + const QValueList* days = data.dayList(); + + if (data.day > 1) { + // Check what remains of the start month + for (it = days->begin(); it != days->end(); ++it) { + if (*it >= data.day) { + ++countGone; + if (--countTogo == 0) { + data.day = *it; + break; + } + } + } + if (countTogo) { + data.day = 1; + data.addMonths(rFreq); + } + } + if (countTogo) { + if (data.varies) { + // The number of recurrence days varies from month to month, + // so we need to check month by month. + for ( ; ; ) { + days = data.dayList(); + uint n = days->count(); // number of recurrence days in this month + if (n >= countTogo) + break; + countTogo -= n; + countGone += n; + data.addMonths(rFreq); + } + } else { + // The number of recurrences is the same every month, + // so skip the month-by-month check. + // Skip the remaining whole months, but leave at least + // 1 recurrence remaining, in order to get its date. + int daysPerMonth = days->count(); + int wholeMonths = (countTogo - 1) / daysPerMonth; + data.addMonths(wholeMonths * rFreq); + countGone += wholeMonths * daysPerMonth; + countTogo -= wholeMonths * daysPerMonth; + } + if (countTogo) { + // Check the last month in the recurrence + for (it = days->begin(); it != days->end(); ++it) { + ++countGone; + if (--countTogo == 0) { + data.day = *it; + break; + } + } + } + } + enddate = data.date(); + return countGone; +} + +int Recurrence::monthlyCalcToDate(const QDate &enddate, MonthlyData &data) const +{ + int countGone = 0; + int countMax = (rDuration > 0) ? rDuration + mRecurExDatesCount : INT_MAX; + int endYear = enddate.year(); + int endMonth = enddate.month() - 1; // zero-based + int endDay = enddate.day(); + int endYearMonth = endYear*12 + endMonth; + QValueList::ConstIterator it; + const QValueList* days = data.dayList(); + + if (data.day > 1) { + // Check what remains of the start month + for (it = days->begin(); it != days->end(); ++it) { + if (*it >= data.day) { + if (data.yearMonth() == endYearMonth && *it > endDay) + return countGone; + if (++countGone >= countMax) + return countMax; + } + } + data.day = 1; + data.addMonths(rFreq); + } + + if (data.varies) { + // The number of recurrence days varies from month to month, + // so we need to check month by month. + while (data.yearMonth() < endYearMonth) { + countGone += data.dayList()->count(); + if (countGone >= countMax) + return countMax; + data.addMonths(rFreq); + } + days = data.dayList(); + } else { + // The number of recurrences is the same every month, + // so skip the month-by-month check. + // Skip the remaining whole months. + int daysPerMonth = days->count(); + int wholeMonths = endYearMonth - data.yearMonth(); + countGone += (wholeMonths / rFreq) * daysPerMonth; + if (countGone >= countMax) + return countMax; + if (wholeMonths % rFreq) + return countGone; // end year isn't a recurrence year + data.year = endYear; + data.month = endMonth; + } + + // Check the last month in the recurrence + for (it = days->begin(); it != days->end(); ++it) { + if (*it > endDay) + return countGone; + if (++countGone >= countMax) + return countMax; + } + return countGone; +} + +int Recurrence::monthlyCalcNextAfter(QDate &enddate, MonthlyData &data) const +{ + uint countTogo = (rDuration > 0) ? rDuration + mRecurExDatesCount : UINT_MAX; + int countGone = 0; + int endYear = enddate.year(); + int endDay = enddate.day(); + int endYearMonth = endYear*12 + enddate.month() - 1; + QValueList::ConstIterator it; + const QValueList* days = data.dayList(); + + if (data.day > 1) { + // Check what remains of the start month + for (it = days->begin(); it != days->end(); ++it) { + if (*it >= data.day) { + ++countGone; + if (data.yearMonth() == endYearMonth && *it > endDay) { + data.day = *it; + goto ex; + } + if (--countTogo == 0) + return 0; + } + } + data.day = 1; + data.addMonths(rFreq); + } + + if (data.varies) { + // The number of recurrence days varies from month to month, + // so we need to check month by month. + while (data.yearMonth() <= endYearMonth) { + days = data.dayList(); + uint n = days->count(); // number of recurrence days in this month + if (data.yearMonth() == endYearMonth && days->last() > endDay) + break; + if (n >= countTogo) + return 0; + countGone += n; + countTogo -= n; + data.addMonths(rFreq); + } + days = data.dayList(); + } else { + // The number of recurrences is the same every month, + // so skip the month-by-month check. + // Skip the remaining whole months to at least end year/month. + int daysPerMonth = days->count(); + int elapsed = endYearMonth - data.yearMonth(); + int recurMonths = (elapsed + rFreq - 1) / rFreq; + if (elapsed % rFreq == 0 && days->last() <= endDay) + ++recurMonths; // required month is after endYearMonth + if (recurMonths) { + int n = recurMonths * daysPerMonth; + if (static_cast(n) > countTogo) + return 0; // reached end of recurrence + countTogo -= n; + countGone += n; + data.addMonths(recurMonths * rFreq); + } + } + + // Check the last month in the recurrence + for (it = days->begin(); it != days->end(); ++it) { + ++countGone; + if (data.yearMonth() > endYearMonth || *it > endDay) { + data.day = *it; + break; + } + if (--countTogo == 0) + return 0; + } +ex: + enddate = data.date(); + return countGone; +} + + +/* Find count and, depending on 'func', the end date of an annual recurrence by date. + * Reply = total number of occurrences up to 'enddate', or 0 if error. + * If 'func' = END_DATE_AND_COUNT or NEXT_AFTER_DATE, 'enddate' is updated to the + * recurrence end date. + */ +struct Recurrence::YearlyMonthData { + const Recurrence *recurrence; + int year; // current year + int month; // current month 1..12 + int day; // current day of month 1..31 + bool leapyear; // true if February 29th recurs and current year is a leap year + bool feb29; // true if February 29th recurs + private: + QValueList months; // recurring months in non-leap years 1..12 + QValueList leapMonths; // recurring months in leap years 1..12 + public: + YearlyMonthData(const Recurrence* r, const QDate &date) + : recurrence(r), year(date.year()), month(date.month()), day(date.day()) + { feb29 = recurrence->getYearlyMonthMonths(day, months, leapMonths); + leapyear = feb29 && QDate::leapYear(year); + } + const QValueList* monthList() const + { return leapyear ? &leapMonths : &months; } + const QValueList* leapMonthList() const { return &leapMonths; } + QDate date() const { return QDate(year, month, day); } +}; + +int Recurrence::yearlyMonthCalc(PeriodFunc func, QDate &enddate) const +{ + if (rYearNums.isEmpty()) + return 0; + YearlyMonthData data(this, mRecurStart.date()); + switch (func) { + case END_DATE_AND_COUNT: + return yearlyMonthCalcEndDate(enddate, data); + case COUNT_TO_DATE: + return yearlyMonthCalcToDate(enddate, data); + case NEXT_AFTER_DATE: + return yearlyMonthCalcNextAfter(enddate, data); + } + return 0; +} + +// Find total count and end date of an annual recurrence by date. +// Reply = total number of occurrences. +int Recurrence::yearlyMonthCalcEndDate(QDate &enddate, YearlyMonthData &data) const +{ + uint countTogo = rDuration + mRecurExDatesCount; + int countGone = 0; + QValueList::ConstIterator it; + const QValueList* mons = data.monthList(); // get recurring months for this year + + if (data.month > 1) { + // Check what remains of the start year + for (it = mons->begin(); it != mons->end(); ++it) { + if (*it >= data.month) { + ++countGone; + if (--countTogo == 0) { + data.month = *it; + if (data.month == 2 && data.feb29 && !data.leapyear) { + // The recurrence should end on February 29th, but it's a non-leap year + switch (mFeb29YearlyType) { + case rFeb28: + data.day = 28; + break; + case rMar1: + data.month = 3; + data.day = 1; + break; + case rFeb29: + break; + } + } + break; + } + } + } + if (countTogo) { + data.month = 1; + data.year += rFreq; + } + } + if (countTogo) { + if (data.feb29 && mFeb29YearlyType == rFeb29) { + // The number of recurrences is different on leap years, + // so check year-by-year. + for ( ; ; ) { + mons = data.monthList(); + uint n = mons->count(); + if (n >= countTogo) + break; + countTogo -= n; + countGone += n; + data.year += rFreq; + } + } else { + // The number of recurrences is the same every year, + // so skip the year-by-year check. + // Skip the remaining whole years, but leave at least + // 1 recurrence remaining, in order to get its date. + int monthsPerYear = mons->count(); + int wholeYears = (countTogo - 1) / monthsPerYear; + data.year += wholeYears * rFreq; + countGone += wholeYears * monthsPerYear; + countTogo -= wholeYears * monthsPerYear; + } + if (countTogo) { + // Check the last year in the recurrence + for (it = mons->begin(); it != mons->end(); ++it) { + ++countGone; + if (--countTogo == 0) { + data.month = *it; + if (data.month == 2 && data.feb29 && !QDate::leapYear(data.year)) { + // The recurrence should end on February 29th, but it's a non-leap year + switch (mFeb29YearlyType) { + case rFeb28: + data.day = 28; + break; + case rMar1: + data.month = 3; + data.day = 1; + break; + case rFeb29: + break; + } + } + break; + } + } + } + } + enddate = data.date(); + return countGone; +} + +// Find count of an annual recurrence by date. +// Reply = total number of occurrences up to 'enddate'. +int Recurrence::yearlyMonthCalcToDate(const QDate &enddate, YearlyMonthData &data) const +{ + int countGone = 0; + int countMax = (rDuration > 0) ? rDuration + mRecurExDatesCount : INT_MAX; + int endYear = enddate.year(); + int endMonth = enddate.month(); + int endDay = enddate.day(); + if (endDay < data.day) { + /* The end day of the month is earlier than the recurrence day of the month. + * If Feb 29th recurs and: + * 1) it recurs on Feb 28th in non-leap years, don't adjust the end month + * if enddate is Feb 28th on a non-leap year. + * 2) it recurs on Mar 1st in non-leap years, allow the end month to be + * adjusted to February, to simplify calculations. + */ + if (data.feb29 && !QDate::leapYear(endYear) + && mFeb29YearlyType == rFeb28 && endDay == 28 && endMonth == 2) { + } + else if (--endMonth == 0) { + endMonth = 12; + --endYear; + } + } + QValueList::ConstIterator it; + const QValueList* mons = data.monthList(); + + if (data.month > 1) { + // Check what remains of the start year + for (it = mons->begin(); it != mons->end(); ++it) { + if (*it >= data.month) { + if (data.year == endYear && *it > endMonth) + return countGone; + if (++countGone >= countMax) + return countMax; + } + } + data.month = 1; + data.year += rFreq; + } + if (data.feb29 && mFeb29YearlyType == rFeb29) { + // The number of recurrences is different on leap years, + // so check year-by-year. + while (data.year < endYear) { + countGone += data.monthList()->count(); + if (countGone >= countMax) + return countMax; + data.year += rFreq; + } + mons = data.monthList(); + } else { + // The number of recurrences is the same every year, + // so skip the year-by-year check. + // Skip the remaining whole years. + int monthsPerYear = mons->count(); + int wholeYears = endYear - data.year; + countGone += (wholeYears / rFreq) * monthsPerYear; + if (countGone >= countMax) + return countMax; + if (wholeYears % rFreq) + return countGone; // end year isn't a recurrence year + data.year = endYear; + } + + // Check the last year in the recurrence + for (it = mons->begin(); it != mons->end(); ++it) { + if (*it > endMonth) + return countGone; + if (++countGone >= countMax) + return countMax; + } + return countGone; +} + +// Find count and date of first recurrence after 'enddate' of an annual recurrence by date. +// Reply = total number of occurrences up to 'enddate'. +int Recurrence::yearlyMonthCalcNextAfter(QDate &enddate, YearlyMonthData &data) const +{ + uint countTogo = (rDuration > 0) ? rDuration + mRecurExDatesCount : UINT_MAX; + int countGone = 0; + int endYear = enddate.year(); + int endMonth = enddate.month(); + int endDay = enddate.day(); + bool mar1TooEarly = false; + bool feb28ok = false; + if (endDay < data.day) { + if (data.feb29 && mFeb29YearlyType == rMar1 && endMonth == 3) + mar1TooEarly = true; + if (data.feb29 && mFeb29YearlyType == rFeb28 && endMonth == 2 && endDay == 28) + feb28ok = true; + else if (--endMonth == 0) { + endMonth = 12; + --endYear; + } + } + QValueList::ConstIterator it; + const QValueList* mons = data.monthList(); + + if (data.month > 1) { + // Check what remains of the start year + for (it = mons->begin(); it != mons->end(); ++it) { + if (*it >= data.month) { + ++countGone; + if (data.year == endYear + && ( *it > endMonth && (*it > 3 || !mar1TooEarly) + || *it == 2 && feb28ok && data.leapyear)) { + if (*it == 2 && data.feb29 && !data.leapyear) { + // The next recurrence should be on February 29th, but it's a non-leap year + switch (mFeb29YearlyType) { + case rFeb28: + data.month = 2; + data.day = 28; + break; + case rMar1: + data.month = 3; + data.day = 1; + break; + case rFeb29: // impossible in this context! + break; + } + } + else + data.month = *it; + goto ex; + } + if (--countTogo == 0) + return 0; + } + } + data.month = 1; + data.year += rFreq; + } + + if (data.feb29 && mFeb29YearlyType == rFeb29) { + // The number of recurrences is different on leap years, + // so check year-by-year. + while (data.year <= endYear) { + mons = data.monthList(); + if (data.year == endYear && mons->last() > endMonth) + break; + uint n = mons->count(); + if (n >= countTogo) + break; + countTogo -= n; + countGone += n; + data.year += rFreq; + } + mons = data.monthList(); + } else { + // The number of recurrences is the same every year, + // so skip the year-by-year check. + // Skip the remaining whole years to at least endYear. + int monthsPerYear = mons->count(); + int recurYears = (endYear - data.year + rFreq - 1) / rFreq; + if ((endYear - data.year)%rFreq == 0 + && mons->last() <= endMonth) + ++recurYears; // required year is after endYear + if (recurYears) { + int n = recurYears * monthsPerYear; + if (static_cast(n) > countTogo) + return 0; // reached end of recurrence + countTogo -= n; + countGone += n; + data.year += recurYears * rFreq; + } + } + + // Check the last year in the recurrence + for (it = mons->begin(); it != mons->end(); ++it) { + ++countGone; + if (data.year > endYear + || ( *it > endMonth && (*it > 3 || !mar1TooEarly) + || *it == 2 && feb28ok && QDate::leapYear(data.year))) { + if (*it == 2 && data.feb29 && !QDate::leapYear(data.year)) { + // The next recurrence should be on February 29th, but it's a non-leap year + switch (mFeb29YearlyType) { + case rFeb28: + data.month = 2; + data.day = 28; + break; + case rMar1: + data.month = 3; + data.day = 1; + break; + case rFeb29: // impossible in this context! + break; + } + } + else + data.month = *it; + break; + } + if (--countTogo == 0) + return 0; + } +ex: + enddate = data.date(); + return countGone; +} + + +/* Find count and, depending on 'func', the end date of an annual recurrence by date. + * Reply = total number of occurrences up to 'enddate', or 0 if error. + * If 'func' = END_DATE_AND_COUNT or NEXT_AFTER_DATE, 'enddate' is updated to the + * recurrence end date. + */ +struct Recurrence::YearlyPosData { + const Recurrence *recurrence; + int year; // current year + int month; // current month 1..12 + int day; // current day of month 1..31 + int daysPerMonth; // number of days which recur each month, or -1 if variable + int count; // number of days which recur each year, or -1 if variable + bool varies; // true if number of days varies from year to year + private: + mutable QValueList days; + public: + YearlyPosData(const Recurrence* r, const QDate &date) + : recurrence(r), year(date.year()), month(date.month()), day(date.day()), count(-1) + { if ((daysPerMonth = r->countMonthlyPosDays()) > 0) + count = daysPerMonth * r->rYearNums.count(); + varies = (daysPerMonth < 0); + } + const QValueList* dayList() const { + QDate startOfMonth(year, month, 1); + recurrence->getMonthlyPosDays(days, startOfMonth.daysInMonth(), startOfMonth.dayOfWeek()); + return &days; + } + int yearMonth() const { return year*12 + month - 1; } + void addMonths(int diff) { month += diff - 1; year += month / 12; month = month % 12 + 1; } + QDate date() const { return QDate(year, month, day); } +}; + +int Recurrence::yearlyPosCalc(PeriodFunc func, QDate &enddate) const +{ + if (rYearNums.isEmpty() || rMonthPositions.isEmpty()) + return 0; + YearlyPosData data(this, mRecurStart.date()); + switch (func) { + case END_DATE_AND_COUNT: + return yearlyPosCalcEndDate(enddate, data); + case COUNT_TO_DATE: + return yearlyPosCalcToDate(enddate, data); + case NEXT_AFTER_DATE: + return yearlyPosCalcNextAfter(enddate, data); + } + return 0; +} + +int Recurrence::yearlyPosCalcEndDate(QDate &enddate, YearlyPosData &data) const +{ + uint countTogo = rDuration + mRecurExDatesCount; + int countGone = 0; + QValueList::ConstIterator id; + const QValueList* days; + + if (data.month > 1 || data.day > 1) { + // Check what remains of the start year + for (QPtrListIterator im(rYearNums); im.current(); ++im) { + if (*im.current() >= data.month) { + // Check what remains of the start month + if (data.day > 1 || data.varies + || static_cast(data.daysPerMonth) >= countTogo) { + data.month = *im.current(); + days = data.dayList(); + for (id = days->begin(); id != days->end(); ++id) { + if (*id >= data.day) { + ++countGone; + if (--countTogo == 0) { + data.month = *im.current(); + data.day = *id; + goto ex; + } + } + } + data.day = 1; + } else { + // The number of days per month is constant, so skip + // the whole month. + countTogo -= data.daysPerMonth; + countGone += data.daysPerMonth; + } + } + } + data.month = 1; + data.year += rFreq; + } + + if (data.varies) { + // The number of recurrences varies from year to year. + for ( ; ; ) { + for (QPtrListIterator im(rYearNums); im.current(); ++im) { + data.month = *im.current(); + days = data.dayList(); + int n = days->count(); + if (static_cast(n) >= countTogo) { + // Check the last month in the recurrence + for (id = days->begin(); id != days->end(); ++id) { + ++countGone; + if (--countTogo == 0) { + data.day = *id; + goto ex; + } + } + } + countTogo -= n; + countGone += n; + } + data.year += rFreq; + } + } else { + // The number of recurrences is the same every year, + // so skip the year-by-year check. + // Skip the remaining whole years, but leave at least + // 1 recurrence remaining, in order to get its date. + int wholeYears = (countTogo - 1) / data.count; + data.year += wholeYears * rFreq; + countGone += wholeYears * data.count; + countTogo -= wholeYears * data.count; + + // Check the last year in the recurrence. + for (QPtrListIterator im(rYearNums); im.current(); ++im) { + if (static_cast(data.daysPerMonth) >= countTogo) { + // Check the last month in the recurrence + data.month = *im.current(); + days = data.dayList(); + for (id = days->begin(); id != days->end(); ++id) { + ++countGone; + if (--countTogo == 0) { + data.day = *id; + goto ex; + } + } + } + countTogo -= data.daysPerMonth; + countGone += data.daysPerMonth; + } + data.year += rFreq; + } +ex: + enddate = data.date(); + return countGone; +} + +int Recurrence::yearlyPosCalcToDate(const QDate &enddate, YearlyPosData &data) const +{ + int countGone = 0; + int countMax = (rDuration > 0) ? rDuration + mRecurExDatesCount : INT_MAX; + int endYear = enddate.year(); + int endMonth = enddate.month(); + int endDay = enddate.day(); + if (endDay < data.day && --endMonth == 0) { + endMonth = 12; + --endYear; + } + int endYearMonth = endYear*12 + endMonth; + QValueList::ConstIterator id; + const QValueList* days; + + if (data.month > 1 || data.day > 1) { + // Check what remains of the start year + for (QPtrListIterator im(rYearNums); im.current(); ++im) { + if (*im.current() >= data.month) { + data.month = *im.current(); + if (data.yearMonth() > endYearMonth) + return countGone; + // Check what remains of the start month + bool lastMonth = (data.yearMonth() == endYearMonth); + if (lastMonth || data.day > 1 || data.varies) { + days = data.dayList(); + if (lastMonth || data.day > 1) { + for (id = days->begin(); id != days->end(); ++id) { + if (*id >= data.day) { + if (lastMonth && *id > endDay) + return countGone; + if (++countGone >= countMax) + return countMax; + } + } + } else { + countGone += days->count(); + if (countGone >= countMax) + return countMax; + } + data.day = 1; + } else { + // The number of days per month is constant, so skip + // the whole month. + countGone += data.daysPerMonth; + if (countGone >= countMax) + return countMax; + } + } + } + data.month = 1; + data.year += rFreq; + } + + if (data.varies) { + // The number of recurrences varies from year to year. + for ( ; ; ) { + for (QPtrListIterator im(rYearNums); im.current(); ++im) { + data.month = *im.current(); + days = data.dayList(); + if (data.yearMonth() >= endYearMonth) { + if (data.yearMonth() > endYearMonth) + return countGone; + // Check the last month in the recurrence + for (id = days->begin(); id != days->end(); ++id) { + if (*id > endDay) + return countGone; + if (++countGone >= countMax) + return countMax; + } + } else { + countGone += days->count(); + if (countGone >= countMax) + return countMax; + } + } + data.year += rFreq; + } + } else { + // The number of recurrences is the same every year, + // so skip the year-by-year check. + // Skip the remaining whole years, but leave at least + // 1 recurrence remaining, in order to get its date. + int wholeYears = endYear - data.year; + countGone += (wholeYears / rFreq) * data.count; + if (countGone >= countMax) + return countMax; + if (wholeYears % rFreq) + return countGone; // end year isn't a recurrence year + data.year = endYear; + + // Check the last year in the recurrence. + for (QPtrListIterator im(rYearNums); im.current(); ++im) { + data.month = *im.current(); + if (data.month >= endMonth) { + if (data.month > endMonth) + return countGone; + // Check the last month in the recurrence + days = data.dayList(); + for (id = days->begin(); id != days->end(); ++id) { + if (*id > endDay) + return countGone; + if (++countGone >= countMax) + return countMax; + } + } else { + countGone += data.daysPerMonth; + if (countGone >= countMax) + return countMax; + } + } + } + return countGone; +} + +int Recurrence::yearlyPosCalcNextAfter(QDate &enddate, YearlyPosData &data) const +{ + uint countTogo = (rDuration > 0) ? rDuration + mRecurExDatesCount : UINT_MAX; + int countGone = 0; + int endYear = enddate.year(); + int endMonth = enddate.month(); + int endDay = enddate.day(); + if (endDay < data.day && --endMonth == 0) { + endMonth = 12; + --endYear; + } + int endYearMonth = endYear*12 + endMonth; + QValueList::ConstIterator id; + const QValueList* days; + + if (data.varies) { + // The number of recurrences varies from year to year. + for ( ; ; ) { + // Check the next year + for (QPtrListIterator im(rYearNums); im.current(); ++im) { + if (*im.current() >= data.month) { + // Check the next month + data.month = *im.current(); + int ended = data.yearMonth() - endYearMonth; + days = data.dayList(); + if (ended >= 0 || data.day > 1) { + // This is the start or end month, so check each day + for (id = days->begin(); id != days->end(); ++id) { + if (*id >= data.day) { + ++countGone; + if (ended > 0 || (ended == 0 && *id > endDay)) { + data.day = *id; + goto ex; + } + if (--countTogo == 0) + return 0; + } + } + } else { + // Skip the whole month + uint n = days->count(); + if (n >= countTogo) + return 0; + countGone += n; + } + data.day = 1; // we've checked the start month now + } + } + data.month = 1; // we've checked the start year now + data.year += rFreq; + } + } else { + // The number of recurrences is the same every year. + if (data.month > 1 || data.day > 1) { + // Check what remains of the start year + for (QPtrListIterator im(rYearNums); im.current(); ++im) { + if (*im.current() >= data.month) { + // Check what remains of the start month + data.month = *im.current(); + int ended = data.yearMonth() - endYearMonth; + if (ended >= 0 || data.day > 1) { + // This is the start or end month, so check each day + days = data.dayList(); + for (id = days->begin(); id != days->end(); ++id) { + if (*id >= data.day) { + ++countGone; + if (ended > 0 || (ended == 0 && *id > endDay)) { + data.day = *id; + goto ex; + } + if (--countTogo == 0) + return 0; + } + } + data.day = 1; // we've checked the start month now + } else { + // Skip the whole month. + if (static_cast(data.daysPerMonth) >= countTogo) + return 0; + countGone += data.daysPerMonth; + } + } + } + data.year += rFreq; + } + // Skip the remaining whole years to at least endYear. + int recurYears = (endYear - data.year + rFreq - 1) / rFreq; + if ((endYear - data.year)%rFreq == 0 + && *rYearNums.getLast() <= endMonth) + ++recurYears; // required year is after endYear + if (recurYears) { + int n = recurYears * data.count; + if (static_cast(n) > countTogo) + return 0; // reached end of recurrence + countTogo -= n; + countGone += n; + data.year += recurYears * rFreq; + } + + // Check the last year in the recurrence + for (QPtrListIterator im(rYearNums); im.current(); ++im) { + data.month = *im.current(); + int ended = data.yearMonth() - endYearMonth; + if (ended >= 0) { + // This is the end month, so check each day + days = data.dayList(); + for (id = days->begin(); id != days->end(); ++id) { + ++countGone; + if (ended > 0 || (ended == 0 && *id > endDay)) { + data.day = *id; + goto ex; + } + if (--countTogo == 0) + return 0; + } + } else { + // Skip the whole month. + if (static_cast(data.daysPerMonth) >= countTogo) + return 0; + countGone += data.daysPerMonth; + } + } + } +ex: + enddate = data.date(); + return countGone; +} + + +/* Find count and, depending on 'func', the end date of an annual recurrence by day. + * Reply = total number of occurrences up to 'enddate', or 0 if error. + * If 'func' = END_DATE_AND_COUNT or NEXT_AFTER_DATE, 'enddate' is updated to the + * recurrence end date. + */ +struct Recurrence::YearlyDayData { + int year; // current year + int day; // current day of year 1..366 + bool varies; // true if day 366 recurs + private: + int daycount; + public: + YearlyDayData(const Recurrence* r, const QDate &date) + : year(date.year()), day(date.dayOfYear()), varies(*r->rYearNums.getLast() == 366), + daycount(r->rYearNums.count()) { } + bool leapYear() const { return QDate::leapYear(year); } + int dayCount() const { return daycount - (varies && !QDate::leapYear(year) ? 1 : 0); } + bool isMaxDayCount() const { return !varies || QDate::leapYear(year); } + QDate date() const { return QDate(year, 1, 1).addDays(day - 1); } +}; + +int Recurrence::yearlyDayCalc(PeriodFunc func, QDate &enddate) const +{ + if (rYearNums.isEmpty()) + return 0; + YearlyDayData data(this, mRecurStart.date()); + switch (func) { + case END_DATE_AND_COUNT: + return yearlyDayCalcEndDate(enddate, data); + case COUNT_TO_DATE: + return yearlyDayCalcToDate(enddate, data); + case NEXT_AFTER_DATE: + return yearlyDayCalcNextAfter(enddate, data); + } + return 0; +} + +int Recurrence::yearlyDayCalcEndDate(QDate &enddate, YearlyDayData &data) const +{ + uint countTogo = rDuration + mRecurExDatesCount; + int countGone = 0; + + if (data.day > 1) { + // Check what remains of the start year + bool leapOK = data.isMaxDayCount(); + for (QPtrListIterator it(rYearNums); it.current(); ++it) { + int d = *it.current(); + if (d >= data.day && (leapOK || d < 366)) { + ++countGone; + if (--countTogo == 0) { + data.day = d; + goto ex; + } + } + } + data.day = 1; + data.year += rFreq; + } + + if (data.varies) { + // The number of recurrences is different in leap years, + // so check year-by-year. + for ( ; ; ) { + uint n = data.dayCount(); + if (n >= countTogo) + break; + countTogo -= n; + countGone += n; + data.year += rFreq; + } + } else { + // The number of recurrences is the same every year, + // so skip the year-by-year check. + // Skip the remaining whole years, but leave at least + // 1 recurrence remaining, in order to get its date. + int daysPerYear = rYearNums.count(); + int wholeYears = (countTogo - 1) / daysPerYear; + data.year += wholeYears * rFreq; + countGone += wholeYears * daysPerYear; + countTogo -= wholeYears * daysPerYear; + } + if (countTogo) { + // Check the last year in the recurrence + for (QPtrListIterator it(rYearNums); it.current(); ++it) { + ++countGone; + if (--countTogo == 0) { + data.day = *it.current(); + break; + } + } + } +ex: + enddate = data.date(); + return countGone; +} + +int Recurrence::yearlyDayCalcToDate(const QDate &enddate, YearlyDayData &data) const +{ + int countGone = 0; + int countMax = (rDuration > 0) ? rDuration + mRecurExDatesCount : INT_MAX; + int endYear = enddate.year(); + int endDay = enddate.dayOfYear(); + + if (data.day > 1) { + // Check what remains of the start year + bool leapOK = data.isMaxDayCount(); + for (QPtrListIterator it(rYearNums); it.current(); ++it) { + int d = *it.current(); + if (d >= data.day && (leapOK || d < 366)) { + if (data.year == endYear && d > endDay) + return countGone; + if (++countGone >= countMax) + return countMax; + } + } + data.day = 1; + data.year += rFreq; + } + + if (data.varies) { + // The number of recurrences is different in leap years, + // so check year-by-year. + while (data.year < endYear) { + uint n = data.dayCount(); + countGone += n; + if (countGone >= countMax) + return countMax; + data.year += rFreq; + } + if (data.year > endYear) + return countGone; + } else { + // The number of recurrences is the same every year. + // Skip the remaining whole years. + int wholeYears = endYear - data.year; + countGone += (wholeYears / rFreq) * rYearNums.count(); + if (countGone >= countMax) + return countMax; + if (wholeYears % rFreq) + return countGone; // end year isn't a recurrence year + data.year = endYear; + } + + if (data.year <= endYear) { + // Check the last year in the recurrence + for (QPtrListIterator it(rYearNums); it.current(); ++it) { + if (*it.current() > endDay) + return countGone; + if (++countGone >= countMax) + return countMax; + } + } + return countGone; +} + +int Recurrence::yearlyDayCalcNextAfter(QDate &enddate, YearlyDayData &data) const +{ + uint countTogo = (rDuration > 0) ? rDuration + mRecurExDatesCount : UINT_MAX; + int countGone = 0; + int endYear = enddate.year(); + int endDay = enddate.dayOfYear(); + + if (data.day > 1) { + // Check what remains of the start year + bool leapOK = data.isMaxDayCount(); + for (QPtrListIterator it(rYearNums); it.current(); ++it) { + int d = *it.current(); + if (d >= data.day && (leapOK || d < 366)) { + ++countGone; + if (data.year == endYear && d > endDay) { + data.day = d; + goto ex; + } + if (--countTogo == 0) + return 0; + } + } + data.day = 1; + data.year += rFreq; + } + + if (data.varies) { + // The number of recurrences is different in leap years, + // so check year-by-year. + while (data.year <= endYear) { + uint n = data.dayCount(); + if (data.year == endYear && *rYearNums.getLast() > endDay) + break; + if (n >= countTogo) + break; + countTogo -= n; + countGone += n; + data.year += rFreq; + } + } else { + // The number of recurrences is the same every year, + // so skip the year-by-year check. + // Skip the remaining whole years to at least endYear. + int daysPerYear = rYearNums.count(); + int recurYears = (endYear - data.year + rFreq - 1) / rFreq; + if ((endYear - data.year)%rFreq == 0 + && *rYearNums.getLast() <= endDay) + ++recurYears; // required year is after endYear + if (recurYears) { + int n = recurYears * daysPerYear; + if (static_cast(n) > countTogo) + return 0; // reached end of recurrence + countTogo -= n; + countGone += n; + data.year += recurYears * rFreq; + } + } + + // Check the last year in the recurrence + for (QPtrListIterator it(rYearNums); it.current(); ++it) { + ++countGone; + int d = *it.current(); + if (data.year > endYear || d > endDay) { + data.day = d; + break; + } + if (--countTogo == 0) + return 0; + } +ex: + enddate = data.date(); + return countGone; +} + +// Get the days in this month which recur, in numerical order. +// Parameters: daysInMonth = number of days in this month +// startDayOfWeek = day of week for first day of month. +void Recurrence::getMonthlyPosDays(QValueList &list, int daysInMonth, int startDayOfWeek) const +{ + list.clear(); + int endDayOfWeek = (startDayOfWeek + daysInMonth - 2) % 7 + 1; + // Go through the list, compiling a bit list of actual day numbers + Q_UINT32 days = 0; + for (QPtrListIterator pos(rMonthPositions); pos.current(); ++pos) { + int weeknum = pos.current()->rPos - 1; // get 0-based week number + QBitArray &rdays = pos.current()->rDays; + if (pos.current()->negative) { + // nth days before the end of the month + for (uint i = 1; i <= 7; ++i) { + if (rdays.testBit(i - 1)) { + int day = daysInMonth - weeknum*7 - (endDayOfWeek - i + 7) % 7; + if (day > 0) + days |= 1 << (day - 1); + } + } + } else { + // nth days after the start of the month + for (uint i = 1; i <= 7; ++i) { + if (rdays.testBit(i - 1)) { + int day = 1 + weeknum*7 + (i - startDayOfWeek + 7) % 7; + if (day <= daysInMonth) + days |= 1 << (day - 1); + } + } + } + } + // Compile the ordered list + Q_UINT32 mask = 1; + for (int i = 0; i < daysInMonth; mask <<= 1, ++i) { + if (days & mask) + list.append(i + 1); + } +} + +// Get the number of days in the month which recur. +// Reply = -1 if the number varies from month to month. +int Recurrence::countMonthlyPosDays() const +{ + int count = 0; + Q_UINT8 positive[5] = { 0, 0, 0, 0, 0 }; + Q_UINT8 negative[4] = { 0, 0, 0, 0 }; + for (QPtrListIterator pos(rMonthPositions); pos.current(); ++pos) { + int weeknum = pos.current()->rPos; + Q_UINT8* wk; + if (pos.current()->negative) { + // nth days before the end of the month + if (weeknum > 4) + return -1; // days in 5th week are often missing + wk = &negative[4 - weeknum]; + } else { + // nth days after the start of the month + if (weeknum > 4) + return -1; // days in 5th week are often missing + wk = &positive[weeknum - 1]; + } + QBitArray &rdays = pos.current()->rDays; + for (uint i = 0; i < 7; ++i) { + if (rdays.testBit(i)) { + ++count; + *wk |= (1 << i); + } + } + } + // Check for any possible days which could be duplicated by + // a positive and a negative position. + for (int i = 0; i < 4; ++i) { + if (negative[i] & (positive[i] | positive[i+1])) + return -1; + } + return count; +} + +// Get the days in this month which recur, in numerical order. +// Reply = true if day numbers varies from month to month. +bool Recurrence::getMonthlyDayDays(QValueList &list, int daysInMonth) const +{ + list.clear(); + bool variable = false; + Q_UINT32 days = 0; + for (QPtrListIterator it(rMonthDays); it.current(); ++it) { + int day = *it.current(); + if (day > 0) { + // date in the month + if (day <= daysInMonth) + days |= 1 << (day - 1); + if (day > 28 && day <= 31) + variable = true; // this date does not appear in some months + } else if (day < 0) { + // days before the end of the month + variable = true; // this date varies depending on the month length + day = daysInMonth + day; // zero-based day of month + if (day >= 0) + days |= 1 << day; + } + } + // Compile the ordered list + Q_UINT32 mask = 1; + for (int i = 0; i < daysInMonth; mask <<= 1, ++i) { + if (days & mask) + list.append(i + 1); + } + return variable; +} + +// Get the months which recur, in numerical order, for both leap years and non-leap years. +// N.B. If February 29th recurs on March 1st in non-leap years, February (not March) is +// included in the non-leap year month list. +// Reply = true if February 29th also recurs. +bool Recurrence::getYearlyMonthMonths(int day, QValueList &list, QValueList &leaplist) const +{ + list.clear(); + leaplist.clear(); + bool feb29 = false; + for (QPtrListIterator it(rYearNums); it.current(); ++it) { + int month = *it.current(); + if (month == 2) { + if (day <= 28) { + list.append(month); // date appears in February + leaplist.append(month); + } + else if (day == 29) { + // February 29th + leaplist.append(month); + switch (mFeb29YearlyType) { + case rFeb28: + case rMar1: + list.append(2); + break; + case rFeb29: + break; + } + feb29 = true; + } + } + else if (day <= 30 || QDate(2000, month, 1).daysInMonth() == 31) { + list.append(month); // date appears in every month + leaplist.append(month); + } + } + return feb29; +} + +/* From the recurrence day of the week list, get the earliest day in the + * specified week which is >= the startDay. + * Parameters: startDay = 1..7 (Monday..Sunday) + * useWeekStart = true to end search at day before next rWeekStart + * = false to search for a full 7 days + * Reply = day of the week (1..7), or 0 if none found. + */ +int Recurrence::getFirstDayInWeek(int startDay, bool useWeekStart) const +{ + int last = ((useWeekStart ? rWeekStart : startDay) + 5)%7; + for (int i = startDay - 1; ; i = (i + 1)%7) { + if (rDays.testBit(i)) + return i + 1; + if (i == last) + return 0; + } +} + +/* From the recurrence day of the week list, get the latest day in the + * specified week which is <= the endDay. + * Parameters: endDay = 1..7 (Monday..Sunday) + * useWeekStart = true to end search at rWeekStart + * = false to search for a full 7 days + * Reply = day of the week (1..7), or 0 if none found. + */ +int Recurrence::getLastDayInWeek(int endDay, bool useWeekStart) const +{ + int last = useWeekStart ? rWeekStart - 1 : endDay%7; + for (int i = endDay - 1; ; i = (i + 6)%7) { + if (rDays.testBit(i)) + return i + 1; + if (i == last) + return 0; + } +} + +/* From the recurrence monthly day number list or monthly day of week/week of + * month list, get the earliest day in the specified month which is >= the + * earliestDate. + */ +QDate Recurrence::getFirstDateInMonth(const QDate &earliestDate) const +{ + int earliestDay = earliestDate.day(); + int daysInMonth = earliestDate.daysInMonth(); + switch (recurs) { + case rMonthlyDay: { + int minday = daysInMonth + 1; + for (QPtrListIterator it(rMonthDays); it.current(); ++it) { + int day = *it.current(); + if (day < 0) + day = daysInMonth + day + 1; + if (day >= earliestDay && day < minday) + minday = day; + } + if (minday <= daysInMonth) + return earliestDate.addDays(minday - earliestDay); + break; + } + case rMonthlyPos: + case rYearlyPos: { + QDate monthBegin(earliestDate.addDays(1 - earliestDay)); + QValueList dayList; + getMonthlyPosDays(dayList, daysInMonth, monthBegin.dayOfWeek()); + for (QValueList::ConstIterator id = dayList.begin(); id != dayList.end(); ++id) { + if (*id >= earliestDay) + return monthBegin.addDays(*id - 1); + } + break; + } + } + return QDate(); +} + +/* From the recurrence monthly day number list or monthly day of week/week of + * month list, get the latest day in the specified month which is <= the + * latestDate. + */ +QDate Recurrence::getLastDateInMonth(const QDate &latestDate) const +{ + int latestDay = latestDate.day(); + int daysInMonth = latestDate.daysInMonth(); + switch (recurs) { + case rMonthlyDay: { + int maxday = -1; + for (QPtrListIterator it(rMonthDays); it.current(); ++it) { + int day = *it.current(); + if (day < 0) + day = daysInMonth + day + 1; + if (day <= latestDay && day > maxday) + maxday = day; + } + if (maxday > 0) + return QDate(latestDate.year(), latestDate.month(), maxday); + break; + } + case rMonthlyPos: + case rYearlyPos: { + QDate monthBegin(latestDate.addDays(1 - latestDay)); + QValueList dayList; + getMonthlyPosDays(dayList, daysInMonth, monthBegin.dayOfWeek()); + for (QValueList::ConstIterator id = dayList.fromLast(); id != dayList.end(); --id) { + if (*id <= latestDay) + return monthBegin.addDays(*id - 1); + } + break; + } + } + return QDate(); +} + +/* From the recurrence yearly month list or yearly day list, get the earliest + * month or day in the specified year which is >= the earliestDate. + * Note that rYearNums is sorted in numerical order. + */ +QDate Recurrence::getFirstDateInYear(const QDate &earliestDate) const +{ + QPtrListIterator it(rYearNums); + switch (recurs) { + case rYearlyMonth: { + int day = recurStart().date().day(); + int earliestYear = earliestDate.year(); + int earliestMonth = earliestDate.month(); + int earliestDay = earliestDate.day(); + if (earliestDay > day) { + // The earliest date is later in the month than the recurrence date, + // so skip to the next month before starting to check + if (++earliestMonth > 12) + return QDate(); + } + for ( ; it.current(); ++it) { + int month = *it.current(); + if (month >= earliestMonth) { + if (day <= 28 || QDate::isValid(earliestYear, month, day)) + return QDate(earliestYear, month, day); + if (day == 29 && month == 2) { + // It's a recurrence on February 29th, in a non-leap year + switch (mFeb29YearlyType) { + case rMar1: + return QDate(earliestYear, 3, 1); + case rFeb28: + if (earliestDay <= 28) + return QDate(earliestYear, 2, 28); + break; + case rFeb29: + break; + } + } + } + } + break; + } + case rYearlyPos: { + QValueList dayList; + int earliestYear = earliestDate.year(); + int earliestMonth = earliestDate.month(); + int earliestDay = earliestDate.day(); + for ( ; it.current(); ++it) { + int month = *it.current(); + if (month >= earliestMonth) { + QDate monthBegin(earliestYear, month, 1); + getMonthlyPosDays(dayList, monthBegin.daysInMonth(), monthBegin.dayOfWeek()); + for (QValueList::ConstIterator id = dayList.begin(); id != dayList.end(); ++id) { + if (*id >= earliestDay) + return monthBegin.addDays(*id - 1); + } + earliestDay = 1; + } + } + break; + } + case rYearlyDay: { + int earliestDay = earliestDate.dayOfYear(); + for ( ; it.current(); ++it) { + int day = *it.current(); + if (day >= earliestDay && (day <= 365 || day <= earliestDate.daysInYear())) + return earliestDate.addDays(day - earliestDay); + } + break; + } + } + return QDate(); +} + +/* From the recurrence yearly month list or yearly day list, get the latest + * month or day in the specified year which is <= the latestDate. + * Note that rYearNums is sorted in numerical order. + */ +QDate Recurrence::getLastDateInYear(const QDate &latestDate) const +{ + QPtrListIterator it(rYearNums); + switch (recurs) { + case rYearlyMonth: { + int day = recurStart().date().day(); + int latestYear = latestDate.year(); + int latestMonth = latestDate.month(); + if (latestDate.day() > day) { + // The latest date is earlier in the month than the recurrence date, + // so skip to the previous month before starting to check + if (--latestMonth <= 0) + return QDate(); + } + for (it.toLast(); it.current(); --it) { + int month = *it.current(); + if (month <= latestMonth) { + if (day <= 28 || QDate::isValid(latestYear, month, day)) + return QDate(latestYear, month, day); + if (day == 29 && month == 2) { + // It's a recurrence on February 29th, in a non-leap year + switch (mFeb29YearlyType) { + case rMar1: + if (latestMonth >= 3) + return QDate(latestYear, 3, 1); + break; + case rFeb28: + return QDate(latestYear, 2, 28); + case rFeb29: + break; + } + } + } + } + break; + } + case rYearlyPos: { + QValueList dayList; + int latestYear = latestDate.year(); + int latestMonth = latestDate.month(); + int latestDay = latestDate.day(); + for (it.toLast(); it.current(); --it) { + int month = *it.current(); + if (month <= latestMonth) { + QDate monthBegin(latestYear, month, 1); + getMonthlyPosDays(dayList, monthBegin.daysInMonth(), monthBegin.dayOfWeek()); + for (QValueList::ConstIterator id = dayList.fromLast(); id != dayList.end(); --id) { + if (*id <= latestDay) + return monthBegin.addDays(*id - 1); + } + latestDay = 31; + } + } + break; + } + case rYearlyDay: { + int latestDay = latestDate.dayOfYear(); + for (it.toLast(); it.current(); --it) { + int day = *it.current(); + if (day <= latestDay) + return latestDate.addDays(day - latestDay); + } + break; + } + } + return QDate(); +} + +void Recurrence::dump() const +{ + kdDebug() << "Recurrence::dump():" << endl; + + kdDebug() << " type: " << recurs << endl; + + kdDebug() << " rDays: " << endl; + int i; + for( i = 0; i < 7; ++i ) { + kdDebug() << " " << i << ": " + << ( rDays.testBit( i ) ? "true" : "false" ) << endl; + } +} diff --git a/libkcal/recurrence.h b/libkcal/recurrence.h new file mode 100644 index 0000000..a0f6d84 --- a/dev/null +++ b/libkcal/recurrence.h @@ -0,0 +1,401 @@ +/* + This file is part of libkcal. + Copyright (c) 1998 Preston Brown + Copyright (c) 2001 Cornelius Schumacher + Copyright (c) 2002 David Jarvie + + 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_RECURRENCE_H +#define KCAL_RECURRENCE_H + +#include +#include +#include + +namespace KCal { + +class Incidence; + +/** + This class represents a recurrence rule for a calendar incidence. +*/ +class Recurrence +{ + public: + /** enumeration for describing how an event recurs, if at all. */ + enum { rNone = 0, rMinutely = 0x001, rHourly = 0x0002, rDaily = 0x0003, + rWeekly = 0x0004, rMonthlyPos = 0x0005, rMonthlyDay = 0x0006, + rYearlyMonth = 0x0007, rYearlyDay = 0x0008, rYearlyPos = 0x0009 }; + + /** Enumeration for specifying what date yearly recurrences of February 29th occur + * in non-leap years. */ + enum Feb29Type { + rMar1, // recur on March 1st (default) + rFeb28, // recur on February 28th + rFeb29 // only recur on February 29th, i.e. don't recur in non-leap years + }; + + /** structure for Recurs rMonthlyPos */ + struct rMonthPos { + QBitArray rDays; + short rPos; + bool negative; + }; + + Recurrence(Incidence *parent, int compatVersion = 0); + Recurrence(const Recurrence&, Incidence *parent); + ~Recurrence(); + + bool operator==( const Recurrence& ) const; + bool operator!=( const Recurrence& r ) const { return !operator==(r); } + + Incidence *parent() { return mParent; } + + /** Return the start of the recurrence */ + QDateTime recurStart() const { return mRecurStart; } + /** Returns the number of exception dates for the recurrence */ + int recurExDatesCount() const { return mRecurExDatesCount; } + /** Set start of recurrence, as a date and time. */ + void setRecurStart(const QDateTime &start); + /** Set start of recurrence, as a date with no time. + * Recurrence types which are sub-daily (e.g. rHourly) always have a time; + * the time is set to 00:00:00 in these cases. */ + void setRecurStart(const QDate &start); + /** Set whether the recurrence has no time, just a date. + * Recurrence types which are sub-daily (e.g. rHourly) always have a time + * and cannot be set to float. + * N.B. This property is derived by default from the parent incidence, + * or according to whether a time is specified in setRecurStart(). */ + void setFloats(bool f); + /** + Returns whether the recurrence has no time, just a date. + */ + bool doesFloat() const { + return mFloats; + } + + /** Set if recurrence is read-only or can be changed. */ + void setRecurReadOnly(bool readOnly) { mRecurReadOnly = readOnly; } + bool recurReadOnly() const + { + return mRecurReadOnly; + } + + + /** Set number of exception dates. */ + void setRecurExDatesCount(int count) { if (count >= 0) mRecurExDatesCount = count; } + /** Set the calendar file version for backwards compatibility. + * @var version is the KOrganizer/libkcal version, e.g. 220 for KDE 2.2.0. + * Specify version = 0 to cancel compatibility mode. + */ + void setCompatVersion(int version = 0); + + /** Returns the event's recurrence status. See the enumeration at the top + * of this file for possible values. */ + ushort doesRecur() const; + /** Returns true if the date specified is one on which the event will + * recur. */ + bool recursOnPure(const QDate &qd) const; + /** Returns true if the date/time specified is one at which the event will + * recur. Times are rounded down to the nearest minute to determine the result. */ + bool recursAtPure(const QDateTime &) const; + /** Turns off recurrence for the event. */ + void unsetRecurs(); + + /** Returns the date of the next recurrence, after the specified date. + * @var preDate the date after which to find the recurrence. + * @var last if non-null, *last is set to true if the next recurrence is the + * last recurrence, else false. + * Reply = date of next recurrence, or invalid date if none. + */ + QDate getNextDate(const QDate& preDate, bool* last = 0) const; + /** Returns the date and time of the next recurrence, after the specified date/time. + * If the recurrence has no time, the next date after the specified date is returned. + * @var preDate the date/time after which to find the recurrence. + * @var last if non-null, *last is set to true if the next recurrence is the + * last recurrence, else false. + * Reply = date/time of next recurrence, or invalid date if none. + */ + QDateTime getNextDateTime(const QDateTime& preDateTime, bool* last = 0) const; + /** Returns the date of the last previous recurrence, before the specified date. + * @var afterDate the date before which to find the recurrence. + * @var last if non-null, *last is set to true if the previous recurrence is the + * last recurrence, else false. + * Reply = date of previous recurrence, or invalid date if none. + */ + QDate getPreviousDate(const QDate& afterDate, bool* last = 0) const; + /** Returns the date and time of the last previous recurrence, before the specified date/time. + * If a time later than 00:00:00 is specified and the recurrence has no time, 00:00:00 on + * the specified date is returned if that date recurs. + * @var afterDate the date/time before which to find the recurrence. + * @var last if non-null, *last is set to true if the previous recurrence is the + * last recurrence, else false. + * Reply = date/time of previous recurrence, or invalid date if none. + */ + QDateTime getPreviousDateTime(const QDateTime& afterDateTime, bool* last = 0) const; + + /** Returns frequency of recurrence, in terms of the recurrence time period type. */ + int frequency() const; + /** Returns the total number of recurrences, including the initial occurrence. */ + int duration() const; + /** Sets the total number of times the event is to occur, including both the + * first and last. */ + void setDuration(int duration); + /** Returns the number of recurrences up to and including the date specified. */ + int durationTo(const QDate &) const; + /** Returns the number of recurrences up to and including the date/time specified. */ + int durationTo(const QDateTime &) const; + + /** Returns the date of the last recurrence. + * An invalid date is returned if the recurrence has no end. + * Note: for some recurrence types, endDate() can involve significant calculation. + */ + QDate endDate() const; + /** Returns the date and time of the last recurrence. + * An invalid date is returned if the recurrence has no end. + * Note: for some recurrence types, endDateTime() can involve significant calculation. + */ + QDateTime endDateTime() const; + /** Returns a string representing the recurrence end date in the format + according to the user's locale settings. */ + QString endDateStr(bool shortfmt=true) const; + + /** Sets an event to recur minutely. + * @var _rFreq the frequency to recur, e.g. 2 is every other minute + * @var duration the number of times the event is to occur, or -1 to recur indefinitely. + */ + void setMinutely(int _rFreq, int duration); + /** Sets an event to recur minutely. + * @var _rFreq the frequency to recur, e.g. 2 is every other minute + * @var endDateTime the ending date/time after which to stop recurring + */ + void setMinutely(int _rFreq, const QDateTime &endDateTime); + + /** Sets an event to recur hourly. + * @var _rFreq the frequency to recur, e.g. 2 is every other hour + * @var duration the number of times the event is to occur, or -1 to recur indefinitely. + */ + void setHourly(int _rFreq, int duration); + /** Sets an event to recur hourly. + * @var _rFreq the frequency to recur, e.g. 2 is every other hour + * @var endDateTime the ending date/time after which to stop recurring + */ + void setHourly(int _rFreq, const QDateTime &endDateTime); + + /** Sets an event to recur daily. + * @var _rFreq the frequency to recur, e.g. 2 is every other day + * @var duration the number of times the event is to occur, or -1 to recur indefinitely. + */ + void setDaily(int _rFreq, int duration); + /** Sets an event to recur daily. + * @var _rFreq the frequency to recur, e.g. 2 is every other day + * @var endDate the ending date after which to stop recurring + */ + void setDaily(int _rFreq, const QDate &endDate); + + /** Sets an event to recur weekly. + * @var _rFreq the frequency to recur, e.g. every other week etc. + * @var _rDays a 7 bit array indicating which days on which to recur (bit 0 = Monday). + * @var duration the number of times the event is to occur, or -1 to recur indefinitely. + * @var weekStart the first day of the week (Monday=1 .. Sunday=7, default is Monday). + */ + void setWeekly(int _rFreq, const QBitArray &_rDays, int duration, int weekStart = 1); + /** Sets an event to recur weekly. + * @var _rFreq the frequency to recur, e.g. every other week etc. + * @var _rDays a 7 bit array indicating which days on which to recur (bit 0 = Monday). + * @var endDate the date on which to stop recurring. + * @var weekStart the first day of the week (Monday=1 .. Sunday=7, default is Monday). + */ + void setWeekly(int _rFreq, const QBitArray &_rDays, const QDate &endDate, int weekStart = 1); + /** Returns the first day of the week. Monday=1 .. Sunday=7. */ + int weekStart() const { return rWeekStart; } + /** Returns week day mask (bit 0 = Monday). */ + const QBitArray &days() const; + + /** Sets an event to recur monthly. + * @var type rMonthlyPos or rMonthlyDay + * @var _rFreq the frequency to recur, e.g. 3 for every third month. + * @var duration the number of times the event is to occur, or -1 to recur indefinitely. + */ + void setMonthly(short type, int _rFreq, int duration); + /** same as above, but with ending date not number of recurrences */ + void setMonthly(short type, int _rFreq, const QDate &endDate); + /** Adds a position to the recursMonthlyPos recurrence rule, if it is + * set. + * @var _rPos the position in the month for the recurrence, with valid + * values being 1-5 (5 weeks max in a month). + * @var _rDays the days for the position to recur on (bit 0 = Monday). + * Example: _rPos = 2, and bits 0 and 2 are set in _rDays: + * the rule is to repeat every 2nd Monday and Wednesday in the month. + */ + void addMonthlyPos(short _rPos, const QBitArray &_rDays); + /** Adds a position the the recursMonthlyDay list. + * @var _rDay the date in the month to recur. + */ + void addMonthlyDay(short _rDay); + /** Returns list of day positions in months. */ + const QPtrList &monthPositions() const; + /** Returns list of day numbers of a month. */ + const QPtrList &monthDays() const; + + /** Sets an event to recur yearly. + * @var type rYearlyMonth, rYearlyPos or rYearlyDay + * @var freq the frequency to recur, e.g. 3 for every third year. + * @var duration the number of times the event is to occur, or -1 to recur indefinitely. + */ + void setYearly(int type, int freq, int duration); + /** Sets an event to recur yearly ending at \a endDate. */ + void setYearly(int type, int freq, const QDate &endDate); + /** Sets an event to recur yearly on specified dates. + * The dates must be specified by calling addYearlyNum(). + * @var type the way recurrences of February 29th are to be handled in non-leap years. + * @var freq the frequency to recur, e.g. 3 for every third year. + * @var duration the number of times the event is to occur, or -1 to recur indefinitely. + */ + void setYearlyByDate(Feb29Type type, int freq, int duration); + /** Sets an event to recur yearly ending at \a endDate. */ + void setYearlyByDate(Feb29Type type, int freq, const QDate &endDate); + /** Adds position of day or month in year. + * N.B. for recursYearlyPos, addYearlyMonthPos() must also be called + * to add positions within the month. */ + void addYearlyNum(short _rNum); + /** Adds a position to the recursYearlyPos recurrence rule, if it is set. + * N.B. addYearlyNum() must also be called to add recurrence months. + * Parameters are the same as for addMonthlyPos(). + */ + void addYearlyMonthPos(short _rPos, const QBitArray &_rDays); + /** Returns positions of days or months in year. */ + const QPtrList &yearNums() const; + /** Returns list of day positions in months, for a recursYearlyPos recurrence rule. */ + const QPtrList &yearMonthPositions() const; + /** Returns how yearly recurrences of February 29th are handled. */ + Feb29Type feb29YearlyType() const { return mFeb29YearlyType; } + /** Sets the default method for handling yearly recurrences of February 29th. */ + static void setFeb29YearlyTypeDefault(Feb29Type t) { mFeb29YearlyDefaultType = t; } + /** Returns the default method for handling yearly recurrences of February 29th. */ + static Feb29Type setFeb29YearlyTypeDefault() { return mFeb29YearlyDefaultType; } + + /** + Debug output. + */ + void dump() const; + QString recurrenceText() const; + + protected: + enum PeriodFunc { END_DATE_AND_COUNT, COUNT_TO_DATE, NEXT_AFTER_DATE }; + struct MonthlyData; friend struct MonthlyData; + struct YearlyMonthData; friend struct YearlyMonthData; + struct YearlyPosData; friend struct YearlyPosData; + struct YearlyDayData; friend struct YearlyDayData; + + bool recursSecondly(const QDate &, int secondFreq) const; + bool recursMinutelyAt(const QDateTime &dt, int minuteFreq) const; + bool recursDaily(const QDate &) const; + bool recursWeekly(const QDate &) const; + bool recursMonthly(const QDate &) const; + bool recursYearlyByMonth(const QDate &) const; + bool recursYearlyByPos(const QDate &) const; + bool recursYearlyByDay(const QDate &) const; + + QDate getNextDateNoTime(const QDate& preDate, bool* last) const; + QDate getPreviousDateNoTime(const QDate& afterDate, bool* last) const; + + void addMonthlyPos_(short _rPos, const QBitArray &_rDays); + void setDailySub(short type, int freq, int duration); + void setYearly_(short type, Feb29Type, int freq, int duration); + int recurCalc(PeriodFunc, QDate &enddate) const; + int recurCalc(PeriodFunc, QDateTime &endtime) const; + int secondlyCalc(PeriodFunc, QDateTime& endtime, int freq) const; + int dailyCalc(PeriodFunc, QDate &enddate) const; + int weeklyCalc(PeriodFunc, QDate &enddate) const; + int weeklyCalcEndDate(QDate& enddate, int daysPerWeek) const; + int weeklyCalcToDate(const QDate& enddate, int daysPerWeek) const; + int weeklyCalcNextAfter(QDate& enddate, int daysPerWeek) const; + int monthlyCalc(PeriodFunc, QDate &enddate) const; + int monthlyCalcEndDate(QDate& enddate, MonthlyData&) const; + int monthlyCalcToDate(const QDate& enddate, MonthlyData&) const; + int monthlyCalcNextAfter(QDate& enddate, MonthlyData&) const; + int yearlyMonthCalc(PeriodFunc, QDate &enddate) const; + int yearlyMonthCalcEndDate(QDate& enddate, YearlyMonthData&) const; + int yearlyMonthCalcToDate(const QDate& enddate, YearlyMonthData&) const; + int yearlyMonthCalcNextAfter(QDate& enddate, YearlyMonthData&) const; + int yearlyPosCalc(PeriodFunc, QDate &enddate) const; + int yearlyPosCalcEndDate(QDate& enddate, YearlyPosData&) const; + int yearlyPosCalcToDate(const QDate& enddate, YearlyPosData&) const; + int yearlyPosCalcNextAfter(QDate& enddate, YearlyPosData&) const; + int yearlyDayCalc(PeriodFunc, QDate &enddate) const; + int yearlyDayCalcEndDate(QDate& enddate, YearlyDayData&) const; + int yearlyDayCalcToDate(const QDate& enddate, YearlyDayData&) const; + int yearlyDayCalcNextAfter(QDate& enddate, YearlyDayData&) const; + + int countMonthlyPosDays() const; + void getMonthlyPosDays(QValueList&, int daysInMonth, + int startDayOfWeek) const; + bool getMonthlyDayDays(QValueList&, int daysInMonth) const; + bool getYearlyMonthMonths(int day, QValueList&, + QValueList &leaplist) const; + + int getFirstDayInWeek(int startDay, bool useWeekStart = true) const; + int getLastDayInWeek(int endDay, bool useWeekStart = true) const; + QDate getFirstDateInMonth(const QDate& earliestDate) const; + QDate getLastDateInMonth(const QDate& latestDate) const; + QDate getFirstDateInYear(const QDate& earliestDate) const; + QDate getLastDateInYear(const QDate& latestDate) const; + + private: + // Prohibit copying + Recurrence(const Recurrence&); + Recurrence &operator=(const Recurrence&); + + short recurs; // should be one of the enums. + + int rWeekStart; // day which starts the week, Monday=1 .. Sunday=7 + QBitArray rDays; // array of days during week it recurs + + QPtrList rMonthPositions; // list of positions during a month + // on which an event recurs + + QPtrList rMonthDays; // list of days during a month on + // which the event recurs + + QPtrList rYearNums; // either months/days to recur on for rYearly, + // sorted in numerical order + + int rFreq; // frequency of period + + // one of the following must be specified + int rDuration; // num times to recur (inc. first occurrence), -1 = infinite + QDateTime rEndDateTime; // date/time at which to end recurrence + + QDateTime mRecurStart; // date/time of first recurrence + bool mFloats; // the recurrence has no time, just a date + bool mRecurReadOnly; + int mRecurExDatesCount; // number of recurrences (in addition to rDuration) which are excluded + Feb29Type mFeb29YearlyType; // how to handle yearly recurrences of February 29th + static Feb29Type mFeb29YearlyDefaultType; // default value for mFeb29YearlyType + + // Backwards compatibility for KDE < 3.1. + int mCompatVersion; // calendar file version for backwards compatibility + short mCompatRecurs; // original 'recurs' in old calendar format, or rNone + int mCompatDuration; // original 'rDuration' in old calendar format, or 0 + + Incidence *mParent; +}; + +} + +#endif diff --git a/libkcal/resourcecalendar.h b/libkcal/resourcecalendar.h new file mode 100644 index 0000000..26b3831 --- a/dev/null +++ b/libkcal/resourcecalendar.h @@ -0,0 +1,16 @@ +#ifndef MICRO_KCAL_RESOURCECALENDAR_H +#define MICRO_KCAL_RESOURCECALENDAR_H + +namespace KCal { + +class ResourceCalendar +{ +}; + +class CalendarResourceManager +{ +}; + +} + +#endif diff --git a/libkcal/scheduler.cpp b/libkcal/scheduler.cpp new file mode 100644 index 0000000..253d8b7 --- a/dev/null +++ b/libkcal/scheduler.cpp @@ -0,0 +1,355 @@ +/* + This file is part of libkcal. + Copyright (c) 2001 Cornelius Schumacher + + 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 +#include +#include + +#include +#include +#include + +#include "event.h" +#include "todo.h" +#include "freebusy.h" +#include "icalformat.h" +#include "calendar.h" + +#include "scheduler.h" + +using namespace KCal; + +ScheduleMessage::ScheduleMessage(IncidenceBase *incidence,int method,ScheduleMessage::Status status) +{ + mIncidence = incidence; + mMethod = method; + mStatus = status; +} + +QString ScheduleMessage::statusName(ScheduleMessage::Status status) +{ + switch (status) { + case PublishNew: + return i18n("Publish"); + case Obsolete: + return i18n("Obsolete"); + case RequestNew: + return i18n("New Request"); + case RequestUpdate: + return i18n("Updated Request"); + default: + return i18n("Unknown Status: %1").arg(QString::number(status)); + } +} + +Scheduler::Scheduler(Calendar *calendar) +{ + mCalendar = calendar; + mFormat = new ICalFormat(); +} + +Scheduler::~Scheduler() +{ + delete mFormat; +} + +bool Scheduler::acceptTransaction(IncidenceBase *incidence,Method method,ScheduleMessage::Status status) +{ + kdDebug() << "Scheduler::acceptTransaction " << endl; + switch (method) { + case Publish: + return acceptPublish(incidence, status, method); + case Request: + return acceptRequest(incidence, status); + case Add: + return acceptAdd(incidence, status); + case Cancel: + return acceptCancel(incidence, status); + case Declinecounter: + return acceptDeclineCounter(incidence, status); + case Reply: + return acceptReply(incidence, status, method); + case Refresh: + return acceptRefresh(incidence, status); + case Counter: + return acceptCounter(incidence, status); + default: + deleteTransaction(incidence); + return false; + } + deleteTransaction(incidence); + return false; +} + +QString Scheduler::methodName(Method method) +{ + switch (method) { + case Publish: + return QString::fromLatin1("Publish"); + case Request: + return QString::fromLatin1("Request"); + case Refresh: + return QString::fromLatin1("Refresh"); + case Cancel: + return QString::fromLatin1("Cancel"); + case Add: + return QString::fromLatin1("Add"); + case Reply: + return QString::fromLatin1("Reply"); + case Counter: + return QString::fromLatin1("Counter"); + case Declinecounter: + return QString::fromLatin1("Decline Counter"); + default: + return QString::fromLatin1("Unknown"); + } +} + +QString Scheduler::translatedMethodName(Method method) +{ + switch (method) { + case Publish: + return i18n("Publish"); + case Request: + return i18n("Request"); + case Refresh: + return i18n("Refresh"); + case Cancel: + return i18n("Cancel"); + case Add: + return i18n("Add"); + case Reply: + return i18n("Reply"); + case Counter: + return i18n("counter proposal","Counter"); + case Declinecounter: + return i18n("decline counter proposal","Decline Counter"); + default: + return i18n("Unknown"); + } +} + +bool Scheduler::deleteTransaction(IncidenceBase *) +{ + return true; +} + +bool Scheduler::acceptPublish(IncidenceBase *incidence,ScheduleMessage::Status status, Method method) +{ + if(incidence->type()=="FreeBusy") { + return acceptFreeBusy(incidence, method); + } + switch (status) { + case ScheduleMessage::Unknown: + case ScheduleMessage::PublishNew: + if (!mCalendar->event(incidence->uid())) { + Incidence *inc = static_cast(incidence); + mCalendar->addIncidence(inc); + deleteTransaction(incidence); + } + return true; + case ScheduleMessage::Obsolete: + return true; + default: + deleteTransaction(incidence); + return false; + } + deleteTransaction(incidence); + return false; +} + +bool Scheduler::acceptRequest(IncidenceBase *incidence,ScheduleMessage::Status status) +{ + Incidence *inc = static_cast(incidence); + if (inc->type()=="FreeBusy") { + // reply to this request is handled in korganizer's incomingdialog + return true; + } else { + Event *even = mCalendar->event(incidence->uid()); + if (even) { + if ( even->revision()<=inc->revision() ) { + if ( even->revision()==inc->revision() && + even->lastModified()>inc->lastModified()) { + deleteTransaction(incidence); + return false; + } + mCalendar->deleteEvent(even); + } else { + deleteTransaction(incidence); + return false; + } + } else { + Todo *todo = mCalendar->todo(incidence->uid()); + if (todo) { + if ( todo->revision()<=inc->revision() ) { + if ( todo->revision()==inc->revision() && + todo->lastModified()>inc->lastModified()) { + deleteTransaction(incidence); + return false; + } + mCalendar->deleteTodo(todo); + } else { + deleteTransaction(incidence); + return false; + } + } + } + } + mCalendar->addIncidence(inc); + deleteTransaction(incidence); + return true; +} + +bool Scheduler::acceptAdd(IncidenceBase *incidence,ScheduleMessage::Status status) +{ + deleteTransaction(incidence); + return false; +} + +bool Scheduler::acceptCancel(IncidenceBase *incidence,ScheduleMessage::Status status) +{ + bool ret = false; + Event *even = mCalendar->event(incidence->uid()); + if (even) { + mCalendar->deleteEvent(even); + ret = true; + } else { + Todo *todo = mCalendar->todo(incidence->uid()); + if (todo) { + mCalendar->deleteTodo(todo); + ret = true; + } + } + deleteTransaction(incidence); + return ret; +} + +bool Scheduler::acceptDeclineCounter(IncidenceBase *incidence,ScheduleMessage::Status status) +{ + deleteTransaction(incidence); + return false; +} + +//bool Scheduler::acceptFreeBusy(Incidence *incidence,ScheduleMessage::Status status) +//{ +// deleteTransaction(incidence); +// return false; +//} + +bool Scheduler::acceptReply(IncidenceBase *incidence,ScheduleMessage::Status status, Method method) +{ + if(incidence->type()=="FreeBusy") { + return acceptFreeBusy(incidence, method); + } + bool ret = false; + Event *ev = mCalendar->event(incidence->uid()); + Todo *to = mCalendar->todo(incidence->uid()); + if (ev || to) { + //get matching attendee in calendar + kdDebug(5800) << "Scheduler::acceptTransaction match found!" << endl; + QPtrList attendeesIn = incidence->attendees(); + QPtrList attendeesEv; + if (ev) attendeesEv = ev->attendees(); + if (to) attendeesEv = to->attendees(); + Attendee *attIn; + Attendee *attEv; + for ( attIn = attendeesIn.first(); attIn; attIn = attendeesIn.next() ) { + for ( attEv = attendeesEv.first(); attEv; attEv = attendeesEv.next() ) { + if (attIn->email()==attEv->email()) { + //update attendee-info + kdDebug(5800) << "Scheduler::acceptTransaction update attendee" << endl; + attEv->setStatus(attIn->status()); + attEv->setRSVP(false); + // better to not update the sequence number with replys + //if (ev) ev->setRevision(ev->revision()+1); + //if (to) to->setRevision(to->revision()+1); + ret = true; + } + } + } + } + if (ret) deleteTransaction(incidence); + return ret; +} + +bool Scheduler::acceptRefresh(IncidenceBase *incidence,ScheduleMessage::Status status) +{ + // handled in korganizer's IncomingDialog + deleteTransaction(incidence); + return false; +} + +bool Scheduler::acceptCounter(IncidenceBase *incidence,ScheduleMessage::Status status) +{ + deleteTransaction(incidence); + return false; +} + +bool Scheduler::acceptFreeBusy(IncidenceBase *incidence, Method method) +{ + FreeBusy *freebusy = static_cast(incidence); + + QString freeBusyDirName = locateLocal("appdata","freebusy"); + kdDebug() << "acceptFreeBusy:: freeBusyDirName: " << freeBusyDirName << endl; + + QString from; + if(method == Scheduler::Publish) { + from = freebusy->organizer(); + } + if((method == Scheduler::Reply) && (freebusy->attendeeCount() == 1)) { + Attendee *attendee = freebusy->attendees().first(); + from = attendee->email(); + } + + QDir freeBusyDir(freeBusyDirName); + if (!freeBusyDir.exists()) { + kdDebug() << "Directory " << freeBusyDirName << " does not exist!" << endl; + kdDebug() << "Creating directory: " << freeBusyDirName << endl; + + if(!freeBusyDir.mkdir(freeBusyDirName, TRUE)) { + kdDebug() << "Could not create directory: " << freeBusyDirName << endl; + return false; + } + } + + QString filename(freeBusyDirName); + filename += "/"; + filename += from; + filename += ".ifb"; + QFile f(filename); + + kdDebug() << "acceptFreeBusy: filename" << filename << endl; + + freebusy->clearAttendees(); + freebusy->setOrganizer(from); + + QString messageText = mFormat->createScheduleMessage(freebusy, Publish); + + if (!f.open(IO_ReadWrite)) { + kdDebug() << "acceptFreeBusy: Can't open:" << filename << " for writing" << endl; + return false; + } + QTextStream t(&f); + t << messageText; + f.close(); + + deleteTransaction(incidence); + return true; +} diff --git a/libkcal/scheduler.h b/libkcal/scheduler.h new file mode 100644 index 0000000..a9f43b9 --- a/dev/null +++ b/libkcal/scheduler.h @@ -0,0 +1,133 @@ +/* + This file is part of libkcal. + Copyright (c) 2001 Cornelius Schumacher + + 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 SCHEDULER_H +#define SCHEDULER_H + +// iTIP transactions base class + +#include +#include + +namespace KCal { + +class IncidenceBase; +class Event; +class Calendar; +class ICalFormat; + +/** + This class provides an encapsulation of a scheduling message. It associates an + incidence with a method and status information. This class is used by the + Scheduler class. + + @short A Scheduling message +*/ +class ScheduleMessage { + public: + /** Message status. */ + enum Status { PublishNew, Obsolete, RequestNew, RequestUpdate, Unknown }; + + /** + Create a scheduling message with method as defined in Scheduler::Method + and a status. + */ + ScheduleMessage(IncidenceBase *,int method,Status status); + ~ScheduleMessage() {}; + + /** Return event associated with this message. */ + IncidenceBase *event() { return mIncidence; } + /** Return iTIP method associated with this message. */ + int method() { return mMethod; } + /** Return status of this message. */ + Status status() { return mStatus; } + /** Return error message if there is any. */ + QString error() { return mError; } + + /** Return a human-readable name for an ical message status. */ + static QString statusName(Status status); + + private: + IncidenceBase *mIncidence; + int mMethod; + Status mStatus; + QString mError; +}; + +/** + This class provides an encapsulation of iTIP transactions. It is an abstract + base class for inheritance by implementations of the iTIP scheme like iMIP or + iRIP. +*/ +class Scheduler { + public: + /** iTIP methods. */ + enum Method { Publish,Request,Refresh,Cancel,Add,Reply,Counter, + Declinecounter,NoMethod }; + + /** Create scheduler for calendar specified as argument. */ + Scheduler(Calendar *calendar); + virtual ~Scheduler(); + + /** iTIP publish action */ + virtual bool publish (IncidenceBase *incidence,const QString &recipients) = 0; + /** Perform iTIP transaction on incidence. The method is specified as the + method argumanet and can be any valid iTIP method. */ + virtual bool performTransaction(IncidenceBase *incidence,Method method) = 0; + /** Perform iTIP transaction on incidence to specified recipient(s). The + method is specified as the method argumanet and can be any valid iTIP + method. */ + virtual bool performTransaction(IncidenceBase *incidence,Method method,const QString &recipients) = 0; + /** Retrieve incoming iTIP transactions */ + virtual QPtrList retrieveTransactions() = 0; + + /** + Accept transaction. The incidence argument specifies the iCal compoennt + on which the transaction acts. The status is the result of processing a + iTIP message with the current calendar and specifies the action to be + taken for this incidence. + */ + bool acceptTransaction(IncidenceBase *,Method method,ScheduleMessage::Status status); + + /** Return a machine-readable name for a iTIP method. */ + static QString methodName(Method); + /** Return a translated and human-readable name for a iTIP method. */ + static QString translatedMethodName(Method); + + virtual bool deleteTransaction(IncidenceBase *incidence); + + protected: + + bool acceptPublish(IncidenceBase *,ScheduleMessage::Status status, Method method); + bool acceptRequest(IncidenceBase *,ScheduleMessage::Status status); + bool acceptAdd(IncidenceBase *,ScheduleMessage::Status status); + bool acceptCancel(IncidenceBase *,ScheduleMessage::Status status); + bool acceptDeclineCounter(IncidenceBase *,ScheduleMessage::Status status); + bool acceptReply(IncidenceBase *,ScheduleMessage::Status status, Method method); + bool acceptRefresh(IncidenceBase *,ScheduleMessage::Status status); + bool acceptCounter(IncidenceBase *,ScheduleMessage::Status status); + bool acceptFreeBusy(IncidenceBase *,Method method); + + Calendar *mCalendar; + ICalFormat *mFormat; +}; + +} + +#endif // SCHEDULER_H diff --git a/libkcal/sharpformat.cpp b/libkcal/sharpformat.cpp new file mode 100644 index 0000000..f83f72e --- a/dev/null +++ b/libkcal/sharpformat.cpp @@ -0,0 +1,1007 @@ +/* + This file is part of libkcal. + + Copyright (c) 2003 Cornelius Schumacher + + 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include "calendar.h" +#include "alarm.h" +#include "recurrence.h" +#include "calendarlocal.h" + +#include "sharpformat.h" + +using namespace KCal; + +//CARDID,CATEGORY,DSRP,PLCE,MEM1,TIM1,TIM2,ADAY,ARON,ARMN,ARSD,RTYP,RFRQ,RPOS,RDYS,REND,REDT,ALSD,ALED,MDAY +// 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 + +//ARSD silentalarm = 0 +// 11 RTYP 225 no /0 dialy/ 1 weekly/ 3 month by date/ 2 month by day(pos)/ yearly +// 12 RFRQ +// 13 RPOS pos = 4. monday in month +// 14 RDYS days: 1 mon/ 2 tue .. 64 sun +// 15 REND 0 = no end/ 1 = end +// 16 REDT rec end dt +//ALSD +//ALED +//MDAY + +class SharpParser : public QObject +{ + public: + SharpParser( Calendar *calendar ) : mCalendar( calendar ) { + oldCategories = 0; + } + + bool startElement( Calendar *existingCalendar, const QStringList & attList, QString qName ) + { + int i = 1; + bool skip = true; + int max = attList.count() -2; + while ( i < max ) { + if ( !attList[i].isEmpty() ) { + skip = false; + break; + } + ++i ; + } + if ( skip ) + return false; + ulong cSum = SharpFormat::getCsum(attList ); + + if ( qName == "Event" ) { + Event *event; + event = existingCalendar->event( attList[0].toInt() ); + if ( event ) + event = (Event*)event->clone(); + else + event = new Event; + event->setZaurusId( attList[0].toInt() ); + event->setZaurusUid( cSum ); + event->setZaurusStat( -2 ); + + event->setSummary( attList[2] ); + event->setLocation( attList[3] ); + event->setDescription( attList[4] ); + if ( attList[7] == "1" ) { + event->setDtStart( QDateTime(fromString( attList[17]+"000000", false ).date(),QTime(0,0,0 ) )); + event->setDtEnd( QDateTime(fromString( attList[18]+"000000", false ).date(),QTime(0,0,0 ))); + event->setFloats( true ); + } else { + event->setFloats( false ); + event->setDtStart( fromString( attList[5] ) ); + event->setDtEnd( fromString( attList[6] )); + } + + QString rtype = attList[11]; + if ( rtype != "255" ) { + // qDebug("recurs "); + QDate startDate = event->dtStart().date(); + + QString freqStr = attList[12]; + int freq = freqStr.toInt(); + + QString hasEndDateStr = attList[15] ; + bool hasEndDate = hasEndDateStr == "1"; + + QString endDateStr = attList[16]; + QDate endDate = fromString( endDateStr ).date(); + + QString weekDaysStr = attList[14]; + uint weekDaysNum = weekDaysStr.toInt(); + + QBitArray weekDays( 7 ); + int i; + int bb = 1; + for( i = 1; i <= 7; ++i ) { + weekDays.setBit( i - 1, ( bb & weekDaysNum )); + bb = 2 << (i-1); + //qDebug(" %d bit %d ",i-1,weekDays.at(i-1) ); + } + // qDebug("next "); + QString posStr = attList[13]; + int pos = posStr.toInt(); + Recurrence *r = event->recurrence(); + + if ( rtype == "0" ) { + if ( hasEndDate ) r->setDaily( freq, endDate ); + else r->setDaily( freq, -1 ); + } else if ( rtype == "1" ) { + if ( hasEndDate ) r->setWeekly( freq, weekDays, endDate ); + else r->setWeekly( freq, weekDays, -1 ); + } else if ( rtype == "3" ) { + if ( hasEndDate ) + r->setMonthly( Recurrence::rMonthlyDay, freq, endDate ); + else + r->setMonthly( Recurrence::rMonthlyDay, freq, -1 ); + r->addMonthlyDay( startDate.day() ); + } else if ( rtype == "2" ) { + if ( hasEndDate ) + r->setMonthly( Recurrence::rMonthlyPos, freq, endDate ); + else + r->setMonthly( Recurrence::rMonthlyPos, freq, -1 ); + QBitArray days( 7 ); + days.fill( false ); + days.setBit( startDate.dayOfWeek() - 1 ); + r->addMonthlyPos( pos, days ); + } else if ( rtype == "4" ) { + if ( hasEndDate ) + r->setYearly( Recurrence::rYearlyMonth, freq, endDate ); + else + r->setYearly( Recurrence::rYearlyMonth, freq, -1 ); + r->addYearlyNum( startDate.month() ); + } + } + + QString categoryList = attList[1] ; + event->setCategories( lookupCategories( categoryList ) ); + + // strange 0 semms to mean: alarm enabled + if ( attList[8] == "0" ) { + Alarm *alarm; + if ( event->alarms().count() > 0 ) + alarm = event->alarms().first(); + else { + alarm = new Alarm( event ); + event->addAlarm( alarm ); + } + alarm->setType( Alarm::Audio ); + alarm->setEnabled( true ); + int alarmOffset = attList[9].toInt(); + alarm->setStartOffset( alarmOffset * -60 ); + } + + mCalendar->addEvent( event); + } else if ( qName == "Todo" ) { + Todo *todo; + + todo = existingCalendar->todo( attList[0].toInt() ); + if (todo ) + todo = (Todo*)todo->clone(); + else + todo = new Todo; + +//CARDID,CATEGORY,ETDY,LTDY,FNDY,MARK,PRTY,TITL,MEM1 +// 0 1 2 3 4 5 6 7 8 +//1,,,,,1,4,Loch zumachen,"" +//3,Privat,20040317T000000,20040318T000000,20040319T000000,0,5,Call bbb,"notes123 bbb gggg ""bb "" " +//2,"Familie,Freunde,Holiday",20040318T000000,20040324T000000,20040317T000000,1,2,tod2,notes + + todo->setZaurusId( attList[0].toInt() ); + todo->setZaurusUid( cSum ); + todo->setZaurusStat( -2 ); + + todo->setSummary( attList[7] ); + todo->setDescription( attList[8]); + + int priority = attList[6].toInt(); + if ( priority == 0 ) priority = 3; + todo->setPriority( priority ); + + QString categoryList = attList[1]; + todo->setCategories( lookupCategories( categoryList ) ); + + + + QString hasDateStr = attList[3]; // due + if ( !hasDateStr.isEmpty() ) { + if ( hasDateStr.right(6) == "000000" ) { + todo->setDtDue( QDateTime(fromString( hasDateStr, false ).date(), QTime(0,0,0 )) ); + todo->setFloats( true ); + } + else { + todo->setDtDue( fromString( hasDateStr ) ); + todo->setFloats( false ); + } + + todo->setHasDueDate( true ); + } + hasDateStr = attList[2];//start + if ( !hasDateStr.isEmpty() ) { + + todo->setDtStart( fromString( hasDateStr ) ); + todo->setHasStartDate( true); + } else + todo->setHasStartDate( false ); + hasDateStr = attList[4];//completed + if ( !hasDateStr.isEmpty() ) { + todo->setCompleted(fromString( hasDateStr ) ); + } + QString completedStr = attList[5]; + if ( completedStr == "0" ) + todo->setCompleted( true ); + else + todo->setCompleted( false ); + mCalendar->addTodo( todo ); + + } else if ( qName == "Category" ) { + /* + QString id = attributes.value( "id" ); + QString name = attributes.value( "name" ); + setCategory( id, name ); + */ + } + //qDebug("end "); + return true; + } + + + void setCategoriesList ( QStringList * c ) + { + oldCategories = c; + } + + QDateTime fromString ( QString s, bool useTz = true ) { + QDateTime dt; + int y,m,t,h,min,sec; + y = s.mid(0,4).toInt(); + m = s.mid(4,2).toInt(); + t = s.mid(6,2).toInt(); + h = s.mid(9,2).toInt(); + min = s.mid(11,2).toInt(); + sec = s.mid(13,2).toInt(); + dt = QDateTime(QDate(y,m,t), QTime(h,min,sec)); + int offset = KGlobal::locale()->localTimeOffset( dt ); + if ( useTz ) + dt = dt.addSecs ( offset*60); + return dt; + + } + protected: + QDateTime toDateTime( const QString &value ) + { + QDateTime dt; + dt.setTime_t( value.toUInt() ); + + return dt; + } + + QStringList lookupCategories( const QString &categoryList ) + { + QStringList categoryIds = QStringList::split( ";", categoryList ); + QStringList categories; + QStringList::ConstIterator it; + for( it = categoryIds.begin(); it != categoryIds.end(); ++it ) { + QString cate = category( *it ); + if ( oldCategories ) { + if ( ! oldCategories->contains( cate ) ) + oldCategories->append( cate ); + } + categories.append(cate ); + } + return categories; + } + + private: + Calendar *mCalendar; + QStringList * oldCategories; + static QString category( const QString &id ) + { + QMap::ConstIterator it = mCategoriesMap.find( id ); + if ( it == mCategoriesMap.end() ) return id; + else return *it; + } + + static void setCategory( const QString &id, const QString &name ) + { + mCategoriesMap.insert( id, name ); + } + + static QMap mCategoriesMap; +}; + +QMap SharpParser::mCategoriesMap; + +SharpFormat::SharpFormat() +{ + mCategories = 0; +} + +SharpFormat::~SharpFormat() +{ +} +ulong SharpFormat::getCsum( const QStringList & attList) +{ + int max = attList.count() -1; + ulong cSum = 0; + int j,k,i; + int add; + for ( i = 1; i < max ; ++i ) { + QString s = attList[i]; + if ( ! s.isEmpty() ){ + j = s.length(); + for ( k = 0; k < j; ++k ) { + int mul = k +1; + add = s[k].unicode (); + if ( k < 16 ) + mul = mul * mul; + add = add * mul *i*i*i; + cSum += add; + } + } + } + return cSum; + +} +#include +#define DEBUGMODE false +bool SharpFormat::load( Calendar *calendar, Calendar *existngCal ) +{ + + + bool debug = DEBUGMODE; + //debug = true; + QString text; + QString codec = "utf8"; + QLabel status ( i18n("Reading events ..."), 0 ); + + int w = status.sizeHint().width()+20 ; + if ( w < 200 ) w = 200; + int h = status.sizeHint().height()+20 ; + int dw = QApplication::desktop()->width(); + int dh = QApplication::desktop()->height(); + status.setCaption(i18n("Reading DTM Data") ); + status.setGeometry( (dw-w)/2, (dh - h )/2 ,w,h ); + status.show(); + status.raise(); + qApp->processEvents(); + QString fileName; + if ( ! debug ) { + fileName = "/tmp/kopitempout"; + QString command ="db2file datebook -r -c "+ codec + " > " + fileName; + system ( command.latin1() ); + } else { + fileName = "/tmp/events.txt"; + + } + QFile file( fileName ); + if (!file.open( IO_ReadOnly ) ) { + return false; + + } + QTextStream ts( &file ); + ts.setCodec( QTextCodec::codecForName("utf8") ); + text = ts.read(); + file.close(); + status.setText( i18n("Processing events ...") ); + status.raise(); + qApp->processEvents(); + fromString2Cal( calendar, existngCal, text, "Event" ); + status.setText( i18n("Reading todos ...") ); + qApp->processEvents(); + if ( ! debug ) { + fileName = "/tmp/kopitempout"; + QString command = "db2file todo -r -c " + codec+ " > " + fileName; + system ( command.latin1() ); + } else { + fileName = "/tmp/todo.txt"; + } + file.setName( fileName ); + if (!file.open( IO_ReadOnly ) ) { + return false; + + } + ts.setDevice( &file ); + text = ts.read(); + file.close(); + + status.setText( i18n("Processing todos ...") ); + status.raise(); + qApp->processEvents(); + fromString2Cal( calendar, existngCal, text, "Todo" ); + return true; +} +int SharpFormat::getNumFromRecord( QString answer, Incidence* inc ) +{ + int retval = -1; + QStringList templist; + QString tempString; + int start = 0; + int len = answer.length(); + int end = answer.find ("\n",start)+1; + bool ok = true; + start = end; + int ccc = 0; + while ( start > 0 ) { + templist.clear(); + ok = true; + int loopCount = 0; + while ( ok ) { + ++loopCount; + if ( loopCount > 25 ) { + qDebug("KO: Error in while loop"); + ok = false; + start = 0; + break; + } + if ( ok ) + tempString = getPart( answer, ok, start ); + if ( start >= len || start == 0 ) { + start = 0; + ok = false; + } + if ( tempString.right(1) =="\n" ) + tempString = tempString.left( tempString.length()-1); + + templist.append( tempString ); + } + ++ccc; + if ( ccc == 2 && loopCount < 25 ) { + start = 0; + bool ok; + int newnum = templist[0].toInt( &ok ); + if ( ok && newnum > 0) { + retval = newnum; + inc->setZaurusId( newnum ); + inc->setZaurusUid( getCsum( templist ) ); + inc->setZaurusStat( -4 ); + } + } + } + //qDebug("getNumFromRecord returning : %d ", retval); + return retval; +} +bool SharpFormat::save( Calendar *calendar) +{ + + QLabel status ( i18n("Processing/adding events ..."), 0 ); + int w = status.sizeHint().width()+20 ; + if ( w < 200 ) w = 200; + int h = status.sizeHint().height()+20 ; + int dw = QApplication::desktop()->width(); + int dh = QApplication::desktop()->height(); + status.setCaption(i18n("Writing DTM Data") ); + status.setGeometry( (dw-w)/2, (dh - h )/2 ,w,h ); + status.show(); + status.raise(); + qApp->processEvents(); + bool debug = DEBUGMODE; + QString codec = "utf8"; + QString answer; + QString ePrefix = "CARDID,CATEGORY,DSRP,PLCE,MEM1,TIM1,TIM2,ADAY,ARON,ARMN,ARSD,RTYP,RFRQ,RPOS,RDYS,REND,REDT,ALSD,ALED,MDAY\n"; + QString tPrefix = "CARDID,CATEGORY,ETDY,LTDY,FNDY,MARK,PRTY,TITL,MEM1\n"; + QString command; + QPtrList er = calendar->rawEvents(); + Event* ev = er.first(); + QString fileName = "/tmp/kopitempout"; + int i = 0; + QString changeString = ePrefix; + QString deleteString = ePrefix; + bool deleteEnt = false; + bool changeEnt = false; + QString message = i18n("Processing event # "); + int procCount = 0; + while ( ev ) { + //qDebug("i %d ", ++i); + if ( ev->zaurusStat() != -2 ) { + status.setText ( message + QString::number ( ++procCount ) ); + qApp->processEvents(); + QString eString = getEventString( ev ); + if ( ev->zaurusStat() == -3 ) { // delete + // deleting empty strings does not work. + // we write first and x and then delete the record with the x + eString = eString.replace( QRegExp(",\"\""),",\"x\"" ); + changeString += eString + "\n"; + deleteString += eString + "\n"; + deleteEnt = true; + changeEnt = true; + } + else if ( ev->zaurusId() == -1 ) { // add new + command = "(echo \"" + ePrefix + eString + "\" ) | db2file datebook -w -g -c " + codec+ " > "+ fileName; + system ( command.utf8() ); + QFile file( fileName ); + if (!file.open( IO_ReadOnly ) ) { + return false; + + } + QTextStream ts( &file ); + ts.setCodec( QTextCodec::codecForName("utf8") ); + answer = ts.read(); + file.close(); + //qDebug("answer \n%s ", answer.latin1()); + getNumFromRecord( answer, ev ) ; + + } + else { // change existing + //qDebug("canging %d %d",ev->zaurusStat() ,ev->zaurusId() ); + //command = "(echo \"" + ePrefix + eString + "\" ) | db2file datebook -w -g -c " + codec+ " > "+ fileName; + changeString += eString + "\n"; + changeEnt = true; + + } + } + ev = er.next(); + } + status.setText ( i18n("Changing events ...") ); + qApp->processEvents(); + //qDebug("changing... "); + if ( changeEnt ) { + QFile file( fileName ); + if (!file.open( IO_WriteOnly ) ) { + return false; + + } + QTextStream ts( &file ); + ts.setCodec( QTextCodec::codecForName("utf8") ); + ts << changeString ; + file.close(); + command = "db2file datebook -w -g -c " + codec+ " < "+ fileName; + system ( command.latin1() ); + //qDebug("command %s file :\n%s ", command.latin1(), changeString.latin1()); + + } + status.setText ( i18n("Deleting events ...") ); + qApp->processEvents(); + //qDebug("deleting... "); + if ( deleteEnt ) { + QFile file( fileName ); + if (!file.open( IO_WriteOnly ) ) { + return false; + + } + QTextStream ts( &file ); + ts.setCodec( QTextCodec::codecForName("utf8") ); + ts << deleteString; + file.close(); + command = "db2file datebook -d -c " + codec+ " < "+ fileName; + system ( command.latin1() ); + // qDebug("command %s file :\n%s ", command.latin1(), deleteString.latin1()); + } + + + changeString = tPrefix; + deleteString = tPrefix; + status.setText ( i18n("Processing todos ...") ); + qApp->processEvents(); + QPtrList tl = calendar->rawTodos(); + Todo* to = tl.first(); + i = 0; + message = i18n("Processing todo # "); + procCount = 0; + while ( to ) { + if ( to->zaurusStat() != -2 ) { + status.setText ( message + QString::number ( ++procCount ) ); + qApp->processEvents(); + QString eString = getTodoString( to ); + if ( to->zaurusStat() == -3 ) { // delete + // deleting empty strings does not work. + // we write first and x and then delete the record with the x + eString = eString.replace( QRegExp(",\"\""),",\"x\"" ); + changeString += eString + "\n"; + deleteString += eString + "\n"; + deleteEnt = true; + changeEnt = true; + } + else if ( to->zaurusId() == -1 ) { // add new + command = "(echo \"" + tPrefix + eString + "\" ) | db2file todo -w -g -c " + codec+ " > "+ fileName; + system ( command.utf8() ); + QFile file( fileName ); + if (!file.open( IO_ReadOnly ) ) { + return false; + + } + QTextStream ts( &file ); + ts.setCodec( QTextCodec::codecForName("utf8") ); + answer = ts.read(); + file.close(); + //qDebug("answer \n%s ", answer.latin1()); + getNumFromRecord( answer, to ) ; + + } + else { // change existing + //qDebug("canging %d %d",to->zaurusStat() ,to->zaurusId() ); + //command = "(echo \"" + ePrefix + eString + "\" ) | db2file datebook -w -g -c " + codec+ " > "+ fileName; + changeString += eString + "\n"; + changeEnt = true; + + } + } + + to = tl.next(); + } + status.setText ( i18n("Changing todos ...") ); + qApp->processEvents(); + //qDebug("changing... "); + if ( changeEnt ) { + QFile file( fileName ); + if (!file.open( IO_WriteOnly ) ) { + return false; + + } + QTextStream ts( &file ); + ts.setCodec( QTextCodec::codecForName("utf8") ); + ts << changeString ; + file.close(); + command = "db2file todo -w -g -c " + codec+ " < "+ fileName; + system ( command.latin1() ); + //qDebug("command %s file :\n%s ", command.latin1(), changeString.latin1()); + + } + status.setText ( i18n("Deleting todos ...") ); + qApp->processEvents(); + //qDebug("deleting... "); + if ( deleteEnt ) { + QFile file( fileName ); + if (!file.open( IO_WriteOnly ) ) { + return false; + + } + QTextStream ts( &file ); + ts.setCodec( QTextCodec::codecForName("utf8") ); + ts << deleteString; + file.close(); + command = "db2file todo -d -c " + codec+ " < "+ fileName; + system ( command.latin1() ); + // qDebug("command %s file :\n%s ", command.latin1(), deleteString.latin1()); + } + + return true; +} +QString SharpFormat::dtToString( const QDateTime& dti, bool useTZ ) +{ + QString datestr; + QString timestr; + int offset = KGlobal::locale()->localTimeOffset( dti ); + QDateTime dt; + if (useTZ) + dt = dti.addSecs ( -(offset*60)); + else + dt = dti; + if(dt.date().isValid()){ + const QDate& date = dt.date(); + datestr.sprintf("%04d%02d%02d", + date.year(), date.month(), date.day()); + } + if(dt.time().isValid()){ + const QTime& time = dt.time(); + timestr.sprintf("T%02d%02d%02d", + time.hour(), time.minute(), time.second()); + } + return datestr + timestr; +} +QString SharpFormat::getEventString( Event* event ) +{ + QStringList list; + list.append( QString::number(event->zaurusId() ) ); + list.append( event->categories().join(",") ); + if ( !event->summary().isEmpty() ) + list.append( event->summary() ); + else + list.append("" ); + if ( !event->location().isEmpty() ) + list.append( event->location() ); + else + list.append("" ); + if ( !event->description().isEmpty() ) + list.append( event->description() ); + else + list.append( "" ); + if ( event->doesFloat () ) { + list.append( dtToString( QDateTime(event->dtStart().date(), QTime(0,0,0)), false )); + list.append( dtToString( QDateTime(event->dtEnd().date(),QTime(23,59,59)), false )); //6 + list.append( "1" ); + + } + else { + list.append( dtToString( event->dtStart()) ); + list.append( dtToString( event->dtEnd()) ); //6 + list.append( "0" ); + } + bool noAlarm = true; + if ( event->alarms().count() > 0 ) { + Alarm * al = event->alarms().first(); + if ( al->enabled() ) { + noAlarm = false; + list.append( "0" ); // yes, 0 == alarm + list.append( QString::number( al->startOffset().asSeconds()/(-60) ) ); + if ( al->type() == Alarm::Audio ) + list.append( "1" ); // type audio + else + list.append( "0" ); // type silent + } + } + if ( noAlarm ) { + list.append( "1" ); // yes, 1 == no alarm + list.append( "0" ); // no alarm offset + list.append( "1" ); // type + } + // next is: 11 + // next is: 11-16 are recurrence + Recurrence* rec = event->recurrence(); + + bool writeEndDate = false; + switch ( rec->doesRecur() ) + { + case Recurrence::rDaily: // 0 + list.append( "0" ); + list.append( QString::number( rec->frequency() ));//12 + list.append( "0" ); + list.append( "0" ); + writeEndDate = true; + break; + case Recurrence::rWeekly:// 1 + list.append( "1" ); + list.append( QString::number( rec->frequency()) );//12 + list.append( "0" ); + { + int days = 0; + QBitArray weekDays = rec->days(); + int i; + for( i = 1; i <= 7; ++i ) { + if ( weekDays[i-1] ) { + days += 1 << (i-1); + } + } + list.append( QString::number( days ) ); + } + //pending weekdays + writeEndDate = true; + + break; + case Recurrence::rMonthlyPos:// 2 + list.append( "2" ); + list.append( QString::number( rec->frequency()) );//12 + + writeEndDate = true; + { + int count = 1; + QPtrList rmp; + rmp = rec->monthPositions(); + if ( rmp.first()->negative ) + count = 5 - rmp.first()->rPos - 1; + else + count = rmp.first()->rPos - 1; + list.append( QString::number( count ) ); + + } + + list.append( "0" ); + break; + case Recurrence::rMonthlyDay:// 3 + list.append( "3" ); + list.append( QString::number( rec->frequency()) );//12 + list.append( "0" ); + list.append( "0" ); + writeEndDate = true; + break; + case Recurrence::rYearlyMonth://4 + list.append( "4" ); + list.append( QString::number( rec->frequency()) );//12 + list.append( "0" ); + list.append( "0" ); + writeEndDate = true; + break; + + default: + list.append( "255" ); + list.append( QString() ); + list.append( "0" ); + list.append( QString() ); + list.append( "0" ); + list.append( "20991231T000000" ); + break; + } + if ( writeEndDate ) { + + if ( rec->endDate().isValid() ) { // 15 + 16 + list.append( "1" ); + list.append( dtToString( rec->endDate()) ); + } else { + list.append( "0" ); + list.append( "20991231T000000" ); + } + + } + if ( event->doesFloat () ) { + list.append( dtToString( event->dtStart(), false ).left( 8 )); + list.append( dtToString( event->dtEnd(), false ).left( 8 )); //6 + + } + else { + list.append( QString() ); + list.append( QString() ); + + } + if (event->dtStart().date() == event->dtEnd().date() ) + list.append( "0" ); + else + list.append( "1" ); + + + for(QStringList::Iterator it=list.begin(); + it!=list.end(); ++it){ + QString& s = (*it); + s.replace(QRegExp("\""), "\"\""); + if(s.contains(QRegExp("[,\"\r\n]")) || s.stripWhiteSpace() != s){ + s.prepend('\"'); + s.append('\"'); + } else if(s.isEmpty() && !s.isNull()){ + s = "\"\""; + } + } + return list.join(","); + + +} +QString SharpFormat::getTodoString( Todo* todo ) +{ + QStringList list; + list.append( QString::number( todo->zaurusId() ) ); + list.append( todo->categories().join(",") ); + + if ( todo->hasStartDate() ) { + list.append( dtToString( todo->dtStart()) ); + } else + list.append( QString() ); + + if ( todo->hasDueDate() ) { + QTime tim; + if ( todo->doesFloat()) { + list.append( dtToString( QDateTime(todo->dtDue().date(),QTime( 0,0,0 )), false)) ; + } else { + list.append( dtToString(todo->dtDue() ) ); + } + } else + list.append( QString() ); + + if ( todo->isCompleted() ) { + list.append( dtToString( todo->completed()) ); + list.append( "0" ); // yes 0 == completed + } else { + list.append( dtToString( todo->completed()) ); + list.append( "1" ); + } + list.append( QString::number( todo->priority() )); + if( ! todo->summary().isEmpty() ) + list.append( todo->summary() ); + else + list.append( "" ); + if (! todo->description().isEmpty() ) + list.append( todo->description() ); + else + list.append( "" ); + for(QStringList::Iterator it=list.begin(); + it!=list.end(); ++it){ + QString& s = (*it); + s.replace(QRegExp("\""), "\"\""); + if(s.contains(QRegExp("[,\"\r\n]")) || s.stripWhiteSpace() != s){ + s.prepend('\"'); + s.append('\"'); + } else if(s.isEmpty() && !s.isNull()){ + s = "\"\""; + } + } + return list.join(","); +} +QString SharpFormat::getPart( const QString & text, bool &ok, int &start ) +{ + //qDebug("start %d ", start); + + QString retval =""; + if ( text.at(start) == '"' ) { + if ( text.mid( start,2) == "\"\"" && !( text.mid( start+2,1) == "\"")) { + start = start +2; + if ( text.mid( start,1) == "," ) { + start += 1; + } + retval = ""; + if ( text.mid( start,1) == "\n" ) { + start += 1; + ok = false; + } + return retval; + } + int hk = start+1; + hk = text.find ('"',hk); + while ( text.at(hk+1) == '"' ) + hk = text.find ('"',hk+2); + retval = text.mid( start+1, hk-start-1); + start = hk+1; + retval.replace( QRegExp("\"\""), "\""); + if ( text.mid( start,1) == "," ) { + start += 1; + } + if ( text.mid( start,1) == "\n" ) { + start += 1; + ok = false; + } + //qDebug("retval***%s*** ",retval.latin1() ); + return retval; + + } else { + int nl = text.find ("\n",start); + int kom = text.find (',',start); + if ( kom < nl ) { + // qDebug("kom < nl %d ", kom); + retval = text.mid(start, kom-start); + start = kom+1; + return retval; + } else { + if ( nl == kom ) { + // qDebug(" nl == kom "); + start = 0; + ok = false; + return "0"; + } + // qDebug(" nl < kom ", nl); + retval = text.mid( start, nl-start); + ok = false; + start = nl+1; + return retval; + } + } +} +bool SharpFormat::fromString( Calendar *calendar, const QString & text) +{ + return false; +} +bool SharpFormat::fromString2Cal( Calendar *calendar,Calendar *existingCalendar, const QString & text, const QString & type) +{ + // qDebug("test %s ", text.latin1()); + QStringList templist; + QString tempString; + int start = 0; + int len = text.length(); + int end = text.find ("\n",start)+1; + bool ok = true; + start = end; + SharpParser handler( calendar ); + handler.setCategoriesList( mCategories ); + while ( start > 0 ) { + templist.clear(); + ok = true; + while ( ok ) { + tempString = getPart( text, ok, start ); + if ( start >= len || start == 0 ) { + start = 0; + ok = false; + } + if ( tempString.right(1) =="\n" ) + tempString = tempString.left( tempString.length()-1); + //if ( ok ) + templist.append( tempString ); + //qDebug("%d ---%s---", templist.count(),tempString.latin1() ); + } + handler.startElement( existingCalendar, templist, type ); + } + + return false; +} + +QString SharpFormat::toString( Calendar * ) +{ + return QString::null; +} diff --git a/libkcal/sharpformat.h b/libkcal/sharpformat.h new file mode 100644 index 0000000..0b13862 --- a/dev/null +++ b/libkcal/sharpformat.h @@ -0,0 +1,61 @@ +/* + This file is part of libkcal. + + Copyright (c) 2003 Cornelius Schumacher + + 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 SHARPFORMAT_H +#define SHARPAFORMAT_H + +#include + +#include "scheduler.h" + +#include "calformat.h" + +namespace KCal { + +/** + This class implements the calendar format used by Sharp. +*/ +class SharpFormat : public QObject { + public: + /** Create new iCalendar format. */ + SharpFormat(); + virtual ~SharpFormat(); + + bool load( Calendar * ,Calendar *); + bool save( Calendar * ); + void setCategoriesList ( QStringList * cat ){ mCategories = cat; } + bool fromString2Cal( Calendar *, Calendar *, const QString & , const QString & ); + bool fromString( Calendar *, const QString & ); + QString toString( Calendar * ); + static ulong getCsum( const QStringList & ); + + private: + QString getEventString( Event* ); + QString getTodoString( Todo* ); + QString dtToString( const QDateTime& dt, bool useTZ = true ); + + QStringList *mCategories; + int getNumFromRecord( QString answer,Incidence* inc ) ; + QString getPart( const QString & text, bool &ok, int &start ); +}; + +} + +#endif diff --git a/libkcal/todo.cpp b/libkcal/todo.cpp new file mode 100644 index 0000000..0c1e3e4 --- a/dev/null +++ b/libkcal/todo.cpp @@ -0,0 +1,316 @@ +/* + This file is part of libkcal. + Copyright (c) 2001 Cornelius Schumacher + + 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 +#include +#include + +#include "todo.h" + +using namespace KCal; + +Todo::Todo(): Incidence() +{ +// mStatus = TENTATIVE; + + mHasDueDate = false; + setHasStartDate( false ); + mCompleted = getEvenTime(QDateTime::currentDateTime()); + mHasCompletedDate = false; + mPercentComplete = 0; +} + +Todo::Todo(const Todo &t) : Incidence(t) +{ + mDtDue = t.mDtDue; + mHasDueDate = t.mHasDueDate; + mCompleted = t.mCompleted; + mHasCompletedDate = t.mHasCompletedDate; + mPercentComplete = t.mPercentComplete; +} + +Todo::~Todo() +{ + +} + +Incidence *Todo::clone() +{ + return new Todo(*this); +} + + +bool KCal::operator==( const Todo& t1, const Todo& t2 ) +{ + + bool ret = operator==( (const Incidence&)t1, (const Incidence&)t2 ); + if ( ! ret ) + return false; + if ( t1.hasDueDate() == t2.hasDueDate() ) { + if ( t1.hasDueDate() ) { + if ( t1.doesFloat() == t2.doesFloat() ) { + if ( t1.doesFloat() ) { + if ( t1.dtDue().date() != t2.dtDue().date() ) + return false; + } else + if ( t1.dtDue() != t2.dtDue() ) + return false; + } else + return false;// float != + } + + } else + return false; + if ( t1.percentComplete() != t2.percentComplete() ) + return false; + if ( t1.isCompleted() ) { + if ( t1.hasCompletedDate() == t2.hasCompletedDate() ) { + if ( t1.hasCompletedDate() ) { + if ( t1.completed() != t2.completed() ) + return false; + } + + } else + return false; + } + return true; + +} + +void Todo::setDtDue(const QDateTime &dtDue) +{ + //int diffsecs = mDtDue.secsTo(dtDue); + + /*if (mReadOnly) return; + const QPtrList& alarms = alarms(); + for (Alarm* alarm = alarms.first(); alarm; alarm = alarms.next()) { + if (alarm->enabled()) { + alarm->setTime(alarm->time().addSecs(diffsecs)); + } + }*/ + mDtDue = getEvenTime(dtDue); + + //kdDebug(5800) << "setDtDue says date is " << mDtDue.toString() << endl; + + /*const QPtrList& alarms = alarms(); + for (Alarm* alarm = alarms.first(); alarm; alarm = alarms.next()) + alarm->setAlarmStart(mDtDue);*/ + + updated(); +} + +QDateTime Todo::dtDue() const +{ + return mDtDue; +} + +QString Todo::dtDueTimeStr() const +{ + return KGlobal::locale()->formatTime(mDtDue.time()); +} + +QString Todo::dtDueDateStr(bool shortfmt) const +{ + return KGlobal::locale()->formatDate(mDtDue.date(),shortfmt); +} + +QString Todo::dtDueStr(bool shortfmt) const +{ + return KGlobal::locale()->formatDateTime(mDtDue, shortfmt); +} + +bool Todo::hasDueDate() const +{ + return mHasDueDate; +} + +void Todo::setHasDueDate(bool f) +{ + if (mReadOnly) return; + mHasDueDate = f; + updated(); +} + + +#if 0 +void Todo::setStatus(const QString &statStr) +{ + if (mReadOnly) return; + QString ss(statStr.upper()); + + if (ss == "X-ACTION") + mStatus = NEEDS_ACTION; + else if (ss == "NEEDS ACTION") + mStatus = NEEDS_ACTION; + else if (ss == "ACCEPTED") + mStatus = ACCEPTED; + else if (ss == "SENT") + mStatus = SENT; + else if (ss == "TENTATIVE") + mStatus = TENTATIVE; + else if (ss == "CONFIRMED") + mStatus = CONFIRMED; + else if (ss == "DECLINED") + mStatus = DECLINED; + else if (ss == "COMPLETED") + mStatus = COMPLETED; + else if (ss == "DELEGATED") + mStatus = DELEGATED; + + updated(); +} + +void Todo::setStatus(int status) +{ + if (mReadOnly) return; + mStatus = status; + updated(); +} + +int Todo::status() const +{ + return mStatus; +} + +QString Todo::statusStr() const +{ + switch(mStatus) { + case NEEDS_ACTION: + return QString("NEEDS ACTION"); + break; + case ACCEPTED: + return QString("ACCEPTED"); + break; + case SENT: + return QString("SENT"); + break; + case TENTATIVE: + return QString("TENTATIVE"); + break; + case CONFIRMED: + return QString("CONFIRMED"); + break; + case DECLINED: + return QString("DECLINED"); + break; + case COMPLETED: + return QString("COMPLETED"); + break; + case DELEGATED: + return QString("DELEGATED"); + break; + } + return QString(""); +} +#endif + +bool Todo::isCompleted() const +{ + if (mPercentComplete == 100) return true; + else return false; +} + +void Todo::setCompleted(bool completed) +{ + if (completed) mPercentComplete = 100; + else mPercentComplete = 0; + updated(); +} + +QDateTime Todo::completed() const +{ + return mCompleted; +} + +QString Todo::completedStr() const +{ + return KGlobal::locale()->formatDateTime(mCompleted); +} + +void Todo::setCompleted(const QDateTime &completed) +{ + mHasCompletedDate = true; + mPercentComplete = 100; + mCompleted = getEvenTime(completed); + updated(); +} + +bool Todo::hasCompletedDate() const +{ + return mHasCompletedDate; +} + +int Todo::percentComplete() const +{ + return mPercentComplete; +} + +void Todo::setPercentComplete(int v) +{ + mPercentComplete = v; + updated(); +} +QDateTime Todo::getNextAlarmDateTime( bool * ok, int * offset ) const +{ + if ( isCompleted() || ! hasDueDate() || cancelled() ) { + *ok = false; + return QDateTime (); + } + QDateTime incidenceStart; + incidenceStart = dtDue(); + bool enabled = false; + Alarm* alarm; + int off; + QDateTime alarmStart = QDateTime::currentDateTime().addDays( 3650 );; + // if ( QDateTime::currentDateTime() > incidenceStart ){ +// *ok = false; +// return incidenceStart; +// } + for (QPtrListIterator it(mAlarms); (alarm = it.current()) != 0; ++it) { + if (alarm->enabled()) { + if ( alarm->hasTime () ) { + if ( alarm->time() < alarmStart ) { + alarmStart = alarm->time(); + enabled = true; + off = alarmStart.secsTo( incidenceStart ); + } + + } else { + int secs = alarm->startOffset().asSeconds(); + if ( incidenceStart.addSecs( secs ) < alarmStart ) { + alarmStart = incidenceStart.addSecs( secs ); + enabled = true; + off = -secs; + } + } + } + } + if ( enabled ) { + if ( alarmStart > QDateTime::currentDateTime() ) { + *ok = true; + * offset = off; + return alarmStart; + } + } + *ok = false; + return QDateTime (); + +} + diff --git a/libkcal/todo.h b/libkcal/todo.h new file mode 100644 index 0000000..9aa92f8 --- a/dev/null +++ b/libkcal/todo.h @@ -0,0 +1,121 @@ +/* + This file is part of libkcal. + Copyright (c) 2001 Cornelius Schumacher + + 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 TODO_H +#define TODO_H +// +// Todo component, representing a VTODO object +// + +#include "incidence.h" + +namespace KCal { + +/** + This class provides a Todo in the sense of RFC2445. +*/ +class Todo : public Incidence +{ + public: + Todo(); + Todo(const Todo &); + ~Todo(); + typedef ListBase List; + QCString type() const { return "Todo"; } + + /** Return an exact copy of this todo. */ + Incidence *clone(); + QDateTime getNextAlarmDateTime( bool * ok, int * offset ) const; + + /** for setting the todo's due date/time with a QDateTime. */ + void setDtDue(const QDateTime &dtDue); + /** returns an event's Due date/time as a QDateTime. */ + QDateTime dtDue() const; + /** returns an event's due time as a string formatted according to the + users locale settings */ + QString dtDueTimeStr() const; + /** returns an event's due date as a string formatted according to the + users locale settings */ + QString dtDueDateStr(bool shortfmt=true) const; + /** returns an event's due date and time as a string formatted according + to the users locale settings */ + QString dtDueStr(bool shortfmt=true) const; + + /** returns TRUE or FALSE depending on whether the todo has a due date */ + bool hasDueDate() const; + /** sets the event's hasDueDate value. */ + void setHasDueDate(bool f); + + + /** sets the event's status to the string specified. The string + * must be a recognized value for the status field, i.e. a string + * equivalent of the possible status enumerations previously described. */ +// void setStatus(const QString &statStr); + /** sets the event's status to the value specified. See the enumeration + * above for possible values. */ +// void setStatus(int); + /** return the event's status. */ +// int status() const; + /** return the event's status in string format. */ +// QString statusStr() const; + + /** return, if this todo is completed */ + bool isCompleted() const; + /** set completed state of this todo */ + void setCompleted(bool); + + /** + Return how many percent of the task are completed. Returns a value + between 0 and 100. + */ + int percentComplete() const; + /** + Set how many percent of the task are completed. Valid values are in the + range from 0 to 100. + */ + void setPercentComplete(int); + + /** return date and time when todo was completed */ + QDateTime completed() const; + QString completedStr() const; + /** set date and time of completion */ + void setCompleted(const QDateTime &completed); + + /** Return true, if todo has a date associated with completion */ + bool hasCompletedDate() const; + + private: + bool accept(Visitor &v) { return v.visit(this); } + + QDateTime mDtDue; // due date of todo + + bool mHasDueDate; // if todo has associated due date + +// int mStatus; // confirmed/delegated/tentative/etc + + QDateTime mCompleted; + bool mHasCompletedDate; + + int mPercentComplete; +}; + + bool operator==( const Todo&, const Todo& ); +} + +#endif diff --git a/libkcal/vcaldrag.cpp b/libkcal/vcaldrag.cpp new file mode 100644 index 0000000..f01f332 --- a/dev/null +++ b/libkcal/vcaldrag.cpp @@ -0,0 +1,54 @@ +/* + This file is part of libkcal. + Copyright (c) 1998 Preston Brown + Copyright (c) 2001 Cornelius Schumacher + + 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 "vcaldrag.h" + +#include "vcalformat.h" + +using namespace KCal; + +VCalDrag::VCalDrag( Calendar *cal, QWidget *parent, const char *name ) + : QStoredDrag( "text/x-vCalendar", parent, name ) +{ + VCalFormat format; + setEncodedData( format.toString( cal ).utf8() ); +} + +bool VCalDrag::canDecode( QMimeSource *me ) +{ + return me->provides( "text/x-vCalendar" ); +} + +bool VCalDrag::decode( QMimeSource *de, Calendar *cal ) +{ + bool success = false; + + QByteArray payload = de->encodedData( "text/x-vCalendar" ); + if ( payload.size() ) { + QString txt = QString::fromUtf8( payload.data() ); + + VCalFormat format; + success = format.fromString( cal, txt ); + } + + return success; +} + diff --git a/libkcal/vcaldrag.h b/libkcal/vcaldrag.h new file mode 100644 index 0000000..3048124 --- a/dev/null +++ b/libkcal/vcaldrag.h @@ -0,0 +1,47 @@ +/* + This file is part of libkcal. + Copyright (c) 1998 Preston Brown + Copyright (c) 2001 Cornelius Schumacher + + 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 VCALDRAG_H +#define VCALDRAG_H + +#include + + +namespace KCal { + +class Calendar; + +/** vCalendar drag&drop class. */ +class VCalDrag : public QStoredDrag { + public: + /** Create a drag&drop object for vCalendar component \a vcal. */ + VCalDrag( Calendar *vcal, QWidget *parent = 0, const char *name = 0 ); + ~VCalDrag() {}; + + /** Return, if drag&drop object can be decode to vCalendar. */ + static bool canDecode( QMimeSource * ); + /** Decode drag&drop object to vCalendar component \a vcal. */ + static bool decode( QMimeSource *e, Calendar *cal ); +}; + +} + +#endif diff --git a/libkcal/vcalformat.cpp b/libkcal/vcalformat.cpp new file mode 100644 index 0000000..59030d5 --- a/dev/null +++ b/libkcal/vcalformat.cpp @@ -0,0 +1,1678 @@ +/* + This file is part of libkcal. + Copyright (c) 1998 Preston Brwon + Copyright (c) 2001 Cornelius Schumacher + + 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 +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include "vcc.h" +#include "vobject.h" + +#include "vcaldrag.h" +#include "calendar.h" + +#include "vcalformat.h" + +using namespace KCal; + +VCalFormat::VCalFormat() +{ +} + +VCalFormat::~VCalFormat() +{ +} + +bool VCalFormat::load(Calendar *calendar, const QString &fileName) +{ + mCalendar = calendar; + + clearException(); + + kdDebug(5800) << "VCalFormat::load() " << fileName << endl; + + VObject *vcal = 0; + + // this is not necessarily only 1 vcal. Could be many vcals, or include + // a vcard... + vcal = Parse_MIME_FromFileName(const_cast(QFile::encodeName(fileName).data())); + + if (!vcal) { + setException(new ErrorFormat(ErrorFormat::CalVersionUnknown)); + return FALSE; + } + + // any other top-level calendar stuff should be added/initialized here + + // put all vobjects into their proper places + populate(vcal); + + // clean up from vcal API stuff + cleanVObjects(vcal); + cleanStrTbl(); + + return true; +} + + +bool VCalFormat::save(Calendar *calendar, const QString &fileName) +{ + mCalendar = calendar; + + QString tmpStr; + VObject *vcal, *vo; + + kdDebug(5800) << "VCalFormat::save(): " << fileName << endl; + + vcal = newVObject(VCCalProp); + + // addPropValue(vcal,VCLocationProp, "0.0"); + addPropValue(vcal,VCProdIdProp, productId()); + tmpStr = mCalendar->getTimeZoneStr(); + //qDebug("mCalendar->getTimeZoneStr() %s",tmpStr.latin1() ); + addPropValue(vcal,VCTimeZoneProp, tmpStr.local8Bit()); + addPropValue(vcal,VCVersionProp, _VCAL_VERSION); + + // TODO STUFF + QPtrList todoList = mCalendar->rawTodos(); + QPtrListIterator qlt(todoList); + for (; qlt.current(); ++qlt) { + vo = eventToVTodo(qlt.current()); + addVObjectProp(vcal, vo); + } + + // EVENT STUFF + QPtrList events = mCalendar->rawEvents(); + Event *ev; + for(ev=events.first();ev;ev=events.next()) { + vo = eventToVEvent(ev); + addVObjectProp(vcal, vo); + } + + writeVObjectToFile(QFile::encodeName(fileName).data() ,vcal); + cleanVObjects(vcal); + cleanStrTbl(); + + if (QFile::exists(fileName)) { + kdDebug(5800) << "No error" << endl; + return true; + } else { + kdDebug(5800) << "Error" << endl; + return false; // error + } +} + +bool VCalFormat::fromString( Calendar *calendar, const QString &text ) +{ + // TODO: Factor out VCalFormat::fromString() + + QCString data = text.utf8(); + + if ( !data.size() ) return false; + + VObject *vcal = Parse_MIME( data.data(), data.size()); + if ( !vcal ) return false; + + VObjectIterator i; + VObject *curvo; + initPropIterator( &i, vcal ); + + // we only take the first object. TODO: parse all incidences. + do { + curvo = nextVObject( &i ); + } while ( strcmp( vObjectName( curvo ), VCEventProp ) && + strcmp( vObjectName( curvo ), VCTodoProp ) ); + + if ( strcmp( vObjectName( curvo ), VCEventProp ) == 0 ) { + Event *event = VEventToEvent( curvo ); + calendar->addEvent( event ); + } else { + kdDebug(5800) << "VCalFormat::fromString(): Unknown object type." << endl; + deleteVObject( vcal ); + return false; + } + + deleteVObject( vcal ); + + return true; +} + +QString VCalFormat::toString( Calendar *calendar ) +{ + // TODO: Factor out VCalFormat::asString() + + VObject *vcal = newVObject(VCCalProp); + + addPropValue( vcal, VCProdIdProp, CalFormat::productId() ); + QString tmpStr = mCalendar->getTimeZoneStr(); + addPropValue( vcal, VCTimeZoneProp, tmpStr.local8Bit() ); + addPropValue( vcal, VCVersionProp, _VCAL_VERSION ); + + // TODO: Use all data. + QPtrList events = calendar->events(); + Event *event = events.first(); + if ( !event ) return QString::null; + + VObject *vevent = eventToVEvent( event ); + + addVObjectProp( vcal, vevent ); + + char *buf = writeMemVObject( 0, 0, vcal ); + + QString result( buf ); + + cleanVObject( vcal ); + + return result; +} + +VObject *VCalFormat::eventToVTodo(const Todo *anEvent) +{ + VObject *vtodo; + QString tmpStr; + QStringList tmpStrList; + + vtodo = newVObject(VCTodoProp); + + // due date + if (anEvent->hasDueDate()) { + tmpStr = qDateTimeToISO(anEvent->dtDue(), + !anEvent->doesFloat()); + addPropValue(vtodo, VCDueProp, tmpStr.local8Bit()); + } + + // start date + if (anEvent->hasStartDate()) { + tmpStr = qDateTimeToISO(anEvent->dtStart(), + !anEvent->doesFloat()); + addPropValue(vtodo, VCDTstartProp, tmpStr.local8Bit()); + } + + // creation date + tmpStr = qDateTimeToISO(anEvent->created()); + addPropValue(vtodo, VCDCreatedProp, tmpStr.local8Bit()); + + // unique id + addPropValue(vtodo, VCUniqueStringProp, + anEvent->uid().local8Bit()); + + // revision + tmpStr.sprintf("%i", anEvent->revision()); + addPropValue(vtodo, VCSequenceProp, tmpStr.local8Bit()); + + // last modification date + tmpStr = qDateTimeToISO(anEvent->lastModified()); + addPropValue(vtodo, VCLastModifiedProp, tmpStr.local8Bit()); + + // organizer stuff + tmpStr = "MAILTO:" + anEvent->organizer(); + addPropValue(vtodo, ICOrganizerProp, tmpStr.local8Bit()); + + // attendees + if (anEvent->attendeeCount() != 0) { + QPtrList al = anEvent->attendees(); + QPtrListIterator ai(al); + Attendee *curAttendee; + + for (; ai.current(); ++ai) { + curAttendee = ai.current(); + if (!curAttendee->email().isEmpty() && + !curAttendee->name().isEmpty()) + tmpStr = "MAILTO:" + curAttendee->name() + " <" + + curAttendee->email() + ">"; + else if (curAttendee->name().isEmpty()) + tmpStr = "MAILTO: " + curAttendee->email(); + else if (curAttendee->email().isEmpty()) + tmpStr = "MAILTO: " + curAttendee->name(); + else if (curAttendee->name().isEmpty() && + curAttendee->email().isEmpty()) + kdDebug(5800) << "warning! this Event has an attendee w/o name or email!" << endl; + VObject *aProp = addPropValue(vtodo, VCAttendeeProp, tmpStr.local8Bit()); + addPropValue(aProp, VCRSVPProp, curAttendee->RSVP() ? "TRUE" : "FALSE"); + addPropValue(aProp, VCStatusProp, writeStatus(curAttendee->status())); + } + } + + // description BL: + if (!anEvent->description().isEmpty()) { + VObject *d = addPropValue(vtodo, VCDescriptionProp, + anEvent->description().local8Bit()); + if (anEvent->description().find('\n') != -1) + addProp(d, VCQuotedPrintableProp); + } + + // summary + if (!anEvent->summary().isEmpty()) + addPropValue(vtodo, VCSummaryProp, anEvent->summary().local8Bit()); + + if (!anEvent->location().isEmpty()) + addPropValue(vtodo, VCLocationProp, anEvent->location().local8Bit()); + + // completed + // status + // backward compatibility, KOrganizer used to interpret only these two values + addPropValue(vtodo, VCStatusProp, anEvent->isCompleted() ? "COMPLETED" : + "NEEDS_ACTION"); + // completion date + if (anEvent->hasCompletedDate()) { + tmpStr = qDateTimeToISO(anEvent->completed()); + addPropValue(vtodo, VCCompletedProp, tmpStr.local8Bit()); + } + + // priority + tmpStr.sprintf("%i",anEvent->priority()); + addPropValue(vtodo, VCPriorityProp, tmpStr.local8Bit()); + + // related event + if (anEvent->relatedTo()) { + addPropValue(vtodo, VCRelatedToProp, + anEvent->relatedTo()->uid().local8Bit()); + } + + // categories + tmpStrList = anEvent->categories(); + tmpStr = ""; + QString catStr; + for ( QStringList::Iterator it = tmpStrList.begin(); + it != tmpStrList.end(); + ++it ) { + catStr = *it; + if (catStr[0] == ' ') + tmpStr += catStr.mid(1); + else + tmpStr += catStr; + // this must be a ';' character as the vCalendar specification requires! + // vcc.y has been hacked to translate the ';' to a ',' when the vcal is + // read in. + tmpStr += ";"; + } + if (!tmpStr.isEmpty()) { + tmpStr.truncate(tmpStr.length()-1); + addPropValue(vtodo, VCCategoriesProp, tmpStr.local8Bit()); + } + + // alarm stuff + kdDebug(5800) << "vcalformat::eventToVTodo was called" << endl; + QPtrList alarms = anEvent->alarms(); + Alarm* alarm; + for (alarm = alarms.first(); alarm; alarm = alarms.next()) { + if (alarm->enabled()) { + VObject *a = addProp(vtodo, VCDAlarmProp); + tmpStr = qDateTimeToISO(alarm->time()); + addPropValue(a, VCRunTimeProp, tmpStr.local8Bit()); + addPropValue(a, VCRepeatCountProp, "1"); + addPropValue(a, VCDisplayStringProp, "beep!"); + if (alarm->type() == Alarm::Audio) { + a = addProp(vtodo, VCAAlarmProp); + addPropValue(a, VCRunTimeProp, tmpStr.local8Bit()); + addPropValue(a, VCRepeatCountProp, "1"); + addPropValue(a, VCAudioContentProp, QFile::encodeName(alarm->audioFile())); + } + else if (alarm->type() == Alarm::Procedure) { + a = addProp(vtodo, VCPAlarmProp); + addPropValue(a, VCRunTimeProp, tmpStr.local8Bit()); + addPropValue(a, VCRepeatCountProp, "1"); + addPropValue(a, VCProcedureNameProp, QFile::encodeName(alarm->programFile())); + } + } + } + + if (anEvent->pilotId()) { + // pilot sync stuff + tmpStr.sprintf("%i",anEvent->pilotId()); + addPropValue(vtodo, KPilotIdProp, tmpStr.local8Bit()); + tmpStr.sprintf("%i",anEvent->syncStatus()); + addPropValue(vtodo, KPilotStatusProp, tmpStr.local8Bit()); + } + + return vtodo; +} + +VObject* VCalFormat::eventToVEvent(const Event *anEvent) +{ + VObject *vevent; + QString tmpStr; + QStringList tmpStrList; + + vevent = newVObject(VCEventProp); + + // start and end time + tmpStr = qDateTimeToISO(anEvent->dtStart(), + !anEvent->doesFloat()); + addPropValue(vevent, VCDTstartProp, tmpStr.local8Bit()); + + // events that have time associated but take up no time should + // not have both DTSTART and DTEND. + if (anEvent->dtStart() != anEvent->dtEnd()) { + tmpStr = qDateTimeToISO(anEvent->dtEnd(), + !anEvent->doesFloat()); + addPropValue(vevent, VCDTendProp, tmpStr.local8Bit()); + } + + // creation date + tmpStr = qDateTimeToISO(anEvent->created()); + addPropValue(vevent, VCDCreatedProp, tmpStr.local8Bit()); + + // unique id + addPropValue(vevent, VCUniqueStringProp, + anEvent->uid().local8Bit()); + + // revision + tmpStr.sprintf("%i", anEvent->revision()); + addPropValue(vevent, VCSequenceProp, tmpStr.local8Bit()); + + // last modification date + tmpStr = qDateTimeToISO(anEvent->lastModified()); + addPropValue(vevent, VCLastModifiedProp, tmpStr.local8Bit()); + + // attendee and organizer stuff + tmpStr = "MAILTO:" + anEvent->organizer(); + addPropValue(vevent, ICOrganizerProp, tmpStr.local8Bit()); + + if (anEvent->attendeeCount() != 0) { + QPtrList al = anEvent->attendees(); + QPtrListIterator ai(al); + Attendee *curAttendee; + + // TODO: Put this functionality into Attendee class + for (; ai.current(); ++ai) { + curAttendee = ai.current(); + if (!curAttendee->email().isEmpty() && + !curAttendee->name().isEmpty()) + tmpStr = "MAILTO:" + curAttendee->name() + " <" + + curAttendee->email() + ">"; + else if (curAttendee->name().isEmpty()) + tmpStr = "MAILTO: " + curAttendee->email(); + else if (curAttendee->email().isEmpty()) + tmpStr = "MAILTO: " + curAttendee->name(); + else if (curAttendee->name().isEmpty() && + curAttendee->email().isEmpty()) + kdDebug(5800) << "warning! this Event has an attendee w/o name or email!" << endl; + VObject *aProp = addPropValue(vevent, VCAttendeeProp, tmpStr.local8Bit()); + addPropValue(aProp, VCRSVPProp, curAttendee->RSVP() ? "TRUE" : "FALSE");; + addPropValue(aProp, VCStatusProp, writeStatus(curAttendee->status())); + } + } + + // recurrence rule stuff + if (anEvent->recurrence()->doesRecur()) { + // some more variables + QPtrList tmpPositions; + QPtrList tmpDays; + int *tmpDay; + Recurrence::rMonthPos *tmpPos; + QString tmpStr2; + int i; + + switch(anEvent->recurrence()->doesRecur()) { + case Recurrence::rDaily: + tmpStr.sprintf("D%i ",anEvent->recurrence()->frequency()); +// if (anEvent->rDuration > 0) +// tmpStr += "#"; + break; + case Recurrence::rWeekly: + tmpStr.sprintf("W%i ",anEvent->recurrence()->frequency()); + for (i = 0; i < 7; i++) { + if (anEvent->recurrence()->days().testBit(i)) + tmpStr += dayFromNum(i); + } + break; + case Recurrence::rMonthlyPos: + tmpStr.sprintf("MP%i ", anEvent->recurrence()->frequency()); + // write out all rMonthPos's + tmpPositions = anEvent->recurrence()->monthPositions(); + for (tmpPos = tmpPositions.first(); + tmpPos; + tmpPos = tmpPositions.next()) { + + tmpStr2.sprintf("%i", tmpPos->rPos); + if (tmpPos->negative) + tmpStr2 += "- "; + else + tmpStr2 += "+ "; + tmpStr += tmpStr2; + for (i = 0; i < 7; i++) { + if (tmpPos->rDays.testBit(i)) + tmpStr += dayFromNum(i); + } + } // loop for all rMonthPos's + break; + case Recurrence::rMonthlyDay: + tmpStr.sprintf("MD%i ", anEvent->recurrence()->frequency()); + // write out all rMonthDays; + tmpDays = anEvent->recurrence()->monthDays(); + for (tmpDay = tmpDays.first(); + tmpDay; + tmpDay = tmpDays.next()) { + tmpStr2.sprintf("%i ", *tmpDay); + tmpStr += tmpStr2; + } + break; + case Recurrence::rYearlyMonth: + tmpStr.sprintf("YM%i ", anEvent->recurrence()->frequency()); + // write out all the rYearNums; + tmpDays = anEvent->recurrence()->yearNums(); + for (tmpDay = tmpDays.first(); + tmpDay; + tmpDay = tmpDays.next()) { + tmpStr2.sprintf("%i ", *tmpDay); + tmpStr += tmpStr2; + } + break; + case Recurrence::rYearlyDay: + tmpStr.sprintf("YD%i ", anEvent->recurrence()->frequency()); + // write out all the rYearNums; + tmpDays = anEvent->recurrence()->yearNums(); + for (tmpDay = tmpDays.first(); + tmpDay; + tmpDay = tmpDays.next()) { + tmpStr2.sprintf("%i ", *tmpDay); + tmpStr += tmpStr2; + } + break; + default: + kdDebug(5800) << "ERROR, it should never get here in eventToVEvent!" << endl; + break; + } // switch + + if (anEvent->recurrence()->duration() > 0) { + tmpStr2.sprintf("#%i",anEvent->recurrence()->duration()); + tmpStr += tmpStr2; + } else if (anEvent->recurrence()->duration() == -1) { + tmpStr += "#0"; // defined as repeat forever + } else { + tmpStr += qDateTimeToISO(anEvent->recurrence()->endDate(), FALSE); + } + addPropValue(vevent,VCRRuleProp, tmpStr.local8Bit()); + + } // event repeats + + // exceptions to recurrence + DateList dateList = anEvent->exDates(); + DateList::ConstIterator it; + QString tmpStr2; + + for (it = dateList.begin(); it != dateList.end(); ++it) { + tmpStr = qDateToISO(*it) + ";"; + tmpStr2 += tmpStr; + } + if (!tmpStr2.isEmpty()) { + tmpStr2.truncate(tmpStr2.length()-1); + addPropValue(vevent, VCExDateProp, tmpStr2.local8Bit()); + } + + // description + if (!anEvent->description().isEmpty()) { + VObject *d = addPropValue(vevent, VCDescriptionProp, + anEvent->description().local8Bit()); + if (anEvent->description().find('\n') != -1) + addProp(d, VCQuotedPrintableProp); + } + + // summary + if (!anEvent->summary().isEmpty()) + addPropValue(vevent, VCSummaryProp, anEvent->summary().local8Bit()); + + if (!anEvent->location().isEmpty()) + addPropValue(vevent, VCLocationProp, anEvent->location().local8Bit()); + + // status +// TODO: define Event status +// addPropValue(vevent, VCStatusProp, anEvent->statusStr().local8Bit()); + + // secrecy + const char *text = 0; + switch (anEvent->secrecy()) { + case Incidence::SecrecyPublic: + text = "PUBLIC"; + break; + case Incidence::SecrecyPrivate: + text = "PRIVATE"; + break; + case Incidence::SecrecyConfidential: + text = "CONFIDENTIAL"; + break; + } + if (text) { + addPropValue(vevent, VCClassProp, text); + } + + // categories + tmpStrList = anEvent->categories(); + tmpStr = ""; + QString catStr; + for ( QStringList::Iterator it = tmpStrList.begin(); + it != tmpStrList.end(); + ++it ) { + catStr = *it; + if (catStr[0] == ' ') + tmpStr += catStr.mid(1); + else + tmpStr += catStr; + // this must be a ';' character as the vCalendar specification requires! + // vcc.y has been hacked to translate the ';' to a ',' when the vcal is + // read in. + tmpStr += ";"; + } + if (!tmpStr.isEmpty()) { + tmpStr.truncate(tmpStr.length()-1); + addPropValue(vevent, VCCategoriesProp, tmpStr.local8Bit()); + } + + // attachments + // TODO: handle binary attachments! + QPtrList attachments = anEvent->attachments(); + for ( Attachment *at = attachments.first(); at; at = attachments.next() ) + addPropValue(vevent, VCAttachProp, at->uri().local8Bit()); + + // resources + tmpStrList = anEvent->resources(); + tmpStr = tmpStrList.join(";"); + if (!tmpStr.isEmpty()) + addPropValue(vevent, VCResourcesProp, tmpStr.local8Bit()); + + // alarm stuff + QPtrList alarms = anEvent->alarms(); + Alarm* alarm; + for (alarm = alarms.first(); alarm; alarm = alarms.next()) { + if (alarm->enabled()) { + VObject *a = addProp(vevent, VCDAlarmProp); + tmpStr = qDateTimeToISO(alarm->time()); + addPropValue(a, VCRunTimeProp, tmpStr.local8Bit()); + addPropValue(a, VCRepeatCountProp, "1"); + addPropValue(a, VCDisplayStringProp, "beep!"); + if (alarm->type() == Alarm::Audio) { + a = addProp(vevent, VCAAlarmProp); + addPropValue(a, VCRunTimeProp, tmpStr.local8Bit()); + addPropValue(a, VCRepeatCountProp, "1"); + addPropValue(a, VCAudioContentProp, QFile::encodeName(alarm->audioFile())); + } + if (alarm->type() == Alarm::Procedure) { + a = addProp(vevent, VCPAlarmProp); + addPropValue(a, VCRunTimeProp, tmpStr.local8Bit()); + addPropValue(a, VCRepeatCountProp, "1"); + addPropValue(a, VCProcedureNameProp, QFile::encodeName(alarm->programFile())); + } + } + } + + // priority + tmpStr.sprintf("%i",anEvent->priority()); + addPropValue(vevent, VCPriorityProp, tmpStr.local8Bit()); + + // transparency + tmpStr.sprintf("%i",anEvent->transparency()); + addPropValue(vevent, VCTranspProp, tmpStr.local8Bit()); + + // related event + if (anEvent->relatedTo()) { + addPropValue(vevent, VCRelatedToProp, + anEvent->relatedTo()->uid().local8Bit()); + } + + if (anEvent->pilotId()) { + // pilot sync stuff + tmpStr.sprintf("%i",anEvent->pilotId()); + addPropValue(vevent, KPilotIdProp, tmpStr.local8Bit()); + tmpStr.sprintf("%i",anEvent->syncStatus()); + addPropValue(vevent, KPilotStatusProp, tmpStr.local8Bit()); + } + + return vevent; +} + +Todo *VCalFormat::VTodoToEvent(VObject *vtodo) +{ + VObject *vo; + VObjectIterator voi; + char *s; + + Todo *anEvent = new Todo; + + // creation date + if ((vo = isAPropertyOf(vtodo, VCDCreatedProp)) != 0) { + anEvent->setCreated(ISOToQDateTime(s = fakeCString(vObjectUStringZValue(vo)))); + deleteStr(s); + } + + // unique id + vo = isAPropertyOf(vtodo, VCUniqueStringProp); + // while the UID property is preferred, it is not required. We'll use the + // default Event UID if none is given. + if (vo) { + anEvent->setUid(s = fakeCString(vObjectUStringZValue(vo))); + deleteStr(s); + } + + // last modification date + if ((vo = isAPropertyOf(vtodo, VCLastModifiedProp)) != 0) { + anEvent->setLastModified(ISOToQDateTime(s = fakeCString(vObjectUStringZValue(vo)))); + deleteStr(s); + } + else + anEvent->setLastModified(QDateTime(QDate::currentDate(), + QTime::currentTime())); + + // organizer + // if our extension property for the event's ORGANIZER exists, add it. + if ((vo = isAPropertyOf(vtodo, ICOrganizerProp)) != 0) { + anEvent->setOrganizer(s = fakeCString(vObjectUStringZValue(vo))); + deleteStr(s); + } else { + anEvent->setOrganizer(mCalendar->getEmail()); + } + + // attendees. + initPropIterator(&voi, vtodo); + while (moreIteration(&voi)) { + vo = nextVObject(&voi); + if (strcmp(vObjectName(vo), VCAttendeeProp) == 0) { + Attendee *a; + VObject *vp; + s = fakeCString(vObjectUStringZValue(vo)); + QString tmpStr = QString::fromLocal8Bit(s); + deleteStr(s); + tmpStr = tmpStr.simplifyWhiteSpace(); + int emailPos1, emailPos2; + if ((emailPos1 = tmpStr.find('<')) > 0) { + // both email address and name + emailPos2 = tmpStr.findRev('>'); + a = new Attendee(tmpStr.left(emailPos1 - 1), + tmpStr.mid(emailPos1 + 1, + emailPos2 - (emailPos1 + 1))); + } else if (tmpStr.find('@') > 0) { + // just an email address + a = new Attendee(0, tmpStr); + } else { + // just a name + QString email = tmpStr.replace( QRegExp(" "), "." ); + a = new Attendee(tmpStr,email); + } + + // is there an RSVP property? + if ((vp = isAPropertyOf(vo, VCRSVPProp)) != 0) + a->setRSVP(vObjectStringZValue(vp)); + // is there a status property? + if ((vp = isAPropertyOf(vo, VCStatusProp)) != 0) + a->setStatus(readStatus(vObjectStringZValue(vp))); + // add the attendee + anEvent->addAttendee(a); + } + } + + // description for todo + if ((vo = isAPropertyOf(vtodo, VCDescriptionProp)) != 0) { + s = fakeCString(vObjectUStringZValue(vo)); + anEvent->setDescription(QString::fromLocal8Bit(s)); + deleteStr(s); + } + + // summary + if ((vo = isAPropertyOf(vtodo, VCSummaryProp))) { + s = fakeCString(vObjectUStringZValue(vo)); + anEvent->setSummary(QString::fromLocal8Bit(s)); + deleteStr(s); + } + if ((vo = isAPropertyOf(vtodo, VCLocationProp))) { + s = fakeCString(vObjectUStringZValue(vo)); + anEvent->setLocation(QString::fromLocal8Bit(s)); + deleteStr(s); + } + + + // completed + // was: status + if ((vo = isAPropertyOf(vtodo, VCStatusProp)) != 0) { + s = fakeCString(vObjectUStringZValue(vo)); + if (strcmp(s,"COMPLETED") == 0) { + anEvent->setCompleted(true); + } else { + anEvent->setCompleted(false); + } + deleteStr(s); + } + else + anEvent->setCompleted(false); + + // completion date + if ((vo = isAPropertyOf(vtodo, VCCompletedProp)) != 0) { + anEvent->setCompleted(ISOToQDateTime(s = fakeCString(vObjectUStringZValue(vo)))); + deleteStr(s); + } + + // priority + if ((vo = isAPropertyOf(vtodo, VCPriorityProp))) { + anEvent->setPriority(atoi(s = fakeCString(vObjectUStringZValue(vo)))); + deleteStr(s); + } + + // due date + if ((vo = isAPropertyOf(vtodo, VCDueProp)) != 0) { + anEvent->setDtDue(ISOToQDateTime(s = fakeCString(vObjectUStringZValue(vo)))); + deleteStr(s); + anEvent->setHasDueDate(true); + } else { + anEvent->setHasDueDate(false); + } + + // start time + if ((vo = isAPropertyOf(vtodo, VCDTstartProp)) != 0) { + anEvent->setDtStart(ISOToQDateTime(s = fakeCString(vObjectUStringZValue(vo)))); + // kdDebug(5800) << "s is " << // s << ", ISO is " << ISOToQDateTime(s = fakeCString(vObjectUStringZValue(vo))).toString() << endl; + deleteStr(s); + anEvent->setHasStartDate(true); + } else { + anEvent->setHasStartDate(false); + } + + /* alarm stuff */ + //kdDebug(5800) << "vcalformat::VTodoToEvent called" << endl; + if ((vo = isAPropertyOf(vtodo, VCDAlarmProp))) { + Alarm* alarm = anEvent->newAlarm(); + VObject *a; + if ((a = isAPropertyOf(vo, VCRunTimeProp))) { + alarm->setTime(ISOToQDateTime(s = fakeCString(vObjectUStringZValue(a)))); + deleteStr(s); + } + alarm->setEnabled(true); + if ((vo = isAPropertyOf(vtodo, VCPAlarmProp))) { + if ((a = isAPropertyOf(vo, VCProcedureNameProp))) { + s = fakeCString(vObjectUStringZValue(a)); + alarm->setProcedureAlarm(QFile::decodeName(s)); + deleteStr(s); + } + } + if ((vo = isAPropertyOf(vtodo, VCAAlarmProp))) { + if ((a = isAPropertyOf(vo, VCAudioContentProp))) { + s = fakeCString(vObjectUStringZValue(a)); + alarm->setAudioAlarm(QFile::decodeName(s)); + deleteStr(s); + } + } + } + + // related todo + if ((vo = isAPropertyOf(vtodo, VCRelatedToProp)) != 0) { + anEvent->setRelatedToUid(s = fakeCString(vObjectUStringZValue(vo))); + deleteStr(s); + mTodosRelate.append(anEvent); + } + + // categories + QStringList tmpStrList; + int index1 = 0; + int index2 = 0; + if ((vo = isAPropertyOf(vtodo, VCCategoriesProp)) != 0) { + s = fakeCString(vObjectUStringZValue(vo)); + QString categories = QString::fromLocal8Bit(s); + deleteStr(s); + //const char* category; + QString category; + while ((index2 = categories.find(',', index1)) != -1) { + //category = (const char *) categories.mid(index1, (index2 - index1)); + category = categories.mid(index1, (index2 - index1)); + tmpStrList.append(category); + index1 = index2+1; + } + // get last category + category = categories.mid(index1, (categories.length()-index1)); + tmpStrList.append(category); + anEvent->setCategories(tmpStrList); + } + + /* PILOT SYNC STUFF */ + if ((vo = isAPropertyOf(vtodo, KPilotIdProp))) { + anEvent->setPilotId(atoi(s = fakeCString(vObjectUStringZValue(vo)))); + deleteStr(s); + } + else + anEvent->setPilotId(0); + + if ((vo = isAPropertyOf(vtodo, KPilotStatusProp))) { + anEvent->setSyncStatus(atoi(s = fakeCString(vObjectUStringZValue(vo)))); + deleteStr(s); + } + else + anEvent->setSyncStatus(Event::SYNCMOD); + + return anEvent; +} + +Event* VCalFormat::VEventToEvent(VObject *vevent) +{ + VObject *vo; + VObjectIterator voi; + char *s; + + Event *anEvent = new Event; + + // creation date + if ((vo = isAPropertyOf(vevent, VCDCreatedProp)) != 0) { + anEvent->setCreated(ISOToQDateTime(s = fakeCString(vObjectUStringZValue(vo)))); + deleteStr(s); + } + + // unique id + vo = isAPropertyOf(vevent, VCUniqueStringProp); + // while the UID property is preferred, it is not required. We'll use the + // default Event UID if none is given. + if (vo) { + anEvent->setUid(s = fakeCString(vObjectUStringZValue(vo))); + deleteStr(s); + } + + // revision + // again NSCAL doesn't give us much to work with, so we improvise... + if ((vo = isAPropertyOf(vevent, VCSequenceProp)) != 0) { + anEvent->setRevision(atoi(s = fakeCString(vObjectUStringZValue(vo)))); + deleteStr(s); + } + else + anEvent->setRevision(0); + + // last modification date + if ((vo = isAPropertyOf(vevent, VCLastModifiedProp)) != 0) { + anEvent->setLastModified(ISOToQDateTime(s = fakeCString(vObjectUStringZValue(vo)))); + deleteStr(s); + } + else + anEvent->setLastModified(QDateTime(QDate::currentDate(), + QTime::currentTime())); + + // organizer + // if our extension property for the event's ORGANIZER exists, add it. + if ((vo = isAPropertyOf(vevent, ICOrganizerProp)) != 0) { + anEvent->setOrganizer(s = fakeCString(vObjectUStringZValue(vo))); + deleteStr(s); + } else { + anEvent->setOrganizer(mCalendar->getEmail()); + } + + // deal with attendees. + initPropIterator(&voi, vevent); + while (moreIteration(&voi)) { + vo = nextVObject(&voi); + if (strcmp(vObjectName(vo), VCAttendeeProp) == 0) { + Attendee *a; + VObject *vp; + s = fakeCString(vObjectUStringZValue(vo)); + QString tmpStr = QString::fromLocal8Bit(s); + deleteStr(s); + tmpStr = tmpStr.simplifyWhiteSpace(); + int emailPos1, emailPos2; + if ((emailPos1 = tmpStr.find('<')) > 0) { + // both email address and name + emailPos2 = tmpStr.findRev('>'); + a = new Attendee(tmpStr.left(emailPos1 - 1), + tmpStr.mid(emailPos1 + 1, + emailPos2 - (emailPos1 + 1))); + } else if (tmpStr.find('@') > 0) { + // just an email address + a = new Attendee(0, tmpStr); + } else { + // just a name + QString email = tmpStr.replace( QRegExp(" "), "." ); + a = new Attendee(tmpStr,email); + } + + // is there an RSVP property? + if ((vp = isAPropertyOf(vo, VCRSVPProp)) != 0) + a->setRSVP(vObjectStringZValue(vp)); + // is there a status property? + if ((vp = isAPropertyOf(vo, VCStatusProp)) != 0) + a->setStatus(readStatus(vObjectStringZValue(vp))); + // add the attendee + anEvent->addAttendee(a); + } + } + + // This isn't strictly true. An event that doesn't have a start time + // or an end time doesn't "float", it has an anchor in time but it doesn't + // "take up" any time. + /*if ((isAPropertyOf(vevent, VCDTstartProp) == 0) || + (isAPropertyOf(vevent, VCDTendProp) == 0)) { + anEvent->setFloats(TRUE); + } else { + }*/ + + anEvent->setFloats(FALSE); + + // start time + if ((vo = isAPropertyOf(vevent, VCDTstartProp)) != 0) { + anEvent->setDtStart(ISOToQDateTime(s = fakeCString(vObjectUStringZValue(vo)))); + // kdDebug(5800) << "s is " << // s << ", ISO is " << ISOToQDateTime(s = fakeCString(vObjectUStringZValue(vo))).toString() << endl; + deleteStr(s); + if (anEvent->dtStart().time().isNull()) + anEvent->setFloats(TRUE); + } + + // stop time + if ((vo = isAPropertyOf(vevent, VCDTendProp)) != 0) { + anEvent->setDtEnd(ISOToQDateTime(s = fakeCString(vObjectUStringZValue(vo)))); + deleteStr(s); + if (anEvent->dtEnd().time().isNull()) + anEvent->setFloats(TRUE); + } + + // 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 (!(vo = isAPropertyOf(vevent, VCDTstartProp))) + anEvent->setDtStart(anEvent->dtEnd()); + if (!(vo = isAPropertyOf(vevent, VCDTendProp))) + anEvent->setDtEnd(anEvent->dtStart()); + + /////////////////////////////////////////////////////////////////////////// + + // repeat stuff + if ((vo = isAPropertyOf(vevent, VCRRuleProp)) != 0) { + QString tmpStr = (s = fakeCString(vObjectUStringZValue(vo))); + deleteStr(s); + tmpStr.simplifyWhiteSpace(); + tmpStr = tmpStr.upper(); + + /********************************* DAILY ******************************/ + if (tmpStr.left(1) == "D") { + int index = tmpStr.find(' '); + int rFreq = tmpStr.mid(1, (index-1)).toInt(); + index = tmpStr.findRev(' ') + 1; // advance to last field + if (tmpStr.mid(index,1) == "#") index++; + if (tmpStr.find('T', index) != -1) { + QDate rEndDate = (ISOToQDateTime(tmpStr.mid(index, tmpStr.length()-index))).date(); + anEvent->recurrence()->setDaily(rFreq, rEndDate); + } else { + int rDuration = tmpStr.mid(index, tmpStr.length()-index).toInt(); + if (rDuration == 0) // VEvents set this to 0 forever, we use -1 + anEvent->recurrence()->setDaily(rFreq, -1); + else + anEvent->recurrence()->setDaily(rFreq, rDuration); + } + } + /********************************* WEEKLY ******************************/ + else if (tmpStr.left(1) == "W") { + int index = tmpStr.find(' '); + int last = tmpStr.findRev(' ') + 1; + int rFreq = tmpStr.mid(1, (index-1)).toInt(); + index += 1; // advance to beginning of stuff after freq + QBitArray qba(7); + QString dayStr; + if( index == last ) { + // e.g. W1 #0 + qba.setBit(anEvent->dtStart().date().dayOfWeek() - 1); + } + else { + // e.g. W1 SU #0 + while (index < last) { + dayStr = tmpStr.mid(index, 3); + int dayNum = numFromDay(dayStr); + qba.setBit(dayNum); + index += 3; // advance to next day, or possibly "#" + } + } + index = last; if (tmpStr.mid(index,1) == "#") index++; + if (tmpStr.find('T', index) != -1) { + QDate rEndDate = (ISOToQDateTime(tmpStr.mid(index, tmpStr.length()-index))).date(); + anEvent->recurrence()->setWeekly(rFreq, qba, rEndDate); + } else { + int rDuration = tmpStr.mid(index, tmpStr.length()-index).toInt(); + if (rDuration == 0) + anEvent->recurrence()->setWeekly(rFreq, qba, -1); + else + anEvent->recurrence()->setWeekly(rFreq, qba, rDuration); + } + } + /**************************** MONTHLY-BY-POS ***************************/ + else if (tmpStr.left(2) == "MP") { + int index = tmpStr.find(' '); + int last = tmpStr.findRev(' ') + 1; + int rFreq = tmpStr.mid(2, (index-1)).toInt(); + index += 1; // advance to beginning of stuff after freq + QBitArray qba(7); + short tmpPos; + if( index == last ) { + // e.g. MP1 #0 + tmpPos = anEvent->dtStart().date().day()/7 + 1; + if( tmpPos == 5 ) + tmpPos = -1; + qba.setBit(anEvent->dtStart().date().dayOfWeek() - 1); + anEvent->recurrence()->addMonthlyPos(tmpPos, qba); + } + else { + // e.g. MP1 1+ SU #0 + while (index < last) { + tmpPos = tmpStr.mid(index,1).toShort(); + index += 1; + if (tmpStr.mid(index,1) == "-") + // convert tmpPos to negative + tmpPos = 0 - tmpPos; + index += 2; // advance to day(s) + while (numFromDay(tmpStr.mid(index,3)) >= 0) { + int dayNum = numFromDay(tmpStr.mid(index,3)); + qba.setBit(dayNum); + index += 3; // advance to next day, or possibly pos or "#" + } + anEvent->recurrence()->addMonthlyPos(tmpPos, qba); + qba.detach(); + qba.fill(FALSE); // clear out + } // while != "#" + } + index = last; if (tmpStr.mid(index,1) == "#") index++; + if (tmpStr.find('T', index) != -1) { + QDate rEndDate = (ISOToQDateTime(tmpStr.mid(index, tmpStr.length() - + index))).date(); + anEvent->recurrence()->setMonthly(Recurrence::rMonthlyPos, rFreq, rEndDate); + } else { + int rDuration = tmpStr.mid(index, tmpStr.length()-index).toInt(); + if (rDuration == 0) + anEvent->recurrence()->setMonthly(Recurrence::rMonthlyPos, rFreq, -1); + else + anEvent->recurrence()->setMonthly(Recurrence::rMonthlyPos, rFreq, rDuration); + } + } + + /**************************** MONTHLY-BY-DAY ***************************/ + else if (tmpStr.left(2) == "MD") { + int index = tmpStr.find(' '); + int last = tmpStr.findRev(' ') + 1; + int rFreq = tmpStr.mid(2, (index-1)).toInt(); + index += 1; + short tmpDay; + if( index == last ) { + // e.g. MD1 #0 + tmpDay = anEvent->dtStart().date().day(); + anEvent->recurrence()->addMonthlyDay(tmpDay); + } + else { + // e.g. MD1 3 #0 + while (index < last) { + int index2 = tmpStr.find(' ', index); + tmpDay = tmpStr.mid(index, (index2-index)).toShort(); + index = index2-1; + if (tmpStr.mid(index, 1) == "-") + tmpDay = 0 - tmpDay; + index += 2; // advance the index; + anEvent->recurrence()->addMonthlyDay(tmpDay); + } // while != # + } + index = last; if (tmpStr.mid(index,1) == "#") index++; + if (tmpStr.find('T', index) != -1) { + QDate rEndDate = (ISOToQDateTime(tmpStr.mid(index, tmpStr.length()-index))).date(); + anEvent->recurrence()->setMonthly(Recurrence::rMonthlyDay, rFreq, rEndDate); + } else { + int rDuration = tmpStr.mid(index, tmpStr.length()-index).toInt(); + if (rDuration == 0) + anEvent->recurrence()->setMonthly(Recurrence::rMonthlyDay, rFreq, -1); + else + anEvent->recurrence()->setMonthly(Recurrence::rMonthlyDay, rFreq, rDuration); + } + } + + /*********************** YEARLY-BY-MONTH *******************************/ + else if (tmpStr.left(2) == "YM") { + int index = tmpStr.find(' '); + int last = tmpStr.findRev(' ') + 1; + int rFreq = tmpStr.mid(2, (index-1)).toInt(); + index += 1; + short tmpMonth; + if( index == last ) { + // e.g. YM1 #0 + tmpMonth = anEvent->dtStart().date().month(); + anEvent->recurrence()->addYearlyNum(tmpMonth); + } + else { + // e.g. YM1 3 #0 + while (index < last) { + int index2 = tmpStr.find(' ', index); + tmpMonth = tmpStr.mid(index, (index2-index)).toShort(); + index = index2+1; + anEvent->recurrence()->addYearlyNum(tmpMonth); + } // while != # + } + index = last; if (tmpStr.mid(index,1) == "#") index++; + if (tmpStr.find('T', index) != -1) { + QDate rEndDate = (ISOToQDateTime(tmpStr.mid(index, tmpStr.length()-index))).date(); + anEvent->recurrence()->setYearly(Recurrence::rYearlyMonth, rFreq, rEndDate); + } else { + int rDuration = tmpStr.mid(index, tmpStr.length()-index).toInt(); + if (rDuration == 0) + anEvent->recurrence()->setYearly(Recurrence::rYearlyMonth, rFreq, -1); + else + anEvent->recurrence()->setYearly(Recurrence::rYearlyMonth, rFreq, rDuration); + } + } + + /*********************** YEARLY-BY-DAY *********************************/ + else if (tmpStr.left(2) == "YD") { + int index = tmpStr.find(' '); + int last = tmpStr.findRev(' ') + 1; + int rFreq = tmpStr.mid(2, (index-1)).toInt(); + index += 1; + short tmpDay; + if( index == last ) { + // e.g. YD1 #0 + tmpDay = anEvent->dtStart().date().dayOfYear(); + anEvent->recurrence()->addYearlyNum(tmpDay); + } + else { + // e.g. YD1 123 #0 + while (index < last) { + int index2 = tmpStr.find(' ', index); + tmpDay = tmpStr.mid(index, (index2-index)).toShort(); + index = index2+1; + anEvent->recurrence()->addYearlyNum(tmpDay); + } // while != # + } + index = last; if (tmpStr.mid(index,1) == "#") index++; + if (tmpStr.find('T', index) != -1) { + QDate rEndDate = (ISOToQDateTime(tmpStr.mid(index, tmpStr.length()-index))).date(); + anEvent->recurrence()->setYearly(Recurrence::rYearlyDay, rFreq, rEndDate); + } else { + int rDuration = tmpStr.mid(index, tmpStr.length()-index).toInt(); + if (rDuration == 0) + anEvent->recurrence()->setYearly(Recurrence::rYearlyDay, rFreq, -1); + else + anEvent->recurrence()->setYearly(Recurrence::rYearlyDay, rFreq, rDuration); + } + } else { + kdDebug(5800) << "we don't understand this type of recurrence!" << endl; + } // if + } // repeats + + + // recurrence exceptions + if ((vo = isAPropertyOf(vevent, VCExDateProp)) != 0) { + s = fakeCString(vObjectUStringZValue(vo)); + QStringList exDates = QStringList::split(",",s); + QStringList::ConstIterator it; + for(it = exDates.begin(); it != exDates.end(); ++it ) { + anEvent->addExDate(ISOToQDate(*it)); + } + deleteStr(s); + } + + // summary + if ((vo = isAPropertyOf(vevent, VCSummaryProp))) { + s = fakeCString(vObjectUStringZValue(vo)); + anEvent->setSummary(QString::fromLocal8Bit(s)); + deleteStr(s); + } + if ((vo = isAPropertyOf(vevent, VCLocationProp))) { + s = fakeCString(vObjectUStringZValue(vo)); + anEvent->setLocation(QString::fromLocal8Bit(s)); + deleteStr(s); + } + + // description + if ((vo = isAPropertyOf(vevent, VCDescriptionProp)) != 0) { + s = fakeCString(vObjectUStringZValue(vo)); + if (!anEvent->description().isEmpty()) { + anEvent->setDescription(anEvent->description() + "\n" + + QString::fromLocal8Bit(s)); + } else { + anEvent->setDescription(QString::fromLocal8Bit(s)); + } + deleteStr(s); + } + + // some stupid vCal exporters ignore the standard and use Description + // instead of Summary for the default field. Correct for this. + if (anEvent->summary().isEmpty() && + !(anEvent->description().isEmpty())) { + QString tmpStr = anEvent->description().simplifyWhiteSpace(); + anEvent->setDescription(""); + anEvent->setSummary(tmpStr); + } + +#if 0 + // status + if ((vo = isAPropertyOf(vevent, VCStatusProp)) != 0) { + QString tmpStr(s = fakeCString(vObjectUStringZValue(vo))); + deleteStr(s); +// TODO: Define Event status +// anEvent->setStatus(tmpStr); + } + else +// anEvent->setStatus("NEEDS ACTION"); +#endif + + // secrecy + int secrecy = Incidence::SecrecyPublic; + if ((vo = isAPropertyOf(vevent, VCClassProp)) != 0) { + s = fakeCString(vObjectUStringZValue(vo)); + if (strcmp(s,"PRIVATE") == 0) { + secrecy = Incidence::SecrecyPrivate; + } else if (strcmp(s,"CONFIDENTIAL") == 0) { + secrecy = Incidence::SecrecyConfidential; + } + deleteStr(s); + } + anEvent->setSecrecy(secrecy); + + // categories + QStringList tmpStrList; + int index1 = 0; + int index2 = 0; + if ((vo = isAPropertyOf(vevent, VCCategoriesProp)) != 0) { + s = fakeCString(vObjectUStringZValue(vo)); + QString categories = QString::fromLocal8Bit(s); + deleteStr(s); + //const char* category; + QString category; + while ((index2 = categories.find(',', index1)) != -1) { + //category = (const char *) categories.mid(index1, (index2 - index1)); + category = categories.mid(index1, (index2 - index1)); + tmpStrList.append(category); + index1 = index2+1; + } + // get last category + category = categories.mid(index1, (categories.length()-index1)); + tmpStrList.append(category); + anEvent->setCategories(tmpStrList); + } + + // attachments + tmpStrList.clear(); + initPropIterator(&voi, vevent); + while (moreIteration(&voi)) { + vo = nextVObject(&voi); + if (strcmp(vObjectName(vo), VCAttachProp) == 0) { + s = fakeCString(vObjectUStringZValue(vo)); + anEvent->addAttachment(new Attachment(QString(s))); + deleteStr(s); + } + } + + // 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); + } + + /* alarm stuff */ + if ((vo = isAPropertyOf(vevent, VCDAlarmProp))) { + Alarm* alarm = anEvent->newAlarm(); + VObject *a; + if ((a = isAPropertyOf(vo, VCRunTimeProp))) { + alarm->setTime(ISOToQDateTime(s = fakeCString(vObjectUStringZValue(a)))); + deleteStr(s); + } + alarm->setEnabled(true); + if ((vo = isAPropertyOf(vevent, VCPAlarmProp))) { + if ((a = isAPropertyOf(vo, VCProcedureNameProp))) { + s = fakeCString(vObjectUStringZValue(a)); + alarm->setProcedureAlarm(QFile::decodeName(s)); + deleteStr(s); + } + } + if ((vo = isAPropertyOf(vevent, VCAAlarmProp))) { + if ((a = isAPropertyOf(vo, VCAudioContentProp))) { + s = fakeCString(vObjectUStringZValue(a)); + alarm->setAudioAlarm(QFile::decodeName(s)); + deleteStr(s); + } + } + } + + // priority + if ((vo = isAPropertyOf(vevent, VCPriorityProp))) { + anEvent->setPriority(atoi(s = fakeCString(vObjectUStringZValue(vo)))); + deleteStr(s); + } + + // transparency + if ((vo = isAPropertyOf(vevent, VCTranspProp)) != 0) { + int i = atoi(s = fakeCString(vObjectUStringZValue(vo))); + anEvent->setTransparency( i == 1 ? Event::Transparent : Event::Opaque ); + deleteStr(s); + } + + // related event + if ((vo = isAPropertyOf(vevent, VCRelatedToProp)) != 0) { + anEvent->setRelatedToUid(s = fakeCString(vObjectUStringZValue(vo))); + deleteStr(s); + mEventsRelate.append(anEvent); + } + + /* PILOT SYNC STUFF */ + if ((vo = isAPropertyOf(vevent, KPilotIdProp))) { + anEvent->setPilotId(atoi(s = fakeCString(vObjectUStringZValue(vo)))); + deleteStr(s); + } + else + anEvent->setPilotId(0); + + if ((vo = isAPropertyOf(vevent, KPilotStatusProp))) { + anEvent->setSyncStatus(atoi(s = fakeCString(vObjectUStringZValue(vo)))); + deleteStr(s); + } + else + anEvent->setSyncStatus(Event::SYNCMOD); + + return anEvent; +} + + +QString VCalFormat::qDateToISO(const QDate &qd) +{ + QString tmpStr; + + ASSERT(qd.isValid()); + + tmpStr.sprintf("%.2d%.2d%.2d", + qd.year(), qd.month(), qd.day()); + return tmpStr; + +} + +QString VCalFormat::qDateTimeToISO(const QDateTime &qdt, bool zulu) +{ + QString tmpStr; + + ASSERT(qdt.date().isValid()); + ASSERT(qdt.time().isValid()); + if (zulu) { + QDateTime tmpDT(qdt); + tmpDT = tmpDT.addSecs(60*(-mCalendar->getTimeZone())); // correct to GMT. + tmpStr.sprintf("%.2d%.2d%.2dT%.2d%.2d%.2dZ", + tmpDT.date().year(), tmpDT.date().month(), + tmpDT.date().day(), tmpDT.time().hour(), + tmpDT.time().minute(), tmpDT.time().second()); + } else { + tmpStr.sprintf("%.2d%.2d%.2dT%.2d%.2d%.2d", + qdt.date().year(), qdt.date().month(), + qdt.date().day(), qdt.time().hour(), + qdt.time().minute(), qdt.time().second()); + } + return tmpStr; +} + +QDateTime VCalFormat::ISOToQDateTime(const QString & dtStr) +{ + QDate tmpDate; + QTime tmpTime; + QString tmpStr; + int year, month, day, hour, minute, second; + + tmpStr = dtStr; + year = tmpStr.left(4).toInt(); + month = tmpStr.mid(4,2).toInt(); + day = tmpStr.mid(6,2).toInt(); + hour = tmpStr.mid(9,2).toInt(); + minute = tmpStr.mid(11,2).toInt(); + second = tmpStr.mid(13,2).toInt(); + tmpDate.setYMD(year, month, day); + tmpTime.setHMS(hour, minute, second); + + ASSERT(tmpDate.isValid()); + ASSERT(tmpTime.isValid()); + QDateTime tmpDT(tmpDate, tmpTime); + // correct for GMT if string is in Zulu format + if (dtStr.at(dtStr.length()-1) == 'Z') + tmpDT = tmpDT.addSecs(60*mCalendar->getTimeZone()); + return tmpDT; +} + +QDate VCalFormat::ISOToQDate(const QString &dateStr) +{ + int year, month, day; + + year = dateStr.left(4).toInt(); + month = dateStr.mid(4,2).toInt(); + day = dateStr.mid(6,2).toInt(); + + return(QDate(year, month, day)); +} + +// take a raw vcalendar (i.e. from a file on disk, clipboard, etc. etc. +// and break it down from it's tree-like format into the dictionary format +// that is used internally in the VCalFormat. +void VCalFormat::populate(VObject *vcal) +{ + // this function will populate the caldict dictionary and other event + // lists. It turns vevents into Events and then inserts them. + + VObjectIterator i; + VObject *curVO, *curVOProp; + Event *anEvent; + + if ((curVO = isAPropertyOf(vcal, ICMethodProp)) != 0) { + char *methodType = 0; + methodType = fakeCString(vObjectUStringZValue(curVO)); + kdDebug() << "This calendar is an iTIP transaction of type '" + << methodType << "'" << endl; + delete methodType; + } + + // warn the user that we might have trouble reading non-known calendar. + if ((curVO = isAPropertyOf(vcal, VCProdIdProp)) != 0) { + char *s = fakeCString(vObjectUStringZValue(curVO)); + if (strcmp(productId().local8Bit(), s) != 0) + kdDebug() << "This vCalendar file was not created by KOrganizer " + "or any other product we support. Loading anyway..." << endl; + mLoadedProductId = s; + deleteStr(s); + } + + // 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) + kdDebug() << "This vCalendar file has version " << s + << "We only support " << _VCAL_VERSION << endl; + deleteStr(s); + } + + // set the time zone + if ((curVO = isAPropertyOf(vcal, VCTimeZoneProp)) != 0) { + char *s = fakeCString(vObjectUStringZValue(curVO)); + mCalendar->setTimeZone(s); + deleteStr(s); + } + + + // Store all events with a relatedTo property in a list for post-processing + mEventsRelate.clear(); + mTodosRelate.clear(); + + 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); + kdDebug(5800) << "skipping pilot-deleted event" << endl; + 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 (mCalendar->event(tmpStr)) { + goto SKIP; + } + if (mCalendar->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) { + if ( !anEvent->dtStart().isValid() || !anEvent->dtEnd().isValid() ) { + kdDebug() << "VCalFormat::populate(): Event has invalid dates." + << endl; + } else { + mCalendar->addEvent(anEvent); + } + } else { + // some sort of error must have occurred while in translation. + goto SKIP; + } + } else if (strcmp(vObjectName(curVO), VCTodoProp) == 0) { + Todo *aTodo = VTodoToEvent(curVO); + mCalendar->addTodo(aTodo); + } 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 { + kdDebug(5800) << "Ignoring unknown vObject \"" << vObjectName(curVO) << "\"" << endl; + } + SKIP: + ; + } // while + + // Post-Process list of events with relations, put Event objects in relation + Event *ev; + for ( ev=mEventsRelate.first(); ev != 0; ev=mEventsRelate.next() ) { + ev->setRelatedTo(mCalendar->event(ev->relatedToUid())); + } + Todo *todo; + for ( todo=mTodosRelate.first(); todo != 0; todo=mTodosRelate.next() ) { + todo->setRelatedTo(mCalendar->todo(todo->relatedToUid())); + } +} + +const char *VCalFormat::dayFromNum(int day) +{ + const char *days[7] = { "MO ", "TU ", "WE ", "TH ", "FR ", "SA ", "SU " }; + + return days[day]; +} + +int VCalFormat::numFromDay(const QString &day) +{ + if (day == "MO ") return 0; + if (day == "TU ") return 1; + if (day == "WE ") return 2; + if (day == "TH ") return 3; + if (day == "FR ") return 4; + if (day == "SA ") return 5; + if (day == "SU ") return 6; + + return -1; // something bad happened. :) +} + +Attendee::PartStat VCalFormat::readStatus(const char *s) const +{ + QString statStr = s; + statStr = statStr.upper(); + Attendee::PartStat status; + + if (statStr == "X-ACTION") + status = Attendee::NeedsAction; + else if (statStr == "NEEDS ACTION") + status = Attendee::NeedsAction; + else if (statStr== "ACCEPTED") + status = Attendee::Accepted; + else if (statStr== "SENT") + status = Attendee::NeedsAction; + else if (statStr== "TENTATIVE") + status = Attendee::Tentative; + else if (statStr== "CONFIRMED") + status = Attendee::Accepted; + else if (statStr== "DECLINED") + status = Attendee::Declined; + else if (statStr== "COMPLETED") + status = Attendee::Completed; + else if (statStr== "DELEGATED") + status = Attendee::Delegated; + else { + kdDebug(5800) << "error setting attendee mStatus, unknown mStatus!" << endl; + status = Attendee::NeedsAction; + } + + return status; +} + +QCString VCalFormat::writeStatus(Attendee::PartStat status) const +{ + switch(status) { + default: + case Attendee::NeedsAction: + return "NEEDS ACTION"; + break; + case Attendee::Accepted: + return "ACCEPTED"; + break; + case Attendee::Declined: + return "DECLINED"; + break; + case Attendee::Tentative: + return "TENTATIVE"; + break; + case Attendee::Delegated: + return "DELEGATED"; + break; + case Attendee::Completed: + return "COMPLETED"; + break; + case Attendee::InProcess: + return "NEEDS ACTION"; + break; + } +} diff --git a/libkcal/vcalformat.h b/libkcal/vcalformat.h new file mode 100644 index 0000000..d4cecbc --- a/dev/null +++ b/libkcal/vcalformat.h @@ -0,0 +1,108 @@ +/* + This file is part of libkcal. + Copyright (c) 1998 Preston Brown + Copyright (c) 2001 Cornelius Schumacher + + 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 _VCALFORMAT_H +#define _VCALFORMAT_H + +#include "calformat.h" + +#define _VCAL_VERSION "1.0" + +class VObject; + +namespace KCal { + +/** + This class implements the vCalendar format. It provides methods for + loading/saving/converting vCalendar format data into the internal KOrganizer + representation as Calendar and Events. + + @short vCalendar format implementation +*/ +class VCalFormat : public CalFormat { + public: + VCalFormat(); + virtual ~VCalFormat(); + + /** loads a calendar on disk in vCalendar format into the current calendar. + * any information already present is lost. Returns TRUE if successful, + * else returns FALSE. + * @param fileName the name of the calendar on disk. + */ + bool load(Calendar *,const QString &fileName); + /** writes out the calendar to disk in vCalendar format. Returns true if + * successful and false on error. + * @param fileName the name of the file + */ + bool save(Calendar *,const QString &fileName); + + /** + Parse string and populate calendar with that information. + */ + bool fromString( Calendar *, const QString & ); + /** + Return calendar information as string. + */ + QString toString( Calendar * ); + + protected: + /** translates a VObject of the TODO type into a Event */ + Todo *VTodoToEvent(VObject *vtodo); + /** translates a VObject into a Event and returns a pointer to it. */ + Event *VEventToEvent(VObject *vevent); + /** translate a Event into a VTodo-type VObject and return pointer */ + VObject *eventToVTodo(const Todo *anEvent); + /** translate a Event into a VObject and returns a pointer to it. */ + VObject* eventToVEvent(const Event *anEvent); + + /** takes a QDate and returns a string in the format YYYYMMDDTHHMMSS */ + QString qDateToISO(const QDate &); + /** takes a QDateTime and returns a string in format YYYYMMDDTHHMMSS */ + QString qDateTimeToISO(const QDateTime &, bool zulu=TRUE); + /** takes a string in the format YYYYMMDDTHHMMSS and returns a + * valid QDateTime. */ + QDateTime ISOToQDateTime(const QString & dtStr); + /** takes a string in the format YYYYMMDD and returns a + * valid QDate. */ + QDate ISOToQDate(const QString & dtStr); + /** takes a vCalendar tree of VObjects, and puts all of them that have + * the "event" property into the dictionary, todos in the todo-list, etc. */ + void populate(VObject *vcal); + + /** takes a number 0 - 6 and returns the two letter string of that day, + * i.e. MO, TU, WE, etc. */ + const char *dayFromNum(int day); + /** the reverse of the above function. */ + int numFromDay(const QString &day); + + Attendee::PartStat readStatus(const char *s) const; + QCString writeStatus(Attendee::PartStat status) const; + + private: + Calendar *mCalendar; + + QPtrList mEventsRelate; // events with relations + QPtrList mTodosRelate; // todos with relations +}; + +} + +#endif diff --git a/libkcal/versit/port.h b/libkcal/versit/port.h new file mode 100644 index 0000000..afc16dd --- a/dev/null +++ b/libkcal/versit/port.h @@ -0,0 +1,75 @@ +/*************************************************************************** +(C) Copyright 1996 Apple Computer, Inc., AT&T Corp., International +Business Machines Corporation and Siemens Rolm Communications Inc. + +For purposes of this license notice, the term Licensors shall mean, +collectively, Apple Computer, Inc., AT&T Corp., International +Business Machines Corporation and Siemens Rolm Communications Inc. +The term Licensor shall mean any of the Licensors. + +Subject to acceptance of the following conditions, permission is hereby +granted by Licensors without the need for written agreement and without +license or royalty fees, to use, copy, modify and distribute this +software for any purpose. + +The above copyright notice and the following four paragraphs must be +reproduced in all copies of this software and any software including +this software. + +THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS AND NO LICENSOR SHALL HAVE +ANY OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS OR +MODIFICATIONS. + +IN NO EVENT SHALL ANY LICENSOR BE LIABLE TO ANY PARTY FOR DIRECT, +INDIRECT, SPECIAL OR CONSEQUENTIAL DAMAGES OR LOST PROFITS ARISING OUT +OF THE USE OF THIS SOFTWARE EVEN IF ADVISED OF THE POSSIBILITY OF SUCH +DAMAGE. + +EACH LICENSOR SPECIFICALLY DISCLAIMS ANY WARRANTIES, EXPRESS OR IMPLIED, +INCLUDING BUT NOT LIMITED TO ANY WARRANTY OF NONINFRINGEMENT OR THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. + +The software is provided with RESTRICTED RIGHTS. Use, duplication, or +disclosure by the government are subject to restrictions set forth in +DFARS 252.227-7013 or 48 CFR 52.227-19, as applicable. + +***************************************************************************/ + +#ifndef __PORT_H__ +#define __PORT_H__ 1 + +#if defined(__CPLUSPLUS__) || defined(__cplusplus) +extern "C" { +#endif + +#define vCardClipboardFormat "+//ISBN 1-887687-00-9::versit::PDI//vCard" +#define vCalendarClipboardFormat "+//ISBN 1-887687-00-9::versit::PDI//vCalendar" + +/* The above strings vCardClipboardFormat and vCalendarClipboardFormat +are globally unique IDs which can be used to generate clipboard format +ID's as per the requirements of a specific platform. For example, in +Windows they are used as the parameter in a call to RegisterClipboardFormat. +For example: + + CLIPFORMAT foo = RegisterClipboardFormat(vCardClipboardFormat); + +*/ + +#define vCardMimeType "text/x-vCard" +#define vCalendarMimeType "text/x-vCalendar" + +#ifndef FALSE +#define FALSE 0 +#endif +#ifndef TRUE +#define TRUE 1 +#endif + +#define Parse_Debug(t) + +#if defined(__CPLUSPLUS__) || defined(__cplusplus) +} +#endif + +#endif /* __PORT_H__ */ diff --git a/libkcal/versit/vcc.c b/libkcal/versit/vcc.c new file mode 100644 index 0000000..350cac3 --- a/dev/null +++ b/libkcal/versit/vcc.c @@ -0,0 +1,2162 @@ + +/* A Bison parser, made from ./vcc.y + by GNU Bison version 1.28 */ + +#define YYBISON 1 /* Identify Bison output. */ + +#ifdef _WIN32_ +#define strcasecmp _stricmp +#endif + +#define EQ 257 +#define COLON 258 +#define DOT 259 +#define SEMICOLON 260 +#define SPACE 261 +#define HTAB 262 +#define LINESEP 263 +#define NEWLINE 264 +#define BEGIN_VCARD 265 +#define END_VCARD 266 +#define BEGIN_VCAL 267 +#define END_VCAL 268 +#define BEGIN_VEVENT 269 +#define END_VEVENT 270 +#define BEGIN_VTODO 271 +#define END_VTODO 272 +#define ID 273 +#define STRING 274 + +#line 1 "./vcc.y" + + +/*************************************************************************** +(C) Copyright 1996 Apple Computer, Inc., AT&T Corp., International +Business Machines Corporation and Siemens Rolm Communications Inc. + +For purposes of this license notice, the term Licensors shall mean, +collectively, Apple Computer, Inc., AT&T Corp., International +Business Machines Corporation and Siemens Rolm Communications Inc. +The term Licensor shall mean any of the Licensors. + +Subject to acceptance of the following conditions, permission is hereby +granted by Licensors without the need for written agreement and without +license or royalty fees, to use, copy, modify and distribute this +software for any purpose. + +The above copyright notice and the following four paragraphs must be +reproduced in all copies of this software and any software including +this software. + +THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS AND NO LICENSOR SHALL HAVE +ANY OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS OR +MODIFICATIONS. + +IN NO EVENT SHALL ANY LICENSOR BE LIABLE TO ANY PARTY FOR DIRECT, +INDIRECT, SPECIAL OR CONSEQUENTIAL DAMAGES OR LOST PROFITS ARISING OUT +OF THE USE OF THIS SOFTWARE EVEN IF ADVISED OF THE POSSIBILITY OF SUCH +DAMAGE. + +EACH LICENSOR SPECIFICALLY DISCLAIMS ANY WARRANTIES, EXPRESS OR IMPLIED, +INCLUDING BUT NOT LIMITED TO ANY WARRANTY OF NONINFRINGEMENT OR THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. + +The software is provided with RESTRICTED RIGHTS. Use, duplication, or +disclosure by the government are subject to restrictions set forth in +DFARS 252.227-7013 or 48 CFR 52.227-19, as applicable. + +***************************************************************************/ + +/* + * src: vcc.c + * doc: Parser for vCard and vCalendar. Note that this code is + * generated by a yacc parser generator. Generally it should not + * be edited by hand. The real source is vcc.y. The #line directives + * can be commented out here to make it easier to trace through + * in a debugger. However, if a bug is found it should + * be fixed in vcc.y and this file regenerated. + */ + + +/* debugging utilities */ +#if __DEBUG +#define DBG_(x) printf x +#else +#define DBG_(x) +#endif + +/**** External Functions ****/ + +/* assign local name to parser variables and functions so that + we can use more than one yacc based parser. +*/ + +#define yyparse mime_parse +#define yylex mime_lex +#define yyerror mime_error +#define yychar mime_char +/* #define p_yyval p_mime_val */ +#undef yyval +#define yyval mime_yyval +/* #define p_yylval p_mime_lval */ +#undef yylval +#define yylval mime_yylval +#define yydebug mime_debug +#define yynerrs mime_nerrs +#define yyerrflag mime_errflag +#define yyss mime_ss +#define yyssp mime_ssp +#define yyvs mime_vs +#define yyvsp mime_vsp +#define yylhs mime_lhs +#define yylen mime_len +#define yydefred mime_defred +#define yydgoto mime_dgoto +#define yysindex mime_sindex +#define yyrindex mime_rindex +#define yygindex mime_gindex +#define yytable mime_table +#define yycheck mime_check +#define yyname mime_name +#define yyrule mime_rule +#undef YYPREFIX +#define YYPREFIX "mime_" + + +#ifndef _NO_LINE_FOLDING +#define _SUPPORT_LINE_FOLDING 1 +#endif + +#include +#ifndef __FreeBSD__ +#include +#endif +#include +#include +#include +#include "vcc.h" + +/* The following is a hack that I hope will get things compiling + * on SunOS 4.1.x systems + */ +#ifndef SEEK_SET +#define SEEK_SET 0 /* Seek from beginning of file. */ +#define SEEK_CUR 1 /* Seek from current position. */ +#define SEEK_END 2 /* Seek from end of file. */ +#endif + +/**** Types, Constants ****/ + +#define YYDEBUG 0 /* 1 to compile in some debugging code */ +#define MAXTOKEN 256 /* maximum token (line) length */ +#define YYSTACKSIZE 1000 /* ~unref ? */ +#define MAXLEVEL 10 /* max # of nested objects parseable */ + /* (includes outermost) */ + + +/**** Global Variables ****/ +int mime_lineNum, mime_numErrors; /* yyerror() can use these */ +static VObject* vObjList; +static VObject *curProp; +static VObject *curObj; +static VObject* ObjStack[MAXLEVEL]; +static int ObjStackTop; + + +/* A helpful utility for the rest of the app. */ +#if __CPLUSPLUS__ +extern "C" { +#endif + + /* static void Parse_Debug(const char *s);*/ + static void yyerror(char *s); + +#if __CPLUSPLUS__ + }; +#endif + +int yyparse(); +static int yylex(); +enum LexMode { + L_NORMAL, + L_VCARD, + L_VCAL, + L_VEVENT, + L_VTODO, + L_VALUES, + L_BASE64, + L_QUOTED_PRINTABLE + }; + +/**** Private Forward Declarations ****/ +static int pushVObject(const char *prop); +static VObject* popVObject(); +char* lexDataFromBase64(); +static void lexPopMode(int top); +static int lexWithinMode(enum LexMode mode); +static void lexPushMode(enum LexMode mode); +static void enterProps(const char *s); +static void enterAttr(const char *s1, const char *s2); +/* static void enterValues(const char *value); */ +static void appendValue(const char *value); +static void mime_error_(char *s); + + +#line 181 "./vcc.y" +typedef union { + char *str; + VObject *vobj; + } YYSTYPE; +#include + +#ifndef __cplusplus +#ifndef __STDC__ +#define const +#endif +#endif + + + +#define YYFINAL 62 +#define YYFLAG -32768 +#define YYNTBASE 21 + +#define YYTRANSLATE(x) ((unsigned)(x) <= 274 ? yytranslate[x] : 51) + +static const char yytranslate[] = { 0, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 1, 3, 4, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20 +}; + +#if YYDEBUG != 0 +static const short yyprhs[] = { 0, + 0, 2, 3, 7, 9, 11, 13, 14, 19, 20, + 24, 27, 29, 30, 36, 38, 39, 43, 45, 48, + 50, 53, 55, 59, 61, 62, 67, 69, 71, 72, + 73, 78, 79, 83, 86, 88, 90, 92, 94, 95, + 100, 101, 105, 106, 111, 112 +}; + +static const short yyrhs[] = { 22, + 0, 0, 24, 23, 22, 0, 24, 0, 25, 0, + 40, 0, 0, 11, 26, 28, 12, 0, 0, 11, + 27, 12, 0, 29, 28, 0, 29, 0, 0, 31, + 4, 30, 37, 9, 0, 1, 0, 0, 36, 32, + 33, 0, 36, 0, 34, 33, 0, 34, 0, 6, + 35, 0, 36, 0, 36, 3, 36, 0, 19, 0, + 0, 39, 6, 38, 37, 0, 39, 0, 20, 0, + 0, 0, 13, 41, 43, 14, 0, 0, 13, 42, + 14, 0, 44, 43, 0, 44, 0, 45, 0, 48, + 0, 28, 0, 0, 15, 46, 28, 16, 0, 0, + 15, 47, 16, 0, 0, 17, 49, 28, 18, 0, + 0, 17, 50, 18, 0 +}; + +#endif + +#if YYDEBUG != 0 +static const short yyrline[] = { 0, + 209, 212, 215, 215, 219, 220, 223, 229, 234, 240, + 246, 247, 250, 254, 260, 263, 268, 268, 274, 275, + 278, 281, 285, 292, 295, 296, 296, 300, 301, 305, + 309, 311, 314, 317, 318, 321, 323, 324, 327, 334, + 339, 345, 351, 358, 363, 369 +}; +#endif + + +#if YYDEBUG != 0 || defined (YYERROR_VERBOSE) + +static const char * const yytname[] = { "$","error","$undefined.","EQ","COLON", +"DOT","SEMICOLON","SPACE","HTAB","LINESEP","NEWLINE","BEGIN_VCARD","END_VCARD", +"BEGIN_VCAL","END_VCAL","BEGIN_VEVENT","END_VEVENT","BEGIN_VTODO","END_VTODO", +"ID","STRING","mime","vobjects","@1","vobject","vcard","@2","@3","items","item", +"@4","prop","@5","attr_params","attr_param","attr","name","values","@6","value", +"vcal","@7","@8","calitems","calitem","eventitem","@9","@10","todoitem","@11", +"@12", NULL +}; +#endif + +static const short yyr1[] = { 0, + 21, 23, 22, 22, 24, 24, 26, 25, 27, 25, + 28, 28, 30, 29, 29, 32, 31, 31, 33, 33, + 34, 35, 35, 36, 38, 37, 37, 39, 39, 41, + 40, 42, 40, 43, 43, 44, 44, 44, 46, 45, + 47, 45, 49, 48, 50, 48 +}; + +static const short yyr2[] = { 0, + 1, 0, 3, 1, 1, 1, 0, 4, 0, 3, + 2, 1, 0, 5, 1, 0, 3, 1, 2, 1, + 2, 1, 3, 1, 0, 4, 1, 1, 0, 0, + 4, 0, 3, 2, 1, 1, 1, 1, 0, 4, + 0, 3, 0, 4, 0, 3 +}; + +static const short yydefact[] = { 0, + 7, 30, 1, 2, 5, 6, 0, 0, 0, 0, + 0, 15, 24, 0, 0, 0, 16, 10, 39, 43, + 38, 0, 0, 36, 37, 33, 3, 8, 11, 13, + 0, 0, 0, 0, 0, 31, 34, 29, 0, 17, + 20, 0, 42, 0, 46, 28, 0, 27, 21, 22, + 19, 40, 44, 14, 25, 0, 29, 23, 26, 0, + 0, 0 +}; + +static const short yydefgoto[] = { 60, + 3, 11, 4, 5, 7, 8, 21, 15, 38, 16, + 31, 40, 41, 49, 17, 47, 57, 48, 6, 9, + 10, 22, 23, 24, 32, 33, 25, 34, 35 +}; + +static const short yypact[] = { -9, + -6, -5,-32768, 7,-32768,-32768, 2, -1, 19, 15, + -9,-32768,-32768, 1, 0, 26, 27,-32768, 16, 17, +-32768, 23, 9,-32768,-32768,-32768,-32768,-32768,-32768,-32768, + 33, 2, 24, 2, 25,-32768,-32768, 13, 22,-32768, + 33, 28,-32768, 29,-32768,-32768, 36, 40,-32768, 39, +-32768,-32768,-32768,-32768,-32768, 22, 13,-32768,-32768, 48, + 49,-32768 +}; + +static const short yypgoto[] = {-32768, + 41,-32768,-32768,-32768,-32768,-32768, -7,-32768,-32768,-32768, +-32768, 10,-32768,-32768, -34, -4,-32768,-32768,-32768,-32768, +-32768, 31,-32768,-32768,-32768,-32768,-32768,-32768,-32768 +}; + + +#define YYLAST 54 + + +static const short yytable[] = { 14, + 12, 1, 12, 2, 50, -9, -4, 29, -32, 12, + 18, -12, 28, -12, -12, -12, -12, -12, 13, 12, + 13, 58, -35, 19, 42, 20, 44, 13, 26, 30, + -18, -41, 46, 19, -45, 20, 36, 13, 39, 43, + 13, 56, 45, 52, 54, 55, 53, 61, 62, 0, + 51, 27, 59, 37 +}; + +static const short yycheck[] = { 7, + 1, 11, 1, 13, 39, 12, 0, 15, 14, 1, + 12, 12, 12, 14, 15, 16, 17, 18, 19, 1, + 19, 56, 14, 15, 32, 17, 34, 19, 14, 4, + 4, 16, 20, 15, 18, 17, 14, 19, 6, 16, + 19, 3, 18, 16, 9, 6, 18, 0, 0, -1, + 41, 11, 57, 23 +}; +/* -*-C-*- Note some compilers choke on comments on `#line' lines. */ +#line 3 "/usr/share/bison.simple" +/* This file comes from bison-1.28. */ + +/* Skeleton output parser for bison, + Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, or (at your option) + any later version. + + This program 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +/* As a special exception, when this file is copied by Bison into a + Bison output file, you may use that output file without restriction. + This special exception was added by the Free Software Foundation + in version 1.24 of Bison. */ + +/* This is the parser code that is written into each bison parser + when the %semantic_parser declaration is not specified in the grammar. + It was written by Richard Stallman by simplifying the hairy parser + used when %semantic_parser is specified. */ + +#ifndef YYSTACK_USE_ALLOCA +#ifdef alloca +#define YYSTACK_USE_ALLOCA +#else /* alloca not defined */ +#ifdef __GNUC__ +#define YYSTACK_USE_ALLOCA +#define alloca __builtin_alloca +#else /* not GNU C. */ +#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386)) +#define YYSTACK_USE_ALLOCA +#include +#else /* not sparc */ +/* We think this test detects Watcom and Microsoft C. */ +/* This used to test MSDOS, but that is a bad idea + since that symbol is in the user namespace. */ +#if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__) +#if 0 /* No need for malloc.h, which pollutes the namespace; + instead, just don't use alloca. */ +#include +#endif +#else /* not MSDOS, or __TURBOC__ */ +#if defined(_AIX) +/* I don't know what this was needed for, but it pollutes the namespace. + So I turned it off. rms, 2 May 1997. */ +/* #include */ + #pragma alloca +#define YYSTACK_USE_ALLOCA +#else /* not MSDOS, or __TURBOC__, or _AIX */ +#if 0 +#ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up, + and on HPUX 10. Eventually we can turn this on. */ +#define YYSTACK_USE_ALLOCA +#define alloca __builtin_alloca +#endif /* __hpux */ +#endif +#endif /* not _AIX */ +#endif /* not MSDOS, or __TURBOC__ */ +#endif /* not sparc */ +#endif /* not GNU C */ +#endif /* alloca not defined */ +#endif /* YYSTACK_USE_ALLOCA not defined */ + +#ifdef YYSTACK_USE_ALLOCA +#define YYSTACK_ALLOC alloca +#else +#define YYSTACK_ALLOC malloc +#endif + +/* Note: there must be only one dollar sign in this file. + It is replaced by the list of actions, each action + as one case of the switch. */ + +#define yyerrok (yyerrstatus = 0) +#define yyclearin (yychar = YYEMPTY) +#define YYEMPTY -2 +#define YYEOF 0 +#define YYACCEPT goto yyacceptlab +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrlab1 +/* Like YYERROR except do call yyerror. + This remains here temporarily to ease the + transition to the new meaning of YYERROR, for GCC. + Once GCC version 2 has supplanted version 1, this can go. */ +#define YYFAIL goto yyerrlab +#define YYRECOVERING() (!!yyerrstatus) +#define YYBACKUP(token, value) \ +do \ + if (yychar == YYEMPTY && yylen == 1) \ + { yychar = (token), yylval = (value); \ + yychar1 = YYTRANSLATE (yychar); \ + YYPOPSTACK; \ + goto yybackup; \ + } \ + else \ + { yyerror ("syntax error: cannot back up"); YYERROR; } \ +while (0) + +#define YYTERROR 1 +#define YYERRCODE 256 + +#ifndef YYPURE +#define YYLEX yylex() +#endif + +#ifdef YYPURE +#ifdef YYLSP_NEEDED +#ifdef YYLEX_PARAM +#define YYLEX yylex(&yylval, &yylloc, YYLEX_PARAM) +#else +#define YYLEX yylex(&yylval, &yylloc) +#endif +#else /* not YYLSP_NEEDED */ +#ifdef YYLEX_PARAM +#define YYLEX yylex(&yylval, YYLEX_PARAM) +#else +#define YYLEX yylex(&yylval) +#endif +#endif /* not YYLSP_NEEDED */ +#endif + +/* If nonreentrant, generate the variables here */ + +#ifndef YYPURE + +int yychar; /* the lookahead symbol */ +YYSTYPE yylval; /* the semantic value of the */ + /* lookahead symbol */ + +#ifdef YYLSP_NEEDED +YYLTYPE yylloc; /* location data for the lookahead */ + /* symbol */ +#endif + +int yynerrs; /* number of parse errors so far */ +#endif /* not YYPURE */ + +#if YYDEBUG != 0 +int yydebug; /* nonzero means print parse trace */ +/* Since this is uninitialized, it does not stop multiple parsers + from coexisting. */ +#endif + +/* YYINITDEPTH indicates the initial size of the parser's stacks */ + +#ifndef YYINITDEPTH +#define YYINITDEPTH 200 +#endif + +/* YYMAXDEPTH is the maximum size the stacks can grow to + (effective only if the built-in stack extension method is used). */ + +#if YYMAXDEPTH == 0 +#undef YYMAXDEPTH +#endif + +#ifndef YYMAXDEPTH +#define YYMAXDEPTH 10000 +#endif + +/* Define __yy_memcpy. Note that the size argument + should be passed with type unsigned int, because that is what the non-GCC + definitions require. With GCC, __builtin_memcpy takes an arg + of type size_t, but it can handle unsigned int. */ + +#if __GNUC__ > 1 /* GNU C and GNU C++ define this. */ +#define __yy_memcpy(TO,FROM,COUNT) __builtin_memcpy(TO,FROM,COUNT) +#else /* not GNU C or C++ */ +#ifndef __cplusplus + +/* This is the most reliable way to avoid incompatibilities + in available built-in functions on various systems. */ +static void +__yy_memcpy (to, from, count) + char *to; + char *from; + unsigned int count; +{ + register char *f = from; + register char *t = to; + register int i = count; + + while (i-- > 0) + *t++ = *f++; +} + +#else /* __cplusplus */ + +/* This is the most reliable way to avoid incompatibilities + in available built-in functions on various systems. */ +static void +__yy_memcpy (char *to, char *from, unsigned int count) +{ + register char *t = to; + register char *f = from; + register int i = count; + + while (i-- > 0) + *t++ = *f++; +} + +#endif +#endif + +#line 217 "/usr/share/bison.simple" + +/* The user can define YYPARSE_PARAM as the name of an argument to be passed + into yyparse. The argument should have type void *. + It should actually point to an object. + Grammar actions can access the variable by casting it + to the proper pointer type. */ + +#ifdef YYPARSE_PARAM +#ifdef __cplusplus +#define YYPARSE_PARAM_ARG void *YYPARSE_PARAM +#define YYPARSE_PARAM_DECL +#else /* not __cplusplus */ +#define YYPARSE_PARAM_ARG YYPARSE_PARAM +#define YYPARSE_PARAM_DECL void *YYPARSE_PARAM; +#endif /* not __cplusplus */ +#else /* not YYPARSE_PARAM */ +#define YYPARSE_PARAM_ARG +#define YYPARSE_PARAM_DECL +#endif /* not YYPARSE_PARAM */ + +/* Prevent warning if -Wstrict-prototypes. */ +#if defined (__GNUC__) && ! defined (__cplusplus) +#ifdef YYPARSE_PARAM +int yyparse (void *); +#else +int yyparse (void); +#endif +#endif + +int +yyparse(YYPARSE_PARAM_ARG) + YYPARSE_PARAM_DECL +{ + register int yystate; + register int yyn; + register short *yyssp; + register YYSTYPE *yyvsp; + int yyerrstatus; /* number of tokens to shift before error messages enabled */ + int yychar1 = 0; /* lookahead token as an internal (translated) token number */ + + short yyssa[YYINITDEPTH]; /* the state stack */ + YYSTYPE yyvsa[YYINITDEPTH]; /* the semantic value stack */ + + short *yyss = yyssa; /* refer to the stacks thru separate pointers */ + YYSTYPE *yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */ + +#ifdef YYLSP_NEEDED + YYLTYPE yylsa[YYINITDEPTH]; /* the location stack */ + YYLTYPE *yyls = yylsa; + YYLTYPE *yylsp; + +#define YYPOPSTACK (yyvsp--, yyssp--, yylsp--) +#else +#define YYPOPSTACK (yyvsp--, yyssp--) +#endif + + int yystacksize = YYINITDEPTH; + int yyfree_stacks = 0; + +#ifdef YYPURE + int yychar; + YYSTYPE yylval; + int yynerrs; +#ifdef YYLSP_NEEDED + YYLTYPE yylloc; +#endif +#endif + + YYSTYPE yyval; /* the variable used to return */ + /* semantic values from the action */ + /* routines */ + + int yylen; + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Starting parse\n"); +#endif + + yystate = 0; + yyerrstatus = 0; + yynerrs = 0; + yychar = YYEMPTY; /* Cause a token to be read. */ + + /* Initialize stack pointers. + Waste one element of value and location stack + so that they stay on the same level as the state stack. + The wasted elements are never initialized. */ + + yyssp = yyss - 1; + yyvsp = yyvs; +#ifdef YYLSP_NEEDED + yylsp = yyls; +#endif + +/* Push a new state, which is found in yystate . */ +/* In all cases, when you get here, the value and location stacks + have just been pushed. so pushing a state here evens the stacks. */ +yynewstate: + + *++yyssp = yystate; + + if (yyssp >= yyss + yystacksize - 1) + { + /* Give user a chance to reallocate the stack */ + /* Use copies of these so that the &'s don't force the real ones into memory. */ + YYSTYPE *yyvs1 = yyvs; + short *yyss1 = yyss; +#ifdef YYLSP_NEEDED + YYLTYPE *yyls1 = yyls; +#endif + + /* Get the current used size of the three stacks, in elements. */ + int size = yyssp - yyss + 1; + +#ifdef yyoverflow + /* Each stack pointer address is followed by the size of + the data in use in that stack, in bytes. */ +#ifdef YYLSP_NEEDED + /* This used to be a conditional around just the two extra args, + but that might be undefined if yyoverflow is a macro. */ + yyoverflow("parser stack overflow", + &yyss1, size * sizeof (*yyssp), + &yyvs1, size * sizeof (*yyvsp), + &yyls1, size * sizeof (*yylsp), + &yystacksize); +#else + yyoverflow("parser stack overflow", + &yyss1, size * sizeof (*yyssp), + &yyvs1, size * sizeof (*yyvsp), + &yystacksize); +#endif + + yyss = yyss1; yyvs = yyvs1; +#ifdef YYLSP_NEEDED + yyls = yyls1; +#endif +#else /* no yyoverflow */ + /* Extend the stack our own way. */ + if (yystacksize >= YYMAXDEPTH) + { + yyerror("parser stack overflow"); + if (yyfree_stacks) + { + free (yyss); + free (yyvs); +#ifdef YYLSP_NEEDED + free (yyls); +#endif + } + return 2; + } + yystacksize *= 2; + if (yystacksize > YYMAXDEPTH) + yystacksize = YYMAXDEPTH; +#ifndef YYSTACK_USE_ALLOCA + yyfree_stacks = 1; +#endif + yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp)); + __yy_memcpy ((char *)yyss, (char *)yyss1, + size * (unsigned int) sizeof (*yyssp)); + yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp)); + __yy_memcpy ((char *)yyvs, (char *)yyvs1, + size * (unsigned int) sizeof (*yyvsp)); +#ifdef YYLSP_NEEDED + yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp)); + __yy_memcpy ((char *)yyls, (char *)yyls1, + size * (unsigned int) sizeof (*yylsp)); +#endif +#endif /* no yyoverflow */ + + yyssp = yyss + size - 1; + yyvsp = yyvs + size - 1; +#ifdef YYLSP_NEEDED + yylsp = yyls + size - 1; +#endif + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Stack size increased to %d\n", yystacksize); +#endif + + if (yyssp >= yyss + yystacksize - 1) + YYABORT; + } + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Entering state %d\n", yystate); +#endif + + goto yybackup; + yybackup: + +/* Do appropriate processing given the current state. */ +/* Read a lookahead token if we need one and don't already have one. */ +/* yyresume: */ + + /* First try to decide what to do without reference to lookahead token. */ + + yyn = yypact[yystate]; + if (yyn == YYFLAG) + goto yydefault; + + /* Not known => get a lookahead token if don't already have one. */ + + /* yychar is either YYEMPTY or YYEOF + or a valid token in external form. */ + + if (yychar == YYEMPTY) + { +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Reading a token: "); +#endif + yychar = YYLEX; + } + + /* Convert token to internal form (in yychar1) for indexing tables with */ + + if (yychar <= 0) /* This means end of input. */ + { + yychar1 = 0; + yychar = YYEOF; /* Don't call YYLEX any more */ + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Now at end of input.\n"); +#endif + } + else + { + yychar1 = YYTRANSLATE(yychar); + +#if YYDEBUG != 0 + if (yydebug) + { + fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]); + /* Give the individual parser a way to print the precise meaning + of a token, for further debugging info. */ +#ifdef YYPRINT + YYPRINT (stderr, yychar, yylval); +#endif + fprintf (stderr, ")\n"); + } +#endif + } + + yyn += yychar1; + if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1) + goto yydefault; + + yyn = yytable[yyn]; + + /* yyn is what to do for this token type in this state. + Negative => reduce, -yyn is rule number. + Positive => shift, yyn is new state. + New state is final state => don't bother to shift, + just return success. + 0, or most negative number => error. */ + + if (yyn < 0) + { + if (yyn == YYFLAG) + goto yyerrlab; + yyn = -yyn; + goto yyreduce; + } + else if (yyn == 0) + goto yyerrlab; + + if (yyn == YYFINAL) + YYACCEPT; + + /* Shift the lookahead token. */ + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]); +#endif + + /* Discard the token being shifted unless it is eof. */ + if (yychar != YYEOF) + yychar = YYEMPTY; + + *++yyvsp = yylval; +#ifdef YYLSP_NEEDED + *++yylsp = yylloc; +#endif + + /* count tokens shifted since error; after three, turn off error status. */ + if (yyerrstatus) yyerrstatus--; + + yystate = yyn; + goto yynewstate; + +/* Do the default action for the current state. */ +yydefault: + + yyn = yydefact[yystate]; + if (yyn == 0) + goto yyerrlab; + +/* Do a reduction. yyn is the number of a rule to reduce with. */ +yyreduce: + yylen = yyr2[yyn]; + if (yylen > 0) + yyval = yyvsp[1-yylen]; /* implement default value of the action */ + +#if YYDEBUG != 0 + if (yydebug) + { + int i; + + fprintf (stderr, "Reducing via rule %d (line %d), ", + yyn, yyrline[yyn]); + + /* Print the symbols being reduced, and their result. */ + for (i = yyprhs[yyn]; yyrhs[i] > 0; i++) + fprintf (stderr, "%s ", yytname[yyrhs[i]]); + fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]); + } +#endif + + + switch (yyn) { + +case 2: +#line 213 "./vcc.y" +{ addList(&vObjList, yyvsp[0].vobj); curObj = 0; ; + break;} +case 4: +#line 216 "./vcc.y" +{ addList(&vObjList, yyvsp[0].vobj); curObj = 0; ; + break;} +case 7: +#line 225 "./vcc.y" +{ + lexPushMode(L_VCARD); + if (!pushVObject(VCCardProp)) YYERROR; + ; + break;} +case 8: +#line 230 "./vcc.y" +{ + lexPopMode(0); + yyval.vobj = popVObject(); + ; + break;} +case 9: +#line 235 "./vcc.y" +{ + lexPushMode(L_VCARD); + if (!pushVObject(VCCardProp)) YYERROR; + ; + break;} +case 10: +#line 240 "./vcc.y" +{ + lexPopMode(0); + yyval.vobj = popVObject(); + ; + break;} +case 13: +#line 251 "./vcc.y" +{ + lexPushMode(L_VALUES); + ; + break;} +case 14: +#line 255 "./vcc.y" +{ + if (lexWithinMode(L_BASE64) || lexWithinMode(L_QUOTED_PRINTABLE)) + lexPopMode(0); + lexPopMode(0); + ; + break;} +case 16: +#line 264 "./vcc.y" +{ + enterProps(yyvsp[0].str); + ; + break;} +case 18: +#line 269 "./vcc.y" +{ + enterProps(yyvsp[0].str); + ; + break;} +case 22: +#line 282 "./vcc.y" +{ + enterAttr(yyvsp[0].str,0); + ; + break;} +case 23: +#line 286 "./vcc.y" +{ + enterAttr(yyvsp[-2].str,yyvsp[0].str); + + ; + break;} +case 25: +#line 295 "./vcc.y" +{ appendValue(yyvsp[-1].str); ; + break;} +case 27: +#line 297 "./vcc.y" +{ appendValue(yyvsp[0].str); ; + break;} +case 29: +#line 302 "./vcc.y" +{ yyval.str = 0; ; + break;} +case 30: +#line 307 "./vcc.y" +{ if (!pushVObject(VCCalProp)) YYERROR; ; + break;} +case 31: +#line 310 "./vcc.y" +{ yyval.vobj = popVObject(); ; + break;} +case 32: +#line 312 "./vcc.y" +{ if (!pushVObject(VCCalProp)) YYERROR; ; + break;} +case 33: +#line 314 "./vcc.y" +{ yyval.vobj = popVObject(); ; + break;} +case 39: +#line 329 "./vcc.y" +{ + lexPushMode(L_VEVENT); + if (!pushVObject(VCEventProp)) YYERROR; + ; + break;} +case 40: +#line 335 "./vcc.y" +{ + lexPopMode(0); + popVObject(); + ; + break;} +case 41: +#line 340 "./vcc.y" +{ + lexPushMode(L_VEVENT); + if (!pushVObject(VCEventProp)) YYERROR; + ; + break;} +case 42: +#line 345 "./vcc.y" +{ + lexPopMode(0); + popVObject(); + ; + break;} +case 43: +#line 353 "./vcc.y" +{ + lexPushMode(L_VTODO); + if (!pushVObject(VCTodoProp)) YYERROR; + ; + break;} +case 44: +#line 359 "./vcc.y" +{ + lexPopMode(0); + popVObject(); + ; + break;} +case 45: +#line 364 "./vcc.y" +{ + lexPushMode(L_VTODO); + if (!pushVObject(VCTodoProp)) YYERROR; + ; + break;} +case 46: +#line 369 "./vcc.y" +{ + lexPopMode(0); + popVObject(); + ; + break;} +} + /* the action file gets copied in in place of this dollarsign */ +#line 543 "/usr/share/bison.simple" + + yyvsp -= yylen; + yyssp -= yylen; +#ifdef YYLSP_NEEDED + yylsp -= yylen; +#endif + +#if YYDEBUG != 0 + if (yydebug) + { + short *ssp1 = yyss - 1; + fprintf (stderr, "state stack now"); + while (ssp1 != yyssp) + fprintf (stderr, " %d", *++ssp1); + fprintf (stderr, "\n"); + } +#endif + + *++yyvsp = yyval; + +#ifdef YYLSP_NEEDED + yylsp++; + if (yylen == 0) + { + yylsp->first_line = yylloc.first_line; + yylsp->first_column = yylloc.first_column; + yylsp->last_line = (yylsp-1)->last_line; + yylsp->last_column = (yylsp-1)->last_column; + yylsp->text = 0; + } + else + { + yylsp->last_line = (yylsp+yylen-1)->last_line; + yylsp->last_column = (yylsp+yylen-1)->last_column; + } +#endif + + /* Now "shift" the result of the reduction. + Determine what state that goes to, + based on the state we popped back to + and the rule number reduced by. */ + + yyn = yyr1[yyn]; + + yystate = yypgoto[yyn - YYNTBASE] + *yyssp; + if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp) + yystate = yytable[yystate]; + else + yystate = yydefgoto[yyn - YYNTBASE]; + + goto yynewstate; + +yyerrlab: /* here on detecting error */ + + if (! yyerrstatus) + /* If not already recovering from an error, report this error. */ + { + ++yynerrs; + +#ifdef YYERROR_VERBOSE + yyn = yypact[yystate]; + + if (yyn > YYFLAG && yyn < YYLAST) + { + int size = 0; + char *msg; + int x, count; + + count = 0; + /* Start X at -yyn if nec to avoid negative indexes in yycheck. */ + for (x = (yyn < 0 ? -yyn : 0); + x < (sizeof(yytname) / sizeof(char *)); x++) + if (yycheck[x + yyn] == x) + size += strlen(yytname[x]) + 15, count++; + msg = (char *) malloc(size + 15); + if (msg != 0) + { + strcpy(msg, "parse error"); + + if (count < 5) + { + count = 0; + for (x = (yyn < 0 ? -yyn : 0); + x < (sizeof(yytname) / sizeof(char *)); x++) + if (yycheck[x + yyn] == x) + { + strcat(msg, count == 0 ? ", expecting `" : " or `"); + strcat(msg, yytname[x]); + strcat(msg, "'"); + count++; + } + } + yyerror(msg); + free(msg); + } + else + yyerror ("parse error; also virtual memory exceeded"); + } + else +#endif /* YYERROR_VERBOSE */ + yyerror("parse error"); + } + + goto yyerrlab1; +yyerrlab1: /* here on error raised explicitly by an action */ + + if (yyerrstatus == 3) + { + /* if just tried and failed to reuse lookahead token after an error, discard it. */ + + /* return failure if at end of input */ + if (yychar == YYEOF) + YYABORT; + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]); +#endif + + yychar = YYEMPTY; + } + + /* Else will try to reuse lookahead token + after shifting the error token. */ + + yyerrstatus = 3; /* Each real token shifted decrements this */ + + goto yyerrhandle; + +yyerrdefault: /* current state does not do anything special for the error token. */ + +#if 0 + /* This is wrong; only states that explicitly want error tokens + should shift them. */ + yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/ + if (yyn) goto yydefault; +#endif + +yyerrpop: /* pop the current state because it cannot handle the error token */ + + if (yyssp == yyss) YYABORT; + yyvsp--; + yystate = *--yyssp; +#ifdef YYLSP_NEEDED + yylsp--; +#endif + +#if YYDEBUG != 0 + if (yydebug) + { + short *ssp1 = yyss - 1; + fprintf (stderr, "Error: state stack now"); + while (ssp1 != yyssp) + fprintf (stderr, " %d", *++ssp1); + fprintf (stderr, "\n"); + } +#endif + +yyerrhandle: + + yyn = yypact[yystate]; + if (yyn == YYFLAG) + goto yyerrdefault; + + yyn += YYTERROR; + if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR) + goto yyerrdefault; + + yyn = yytable[yyn]; + if (yyn < 0) + { + if (yyn == YYFLAG) + goto yyerrpop; + yyn = -yyn; + goto yyreduce; + } + else if (yyn == 0) + goto yyerrpop; + + if (yyn == YYFINAL) + YYACCEPT; + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Shifting error token, "); +#endif + + *++yyvsp = yylval; +#ifdef YYLSP_NEEDED + *++yylsp = yylloc; +#endif + + yystate = yyn; + goto yynewstate; + + yyacceptlab: + /* YYACCEPT comes here. */ + if (yyfree_stacks) + { + free (yyss); + free (yyvs); +#ifdef YYLSP_NEEDED + free (yyls); +#endif + } + return 0; + + yyabortlab: + /* YYABORT comes here. */ + if (yyfree_stacks) + { + free (yyss); + free (yyvs); +#ifdef YYLSP_NEEDED + free (yyls); +#endif + } + return 1; +} +#line 375 "./vcc.y" + +/****************************************************************************/ +static int pushVObject(const char *prop) + { + VObject *newObj; + if (ObjStackTop == MAXLEVEL) + return FALSE; + + ObjStack[++ObjStackTop] = curObj; + + if (curObj) { + newObj = addProp(curObj,prop); + curObj = newObj; + } + else + curObj = newVObject(prop); + + return TRUE; + } + + +/****************************************************************************/ +/* This pops the recently built vCard off the stack and returns it. */ +static VObject* popVObject() + { + VObject *oldObj; + if (ObjStackTop < 0) { + yyerror("pop on empty Object Stack\n"); + return 0; + } + oldObj = curObj; + curObj = ObjStack[ObjStackTop--]; + + return oldObj; + } + + +/* static void enterValues(const char *value) */ +/* { */ +/* if (fieldedProp && *fieldedProp) { */ +/* if (value) { */ +/* addPropValue(curProp,*fieldedProp,value); */ +/* } */ + /* else this field is empty, advance to next field */ +/* fieldedProp++; */ +/* } */ +/* else { */ +/* if (value) { */ +/* setVObjectUStringZValue_(curProp,fakeUnicode(value,0)); */ +/* } */ +/* } */ +/* deleteStr(value); */ +/* } */ + +static void appendValue(const char *value) +{ + char *p1, *p2; + wchar_t *p3; + int i; + + if (fieldedProp && *fieldedProp) { + if (value) { + addPropValue(curProp, *fieldedProp, value); + } + /* else this field is empty, advance to next field */ + fieldedProp++; + } else { + if (value) { + if (vObjectUStringZValue(curProp)) { + p1 = fakeCString(vObjectUStringZValue(curProp)); + p2 = malloc(sizeof(char *) * (strlen(p1)+strlen(value)+1)); + strcpy(p2, p1); + deleteStr(p1); + + i = strlen(p2); + p2[i] = ','; + p2[i+1] = '\0'; + p2 = strcat(p2, value); + p3 = (wchar_t *) vObjectUStringZValue(curProp); + free(p3); + setVObjectUStringZValue_(curProp,fakeUnicode(p2,0)); + deleteStr(p2); + } else { + setVObjectUStringZValue_(curProp,fakeUnicode(value,0)); + } + } + } + deleteStr(value); +} + + +static void enterProps(const char *s) + { + curProp = addGroup(curObj,s); + deleteStr(s); + } + +static void enterAttr(const char *s1, const char *s2) + { + const char *p1=0L, *p2=0L; + p1 = lookupProp_(s1); + if (s2) { + VObject *a; + p2 = lookupProp_(s2); + a = addProp(curProp,p1); + setVObjectStringZValue(a,p2); + } + else + addProp(curProp,p1); + if (strcasecmp(p1,VCBase64Prop) == 0 || (s2 && strcasecmp(p2,VCBase64Prop)==0)) + lexPushMode(L_BASE64); + else if (strcasecmp(p1,VCQuotedPrintableProp) == 0 + || (s2 && strcasecmp(p2,VCQuotedPrintableProp)==0)) + lexPushMode(L_QUOTED_PRINTABLE); + deleteStr(s1); deleteStr(s2); + } + + +#define MAX_LEX_LOOKAHEAD_0 32 +#define MAX_LEX_LOOKAHEAD 64 +#define MAX_LEX_MODE_STACK_SIZE 10 +#define LEXMODE() (lexBuf.lexModeStack[lexBuf.lexModeStackTop]) + +struct LexBuf { + /* input */ + FILE *inputFile; + char *inputString; + unsigned long curPos; + unsigned long inputLen; + /* lookahead buffer */ + /* -- lookahead buffer is short instead of char so that EOF + / can be represented correctly. + */ + unsigned long len; + short buf[MAX_LEX_LOOKAHEAD]; + unsigned long getPtr; + /* context stack */ + unsigned long lexModeStackTop; + enum LexMode lexModeStack[MAX_LEX_MODE_STACK_SIZE]; + /* token buffer */ + unsigned long maxToken; + char *strs; + unsigned long strsLen; + } lexBuf; + +static void lexPushMode(enum LexMode mode) + { + if (lexBuf.lexModeStackTop == (MAX_LEX_MODE_STACK_SIZE-1)) + yyerror("lexical context stack overflow"); + else { + lexBuf.lexModeStack[++lexBuf.lexModeStackTop] = mode; + } + } + +static void lexPopMode(int top) + { + /* special case of pop for ease of error recovery -- this + version will never underflow */ + if (top) + lexBuf.lexModeStackTop = 0; + else + if (lexBuf.lexModeStackTop > 0) lexBuf.lexModeStackTop--; + } + +static int lexWithinMode(enum LexMode mode) { + unsigned long i; + for (i=0;i 0 && lexBuf.buf[lexBuf.getPtr]!=EOF) { + /* don't skip EOF. */ + lexBuf.getPtr = (lexBuf.getPtr + 1) % MAX_LEX_LOOKAHEAD; + lexBuf.len--; + } + } + +static int lexLookahead() { + int c = (lexBuf.len)? + lexBuf.buf[lexBuf.getPtr]: + lexGeta(); + /* do the \r\n -> \n or \r -> \n translation here */ + if (c == '\r') { + int a = (lexBuf.len>1)? + lexBuf.buf[(lexBuf.getPtr+1)%MAX_LEX_LOOKAHEAD]: + lexGeta_(1); + if (a == '\n') { + lexSkipLookahead(); + } + lexBuf.buf[lexBuf.getPtr] = c = '\n'; + } + else if (c == '\n') { + int a; + if (lexBuf.len > 1) + a = lexBuf.buf[lexBuf.getPtr]; + else + a = lexGeta_(1); + if (a == '\r') { + lexSkipLookahead(); + } + lexBuf.buf[lexBuf.getPtr] = '\n'; + } + return c; + } + +static int lexGetc() { + int c = lexLookahead(); + if (lexBuf.len > 0 && lexBuf.buf[lexBuf.getPtr]!=EOF) { + /* EOF will remain in lookahead buffer */ + lexBuf.getPtr = (lexBuf.getPtr + 1) % MAX_LEX_LOOKAHEAD; + lexBuf.len--; + } + return c; + } + +static void lexSkipLookaheadWord() { + if (lexBuf.strsLen <= lexBuf.len) { + lexBuf.len -= lexBuf.strsLen; + lexBuf.getPtr = (lexBuf.getPtr + lexBuf.strsLen) % MAX_LEX_LOOKAHEAD; + } + } + +static void lexClearToken() + { + lexBuf.strsLen = 0; + } + +static void lexAppendc(int c) + { + /* not sure if I am doing this right to fix purify report -- PGB */ + lexBuf.strs = (char *) realloc(lexBuf.strs, (size_t) lexBuf.strsLen + 1); + lexBuf.strs[lexBuf.strsLen] = c; + /* append up to zero termination */ + if (c == 0) return; + lexBuf.strsLen++; + if (lexBuf.strsLen > lexBuf.maxToken) { + /* double the token string size */ + lexBuf.maxToken <<= 1; + lexBuf.strs = (char*) realloc(lexBuf.strs,(size_t)lexBuf.maxToken); + } + } + +static char* lexStr() { + return dupStr(lexBuf.strs,(size_t)lexBuf.strsLen+1); + } + +static void lexSkipWhite() { + int c = lexLookahead(); + while (c == ' ' || c == '\t') { + lexSkipLookahead(); + c = lexLookahead(); + } + } + +static char* lexGetWord() { + int c; + lexSkipWhite(); + lexClearToken(); + c = lexLookahead(); + /* some "words" have a space in them, like "NEEDS ACTION". + this may be an oversight of the spec, but it is true nevertheless. + while (c != EOF && !strchr("\t\n ;:=",c)) { */ + while (c != EOF && !strchr("\n;:=",c)) { + lexAppendc(c); + lexSkipLookahead(); + c = lexLookahead(); + } + lexAppendc(0); + return lexStr(); + } + +void lexPushLookahead(char *s, int len) { + int putptr; + if (len == 0) len = strlen(s); + putptr = (int)lexBuf.getPtr - len; + /* this function assumes that length of word to push back + / is not greater than MAX_LEX_LOOKAHEAD. + */ + if (putptr < 0) putptr += MAX_LEX_LOOKAHEAD; + lexBuf.getPtr = putptr; + while (*s) { + lexBuf.buf[putptr] = *s++; + putptr = (putptr + 1) % MAX_LEX_LOOKAHEAD; + } + lexBuf.len += len; + } + +static void lexPushLookaheadc(int c) { + int putptr; + /* can't putback EOF, because it never leaves lookahead buffer */ + if (c == EOF) return; + putptr = (int)lexBuf.getPtr - 1; + if (putptr < 0) putptr += MAX_LEX_LOOKAHEAD; + lexBuf.getPtr = putptr; + lexBuf.buf[putptr] = c; + lexBuf.len += 1; + } + +static char* lexLookaheadWord() { + /* this function can lookahead word with max size of MAX_LEX_LOOKAHEAD_0 + / and thing bigger than that will stop the lookahead and return 0; + / leading white spaces are not recoverable. + */ + int c; + int len = 0; + int curgetptr = 0; + lexSkipWhite(); + lexClearToken(); + curgetptr = (int)lexBuf.getPtr; /* remember! */ + while (len < (MAX_LEX_LOOKAHEAD_0)) { + c = lexGetc(); + len++; + if (c == EOF || strchr("\t\n ;:=", c)) { + lexAppendc(0); + /* restore lookahead buf. */ + lexBuf.len += len; + lexBuf.getPtr = curgetptr; + return lexStr(); + } + else + lexAppendc(c); + } + lexBuf.len += len; /* char that has been moved to lookahead buffer */ + lexBuf.getPtr = curgetptr; + return 0; + } + +#ifdef _SUPPORT_LINE_FOLDING +static void handleMoreRFC822LineBreak(int c) { + /* suport RFC 822 line break in cases like + * ADR: foo; + * morefoo; + * more foo; + */ + if (c == ';') { + int a; + lexSkipLookahead(); + /* skip white spaces */ + a = lexLookahead(); + while (a == ' ' || a == '\t') { + lexSkipLookahead(); + a = lexLookahead(); + } + if (a == '\n') { + lexSkipLookahead(); + a = lexLookahead(); + if (a == ' ' || a == '\t') { + /* continuation, throw away all the \n and spaces read so + * far + */ + lexSkipWhite(); + lexPushLookaheadc(';'); + } + else { + lexPushLookaheadc('\n'); + lexPushLookaheadc(';'); + } + } + else { + lexPushLookaheadc(';'); + } + } + } + +static char* lexGet1Value() { + int c; + lexSkipWhite(); + c = lexLookahead(); + lexClearToken(); + while (c != EOF && c != ';') { + if (c == '\n') { + int a; + lexSkipLookahead(); + a = lexLookahead(); + if (a == ' ' || a == '\t') { + lexAppendc(' '); + lexSkipLookahead(); + } + else { + lexPushLookaheadc('\n'); + break; + } + } + else { + lexAppendc(c); + lexSkipLookahead(); + } + c = lexLookahead(); + } + lexAppendc(0); + handleMoreRFC822LineBreak(c); + return c==EOF?0:lexStr(); + } +#endif + +char* lexGetStrUntil(char *termset) { + int c = lexLookahead(); + lexClearToken(); + while (c != EOF && !strchr(termset,c)) { + lexAppendc(c); + lexSkipLookahead(); + c = lexLookahead(); + } + lexAppendc(0); + return c==EOF?0:lexStr(); + } + +static int match_begin_name(int end) { + char *n = lexLookaheadWord(); + int token = ID; + if (n) { + if (!strcasecmp(n,"vcard")) token = end?END_VCARD:BEGIN_VCARD; + else if (!strcasecmp(n,"vcalendar")) token = end?END_VCAL:BEGIN_VCAL; + else if (!strcasecmp(n,"vevent")) token = end?END_VEVENT:BEGIN_VEVENT; + else if (!strcasecmp(n,"vtodo")) token = end?END_VTODO:BEGIN_VTODO; + deleteStr(n); + return token; + } + return 0; + } + + +void initLex(const char *inputstring, unsigned long inputlen, FILE *inputfile) + { + /* initialize lex mode stack */ + lexBuf.lexModeStack[lexBuf.lexModeStackTop=0] = L_NORMAL; + + /* iniatialize lex buffer. */ + lexBuf.inputString = (char*) inputstring; + lexBuf.inputLen = inputlen; + lexBuf.curPos = 0; + lexBuf.inputFile = inputfile; + + lexBuf.len = 0; + lexBuf.getPtr = 0; + + lexBuf.maxToken = MAXTOKEN; + lexBuf.strs = (char*)malloc(MAXTOKEN); + lexBuf.strsLen = 0; + + } + +static void finiLex() { + free(lexBuf.strs); + } + + +/****************************************************************************/ +/* This parses and converts the base64 format for binary encoding into + * a decoded buffer (allocated with new). See RFC 1521. + */ +static char * lexGetDataFromBase64() + { + unsigned long bytesLen = 0, bytesMax = 0; + int quadIx = 0, pad = 0; + unsigned long trip = 0; + unsigned char b; + int c; + unsigned char *bytes = NULL; + unsigned char *oldBytes = NULL; + + DBG_(("db: lexGetDataFromBase64\n")); + while (1) { + c = lexGetc(); + if (c == '\n') { + ++mime_lineNum; + if (lexLookahead() == '\n') { + /* a '\n' character by itself means end of data */ + break; + } + else continue; /* ignore '\n' */ + } + else { + if ((c >= 'A') && (c <= 'Z')) + b = (unsigned char)(c - 'A'); + else if ((c >= 'a') && (c <= 'z')) + b = (unsigned char)(c - 'a') + 26; + else if ((c >= '0') && (c <= '9')) + b = (unsigned char)(c - '0') + 52; + else if (c == '+') + b = 62; + else if (c == '/') + b = 63; + else if (c == '=') { + b = 0; + pad++; + } else if ((c == ' ') || (c == '\t')) { + continue; + } else { /* error condition */ + if (bytes) free(bytes); + else if (oldBytes) free(oldBytes); + /* error recovery: skip until 2 adjacent newlines. */ + DBG_(("db: invalid character 0x%x '%c'\n", c,c)); + if (c != EOF) { + c = lexGetc(); + while (c != EOF) { + if (c == '\n' && lexLookahead() == '\n') { + ++mime_lineNum; + break; + } + c = lexGetc(); + } + } + return NULL; + } + trip = (trip << 6) | b; + if (++quadIx == 4) { + unsigned char outBytes[3]; + int numOut; + int i; + for (i = 0; i < 3; i++) { + outBytes[2-i] = (unsigned char)(trip & 0xFF); + trip >>= 8; + } + numOut = 3 - pad; + if (bytesLen + numOut > bytesMax) { + if (!bytes) { + bytesMax = 1024; + bytes = (unsigned char*)malloc((size_t)bytesMax); + } + else { + bytesMax <<= 2; + oldBytes = bytes; + bytes = (unsigned char*)realloc(bytes,(size_t)bytesMax); + } + if (bytes == 0) { + mime_error("out of memory while processing BASE64 data\n"); + } + } + if (bytes) { + memcpy(bytes + bytesLen, outBytes, numOut); + bytesLen += numOut; + } + trip = 0; + quadIx = 0; + } + } + } /* while */ + DBG_(("db: bytesLen = %d\n", bytesLen)); + /* kludge: all this won't be necessary if we have tree form + representation */ + if (bytes) { + setValueWithSize(curProp,bytes,(unsigned int)bytesLen); + free(bytes); + } + else if (oldBytes) { + setValueWithSize(curProp,oldBytes,(unsigned int)bytesLen); + free(oldBytes); + } + return 0; + } + +static int match_begin_end_name(int end) { + int token; + lexSkipWhite(); + if (lexLookahead() != ':') return ID; + lexSkipLookahead(); + lexSkipWhite(); + token = match_begin_name(end); + if (token == ID) { + lexPushLookaheadc(':'); + DBG_(("db: ID '%s'\n", yylval.str)); + return ID; + } + else if (token != 0) { + lexSkipLookaheadWord(); + deleteStr(yylval.str); + DBG_(("db: begin/end %d\n", token)); + return token; + } + return 0; + } + +static char* lexGetQuotedPrintable() + { + char cur; + + lexClearToken(); + do { + cur = lexGetc(); + switch (cur) { + case '=': { + int c = 0; + int next[2]; + int i; + for (i = 0; i < 2; i++) { + next[i] = lexGetc(); + if (next[i] >= '0' && next[i] <= '9') + c = c * 16 + next[i] - '0'; + else if (next[i] >= 'A' && next[i] <= 'F') + c = c * 16 + next[i] - 'A' + 10; + else + break; + } + if (i == 0) { + /* single '=' follow by LINESEP is continuation sign? */ + if (next[0] == '\n') { + ++mime_lineNum; + } + else { + lexPushLookaheadc('='); + goto EndString; + } + } + else if (i == 1) { + lexPushLookaheadc(next[1]); + lexPushLookaheadc(next[0]); + lexAppendc('='); + } else { + lexAppendc(c); + } + break; + } /* '=' */ + case '\n': { + lexPushLookaheadc('\n'); + goto EndString; + } + case (char)EOF: + break; + default: + lexAppendc(cur); + break; + } /* switch */ + } while (cur != (char)EOF); + +EndString: + lexAppendc(0); + return lexStr(); + } /* LexQuotedPrintable */ + +static int yylex() { + + int lexmode = LEXMODE(); + if (lexmode == L_VALUES) { + int c = lexGetc(); + if (c == ';') { + DBG_(("db: SEMICOLON\n")); + lexPushLookaheadc(c); + handleMoreRFC822LineBreak(c); + lexSkipLookahead(); + return SEMICOLON; + } + else if (strchr("\n",c)) { + ++mime_lineNum; + /* consume all line separator(s) adjacent to each other */ + c = lexLookahead(); + while (strchr("\n",c)) { + lexSkipLookahead(); + c = lexLookahead(); + ++mime_lineNum; + } + DBG_(("db: LINESEP\n")); + return LINESEP; + } + else { + char *p = 0; + lexPushLookaheadc(c); + if (lexWithinMode(L_BASE64)) { + /* get each char and convert to bin on the fly... */ + p = lexGetDataFromBase64(); + yylval.str = p; + return STRING; + } + else if (lexWithinMode(L_QUOTED_PRINTABLE)) { + p = lexGetQuotedPrintable(); + } + else { +#ifdef _SUPPORT_LINE_FOLDING + p = lexGet1Value(); +#else + p = lexGetStrUntil(";\n"); +#endif + } + if (p) { + DBG_(("db: STRING: '%s'\n", p)); + yylval.str = p; + return STRING; + } + else return 0; + } + } + + else { + /* normal mode */ + while (1) { + int c = lexGetc(); + switch(c) { + case ':': { + /* consume all line separator(s) adjacent to each other */ + /* ignoring linesep immediately after colon. */ + c = lexLookahead(); + while (strchr("\n",c)) { + lexSkipLookahead(); + c = lexLookahead(); + ++mime_lineNum; + } + DBG_(("db: COLON\n")); + return COLON; + } + case ';': + DBG_(("db: SEMICOLON\n")); + return SEMICOLON; + case '=': + DBG_(("db: EQ\n")); + return EQ; + /* ignore tabs/newlines in this mode. We can't ignore + * spaces, because values like NEEDS ACTION have a space. */ + case '\t': continue; + case '\n': { + ++mime_lineNum; + continue; + } + case EOF: return 0; + break; + default: { + lexPushLookaheadc(c); + /* pending lutz : why linker error with isalpha(c)? */ + /*if ( isalpha(c) || c == ' ') { */ + if ( ( c >= 'A' && c <= 'Z') || ( c >= 'a' && c <= 'z') || c == ' ') { + + char *t = lexGetWord(); + yylval.str = t; + if (!strcasecmp(t, "begin")) { + return match_begin_end_name(0); + } + else if (!strcasecmp(t,"end")) { + return match_begin_end_name(1); + } + else { + DBG_(("db: ID '%s'\n", t)); + return ID; + } + } + else { + /* unknown token */ + return 0; + } + break; + } + } + } + } + + return 0; + } + + +/***************************************************************************/ +/*** Public Functions ****/ +/***************************************************************************/ + +static VObject* Parse_MIMEHelper() + { + ObjStackTop = -1; + mime_numErrors = 0; + mime_lineNum = 1; + vObjList = 0; + curObj = 0; + + if (yyparse() != 0) + return 0; + + finiLex(); + return vObjList; + } + +/****************************************************************************/ +VObject* Parse_MIME(const char *input, unsigned long len) + { + initLex(input, len, 0); + return Parse_MIMEHelper(); + } + + +VObject* Parse_MIME_FromFile(FILE *file) + { + VObject *result; + long startPos; + + initLex(0,(unsigned long)-1,file); + startPos = ftell(file); + if (!(result = Parse_MIMEHelper())) { + fseek(file,startPos,SEEK_SET); + } + return result; + } + +VObject* Parse_MIME_FromFileName(const char *fname) + { + FILE *fp = fopen(fname,"r"); + if (fp) { + VObject* o = Parse_MIME_FromFile(fp); + fclose(fp); + return o; + } + else { + char msg[255]; + sprintf(msg, "can't open file '%s' for reading\n", fname); + mime_error_(msg); + return 0; + } + } + +/****************************************************************************/ +void YYDebug(const char *s) +{ + Parse_Debug(s); +} + + +static MimeErrorHandler mimeErrorHandler; + +void registerMimeErrorHandler(MimeErrorHandler me) + { + mimeErrorHandler = me; + } + +static void mime_error(char *s) + { + char msg[256]; + if (mimeErrorHandler) { + sprintf(msg,"%s at line %d", s, mime_lineNum); + mimeErrorHandler(msg); + } + } + +static void mime_error_(char *s) + { + if (mimeErrorHandler) { + mimeErrorHandler(s); + } + } + diff --git a/libkcal/versit/vcc.h b/libkcal/versit/vcc.h new file mode 100644 index 0000000..03886d1 --- a/dev/null +++ b/libkcal/versit/vcc.h @@ -0,0 +1,76 @@ +/*************************************************************************** +(C) Copyright 1996 Apple Computer, Inc., AT&T Corp., International +Business Machines Corporation and Siemens Rolm Communications Inc. + +For purposes of this license notice, the term Licensors shall mean, +collectively, Apple Computer, Inc., AT&T Corp., International +Business Machines Corporation and Siemens Rolm Communications Inc. +The term Licensor shall mean any of the Licensors. + +Subject to acceptance of the following conditions, permission is hereby +granted by Licensors without the need for written agreement and without +license or royalty fees, to use, copy, modify and distribute this +software for any purpose. + +The above copyright notice and the following four paragraphs must be +reproduced in all copies of this software and any software including +this software. + +THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS AND NO LICENSOR SHALL HAVE +ANY OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS OR +MODIFICATIONS. + +IN NO EVENT SHALL ANY LICENSOR BE LIABLE TO ANY PARTY FOR DIRECT, +INDIRECT, SPECIAL OR CONSEQUENTIAL DAMAGES OR LOST PROFITS ARISING OUT +OF THE USE OF THIS SOFTWARE EVEN IF ADVISED OF THE POSSIBILITY OF SUCH +DAMAGE. + +EACH LICENSOR SPECIFICALLY DISCLAIMS ANY WARRANTIES, EXPRESS OR IMPLIED, +INCLUDING BUT NOT LIMITED TO ANY WARRANTY OF NONINFRINGEMENT OR THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. + +The software is provided with RESTRICTED RIGHTS. Use, duplication, or +disclosure by the government are subject to restrictions set forth in +DFARS 252.227-7013 or 48 CFR 52.227-19, as applicable. + +***************************************************************************/ + +#ifndef __VCC_H__ +#define __VCC_H__ 1 + +#include "vobject.h" + + +#if defined(__CPLUSPLUS__) || defined(__cplusplus) +extern "C" { +#endif + +typedef void (*MimeErrorHandler)(char *); + +extern void registerMimeErrorHandler(MimeErrorHandler); + +extern VObject* Parse_MIME(const char *input, unsigned long len); +extern VObject* Parse_MIME_FromFileName(const char* fname); + + +/* NOTE regarding Parse_MIME_FromFile +The function below, Parse_MIME_FromFile, come in two flavors, +neither of which is exported from the DLL. Each version takes +a CFile or FILE* as a parameter, neither of which can be +passed across a DLL interface (at least that is my experience). +If you are linking this code into your build directly then +you may find them a more convenient API that the other flavors +that take a file name. If you use them with the DLL LIB you +will get a link error. +*/ + + +extern VObject* Parse_MIME_FromFile(FILE *file); + +#if defined(__CPLUSPLUS__) || defined(__cplusplus) +} +#endif + +#endif /* __VCC_H__ */ + diff --git a/libkcal/versit/versit.pro b/libkcal/versit/versit.pro new file mode 100644 index 0000000..915c25c --- a/dev/null +++ b/libkcal/versit/versit.pro @@ -0,0 +1,15 @@ +TEMPLATE = lib +CONFIG = qt warn_on release +TARGET = versit +INTERFACES = \ + +HEADERS = \ + port.h \ + vcc.h \ + vobject.h \ + +SOURCES = \ + \ \ + vcc.c \ + vobject.c \ + diff --git a/libkcal/versit/versit.pro.back b/libkcal/versit/versit.pro.back new file mode 100644 index 0000000..915c25c --- a/dev/null +++ b/libkcal/versit/versit.pro.back @@ -0,0 +1,15 @@ +TEMPLATE = lib +CONFIG = qt warn_on release +TARGET = versit +INTERFACES = \ + +HEADERS = \ + port.h \ + vcc.h \ + vobject.h \ + +SOURCES = \ + \ \ + vcc.c \ + vobject.c \ + diff --git a/libkcal/versit/vobject.c b/libkcal/versit/vobject.c new file mode 100644 index 0000000..637efb2 --- a/dev/null +++ b/libkcal/versit/vobject.c @@ -0,0 +1,1433 @@ +/*************************************************************************** +(C) Copyright 1996 Apple Computer, Inc., AT&T Corp., International +Business Machines Corporation and Siemens Rolm Communications Inc. + +For purposes of this license notice, the term Licensors shall mean, +collectively, Apple Computer, Inc., AT&T Corp., International +Business Machines Corporation and Siemens Rolm Communications Inc. +The term Licensor shall mean any of the Licensors. + +Subject to acceptance of the following conditions, permission is hereby +granted by Licensors without the need for written agreement and without +license or royalty fees, to use, copy, modify and distribute this +software for any purpose. + +The above copyright notice and the following four paragraphs must be +reproduced in all copies of this software and any software including +this software. + +THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS AND NO LICENSOR SHALL HAVE +ANY OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS OR +MODIFICATIONS. + +IN NO EVENT SHALL ANY LICENSOR BE LIABLE TO ANY PARTY FOR DIRECT, +INDIRECT, SPECIAL OR CONSEQUENTIAL DAMAGES OR LOST PROFITS ARISING OUT +OF THE USE OF THIS SOFTWARE EVEN IF ADVISED OF THE POSSIBILITY OF SUCH +DAMAGE. + +EACH LICENSOR SPECIFICALLY DISCLAIMS ANY WARRANTIES, EXPRESS OR IMPLIED, +INCLUDING BUT NOT LIMITED TO ANY WARRANTY OF NONINFRINGEMENT OR THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. + +The software is provided with RESTRICTED RIGHTS. Use, duplication, or +disclosure by the government are subject to restrictions set forth in +DFARS 252.227-7013 or 48 CFR 52.227-19, as applicable. + +***************************************************************************/ + +/* + * src: vobject.c + * doc: vobject and APIs to construct vobject, APIs pretty print + * vobject, and convert a vobject into its textual representation. + */ + +#include + +#include "vobject.h" +#include +#include +#ifdef _WIN32_ + + #define strcasecmp _stricmp + +#endif + +#define NAME_OF(o) o->id +#define VALUE_TYPE(o) o->valType +#define STRINGZ_VALUE_OF(o) o->val.strs +#define USTRINGZ_VALUE_OF(o) o->val.ustrs +#define INTEGER_VALUE_OF(o) o->val.i +#define LONG_VALUE_OF(o) o->val.l +#define ANY_VALUE_OF(o) o->val.any +#define VOBJECT_VALUE_OF(o) o->val.vobj + +const char** fieldedProp; + + + +/*---------------------------------------------------------------------- + The following functions involve with memory allocation: + newVObject + deleteVObject + dupStr + deleteStr + newStrItem + deleteStrItem + ----------------------------------------------------------------------*/ + +VObject* newVObject_(const char *id) +{ + VObject *p = (VObject*)malloc(sizeof(VObject)); + p->next = 0; + p->id = id; + p->prop = 0; + VALUE_TYPE(p) = 0; + ANY_VALUE_OF(p) = 0; + return p; +} + +VObject* newVObject(const char *id) +{ + return newVObject_(lookupStr(id)); +} + +void deleteVObject(VObject *p) +{ + if (p->id) + unUseStr(p->id); + if (p) + free(p); + p = NULL; +} + +char* dupStr(const char *s, unsigned int size) +{ + char *t; + if (size == 0) { + size = strlen(s); + } + t = (char*)malloc(size+1); + if (t) { + memcpy(t,s,size); + t[size] = 0; + return t; + } + else { + return (char*)0; + } +} + +void deleteStr(const char *p) +{ + if (p) + free((void*)p); + p = NULL; +} + + +static StrItem* newStrItem(const char *s, StrItem *next) +{ + StrItem *p = (StrItem*)malloc(sizeof(StrItem)); + p->next = next; + p->s = s; + p->refCnt = 1; + return p; +} + +static void deleteStrItem(StrItem *p) +{ + if (p) + free((void*)p); + p = NULL; +} + + +/*---------------------------------------------------------------------- + The following function provide accesses to VObject's value. + ----------------------------------------------------------------------*/ + +const char* vObjectName(VObject *o) +{ + return NAME_OF(o); +} + +void setVObjectName(VObject *o, const char* id) +{ + NAME_OF(o) = id; +} + +const char* vObjectStringZValue(VObject *o) +{ + return STRINGZ_VALUE_OF(o); +} + +void setVObjectStringZValue(VObject *o, const char *s) +{ + STRINGZ_VALUE_OF(o) = dupStr(s,0); + VALUE_TYPE(o) = VCVT_STRINGZ; +} + +void setVObjectStringZValue_(VObject *o, const char *s) +{ + STRINGZ_VALUE_OF(o) = s; + VALUE_TYPE(o) = VCVT_STRINGZ; +} + +const wchar_t* vObjectUStringZValue(VObject *o) +{ + return USTRINGZ_VALUE_OF(o); +} + +void setVObjectUStringZValue(VObject *o, const wchar_t *s) +{ + USTRINGZ_VALUE_OF(o) = (wchar_t*) dupStr((char*)s,(uStrLen(s)+1)*2); + VALUE_TYPE(o) = VCVT_USTRINGZ; +} + +void setVObjectUStringZValue_(VObject *o, const wchar_t *s) +{ + USTRINGZ_VALUE_OF(o) = s; + VALUE_TYPE(o) = VCVT_USTRINGZ; +} + +unsigned int vObjectIntegerValue(VObject *o) +{ + return INTEGER_VALUE_OF(o); +} + +void setVObjectIntegerValue(VObject *o, unsigned int i) +{ + INTEGER_VALUE_OF(o) = i; + VALUE_TYPE(o) = VCVT_UINT; +} + +unsigned long vObjectLongValue(VObject *o) +{ + return LONG_VALUE_OF(o); +} + +void setVObjectLongValue(VObject *o, unsigned long l) +{ + LONG_VALUE_OF(o) = l; + VALUE_TYPE(o) = VCVT_ULONG; +} + +void* vObjectAnyValue(VObject *o) +{ + return ANY_VALUE_OF(o); +} + +void setVObjectAnyValue(VObject *o, void *t) +{ + ANY_VALUE_OF(o) = t; + VALUE_TYPE(o) = VCVT_RAW; +} + +VObject* vObjectVObjectValue(VObject *o) +{ + return VOBJECT_VALUE_OF(o); +} + +void setVObjectVObjectValue(VObject *o, VObject *p) +{ + VOBJECT_VALUE_OF(o) = p; + VALUE_TYPE(o) = VCVT_VOBJECT; +} + +int vObjectValueType(VObject *o) +{ + return VALUE_TYPE(o); +} + + +/*---------------------------------------------------------------------- + The following functions can be used to build VObject. + ----------------------------------------------------------------------*/ + +VObject* addVObjectProp(VObject *o, VObject *p) +{ + /* circular link list pointed to tail */ + /* + o {next,id,prop,val} + V + pn {next,id,prop,val} + V + ... + p1 {next,id,prop,val} + V + pn + --> + o {next,id,prop,val} + V + pn {next,id,prop,val} + V + p {next,id,prop,val} + ... + p1 {next,id,prop,val} + V + pn + */ + + VObject *tail = o->prop; + if (tail) { + p->next = tail->next; + o->prop = tail->next = p; + } + else { + o->prop = p->next = p; + } + return p; +} + +VObject* addProp(VObject *o, const char *id) +{ + return addVObjectProp(o,newVObject(id)); +} + +VObject* addProp_(VObject *o, const char *id) +{ + return addVObjectProp(o,newVObject_(id)); +} + +void addList(VObject **o, VObject *p) +{ + p->next = 0; + if (*o == 0) { + *o = p; + } + else { + VObject *t = *o; + while (t->next) { + t = t->next; + } + t->next = p; + } +} + +VObject* nextVObjectInList(VObject *o) +{ + return o->next; +} + +VObject* setValueWithSize_(VObject *prop, void *val, unsigned int size) +{ + VObject *sizeProp; + setVObjectAnyValue(prop, val); + sizeProp = addProp(prop,VCDataSizeProp); + setVObjectLongValue(sizeProp, size); + return prop; +} + +VObject* setValueWithSize(VObject *prop, void *val, unsigned int size) +{ + void *p = dupStr(val,size); + return setValueWithSize_(prop,p,p?size:0); +} + +void initPropIterator(VObjectIterator *i, VObject *o) +{ + i->start = o->prop; + i->next = 0; +} + +void initVObjectIterator(VObjectIterator *i, VObject *o) +{ + i->start = o->next; + i->next = 0; +} + +int moreIteration(VObjectIterator *i) +{ + return (i->start && (i->next==0 || i->next!=i->start)); +} + +VObject* nextVObject(VObjectIterator *i) +{ + if (i->start && i->next != i->start) { + if (i->next == 0) { + i->next = i->start->next; + return i->next; + } + else { + i->next = i->next->next; + return i->next; + } + } + else return (VObject*)0; +} + +VObject* isAPropertyOf(VObject *o, const char *id) +{ + VObjectIterator i; + initPropIterator(&i,o); + while (moreIteration(&i)) { + VObject *each = nextVObject(&i); + if (!strcasecmp(id,each->id)) + return each; + } + return (VObject*)0; +} + +VObject* addGroup(VObject *o, const char *g) +{ + /* + a.b.c + --> + prop(c) + prop(VCGrouping=b) + prop(VCGrouping=a) + */ + char *dot = strrchr(g,'.'); + if (dot) { + VObject *p, *t; + char *gs, *n = dot+1; + gs = dupStr(g,0); /* so we can write to it. */ + /* used to be + * t = p = addProp_(o,lookupProp_(n)); + */ + t = p = addProp_(o,lookupProp(n)); + dot = strrchr(gs,'.'); + *dot = 0; + do { + dot = strrchr(gs,'.'); + if (dot) { + n = dot+1; + *dot=0; + } + else + n = gs; + /* property(VCGroupingProp=n); + * and the value may have VCGrouping property + */ + t = addProp(t,VCGroupingProp); + setVObjectStringZValue(t,lookupProp_(n)); + } while (n != gs); + deleteStr(gs); + return p; + } + else + return addProp_(o,lookupProp(g)); +} + +VObject* addPropValue(VObject *o, const char *p, const char *v) +{ + VObject *prop; + prop = addProp(o,p); + setVObjectUStringZValue_(prop, fakeUnicode(v,0)); + return prop; +} + +VObject* addPropSizedValue_(VObject *o, const char *p, const char *v, + unsigned int size) +{ + VObject *prop; + prop = addProp(o,p); + setValueWithSize_(prop, (void*)v, size); + return prop; +} + +VObject* addPropSizedValue(VObject *o, const char *p, const char *v, + unsigned int size) +{ + return addPropSizedValue_(o,p,dupStr(v,size),size); +} + + + +/*---------------------------------------------------------------------- + The following pretty print a VObject + ----------------------------------------------------------------------*/ + +static void printVObject_(FILE *fp, VObject *o, int level); + +static void indent(FILE *fp, int level) +{ + int i; + for (i=0;ifail) return; + slen = strlen(s); + if (fp->fp) { + fwrite(s,1,slen,fp->fp); + } + else { +stuff: + if (fp->len + slen < fp->limit) { + memcpy(fp->s+fp->len,s,slen); + fp->len += slen; + return; + } + else if (fp->alloc) { + fp->limit = fp->limit + OFILE_REALLOC_SIZE; + if (OFILE_REALLOC_SIZE <= slen) fp->limit += slen; + if (fp->s) + fp->s = realloc(fp->s,fp->limit); + else + fp->s = malloc(fp->limit); + if (fp->s) goto stuff; + } + if (fp->alloc) + free(fp->s); + fp->s = 0; + fp->fail = 1; + } +} + +static void appendcOFile(OFile *fp, char c) +{ + if (fp->fail) return; + if (fp->fp) { + fputc(c,fp->fp); + } + else { +stuff: + if (fp->len+1 < fp->limit) { + fp->s[fp->len] = c; + fp->len++; + return; + } + else if (fp->alloc) { + fp->limit = fp->limit + OFILE_REALLOC_SIZE; + fp->s = realloc(fp->s,fp->limit); + if (fp->s) goto stuff; + } + if (fp->alloc) + free(fp->s); + fp->s = 0; + fp->fail = 1; + } +} + +#else + +static void appendcOFile_(OFile *fp, char c) +{ + if (fp->fail) return; + if (fp->fp) { + fputc(c,fp->fp); + } + else { +stuff: + if (fp->len+1 < fp->limit) { + fp->s[fp->len] = c; + fp->len++; + return; + } + else if (fp->alloc) { + fp->limit = fp->limit + OFILE_REALLOC_SIZE; + fp->s = realloc(fp->s,fp->limit); + if (fp->s) goto stuff; + } + if (fp->alloc) + free(fp->s); + fp->s = 0; + fp->fail = 1; + } +} + +static void appendcOFile(OFile *fp, char c) +{ + if (c == '\n') { + /* write out as */ + appendcOFile_(fp,0xd); + appendcOFile_(fp,0xa); + } + else + appendcOFile_(fp,c); +} + +static void appendsOFile(OFile *fp, const char *s) +{ + int i, slen; + slen = strlen(s); + for (i=0; ifp = ofp; + fp->s = 0; + fp->len = 0; + fp->limit = 0; + fp->alloc = 0; + fp->fail = 0; +} + +static void initMemOFile(OFile *fp, char *s, int len) +{ + fp->fp = 0; + fp->s = s; + fp->len = 0; + fp->limit = s?len:0; + fp->alloc = s?0:1; + fp->fail = 0; +} + + +static int writeBase64(OFile *fp, unsigned char *s, long len) +{ + long cur = 0; + int i, numQuads = 0; + unsigned long trip; + unsigned char b; + char quad[5]; +#define MAXQUADS 16 + + quad[4] = 0; + + while (cur < len) { + /* collect the triplet of bytes into 'trip' */ + trip = 0; + for (i = 0; i < 3; i++) { + b = (cur < len) ? *(s + cur) : 0; + cur++; + trip = trip << 8 | b; + } + /* fill in 'quad' with the appropriate four characters */ + for (i = 3; i >= 0; i--) { + b = (unsigned char)(trip & 0x3F); + trip = trip >> 6; + if ((3 - i) < (cur - len)) + quad[i] = '='; /* pad char */ + else if (b < 26) quad[i] = (char)b + 'A'; + else if (b < 52) quad[i] = (char)(b - 26) + 'a'; + else if (b < 62) quad[i] = (char)(b - 52) + '0'; + else if (b == 62) quad[i] = '+'; + else quad[i] = '/'; + } + /* now output 'quad' with appropriate whitespace and line ending */ + appendsOFile(fp, (numQuads == 0 ? " " : "")); + appendsOFile(fp, quad); + appendsOFile(fp, ((cur >= len)?"\n" :(numQuads==MAXQUADS-1?"\n" : ""))); + numQuads = (numQuads + 1) % MAXQUADS; + } + appendcOFile(fp,'\n'); + + return 1; +} + +/* this function really sucks. Too basic. */ +static void writeQPString(OFile *fp, const char *s, int qp) +{ + const char *p = s; + while (*p) { + if (*p == '\n') { + if (p[1]) appendsOFile(fp,"=0A="); + } + if (*p == '=' && qp) + appendsOFile(fp,"=3D"); + else + appendcOFile(fp,*p); + p++; + } +} + +static void writeVObject_(OFile *fp, VObject *o); + +static void writeValue(OFile *fp, VObject *o, unsigned long size) +{ + if (o == 0) return; + switch (VALUE_TYPE(o)) { + case VCVT_USTRINGZ: { + char *s = fakeCString(USTRINGZ_VALUE_OF(o)); + if (isAPropertyOf(o, VCQuotedPrintableProp)) + writeQPString(fp, s, 1); + else + writeQPString(fp, s, 0); + deleteStr(s); + break; + } + case VCVT_STRINGZ: { + if (isAPropertyOf(o, VCQuotedPrintableProp)) + writeQPString(fp, STRINGZ_VALUE_OF(o), 1); + else + writeQPString(fp, STRINGZ_VALUE_OF(o), 0); + break; + } + case VCVT_UINT: { + char buf[16]; + sprintf(buf,"%u", INTEGER_VALUE_OF(o)); + appendsOFile(fp,buf); + break; + } + case VCVT_ULONG: { + char buf[16]; + sprintf(buf,"%lu", LONG_VALUE_OF(o)); + appendsOFile(fp,buf); + break; + } + case VCVT_RAW: { + appendcOFile(fp,'\n'); + writeBase64(fp,(unsigned char*)(ANY_VALUE_OF(o)),size); + break; + } + case VCVT_VOBJECT: + appendcOFile(fp,'\n'); + writeVObject_(fp,VOBJECT_VALUE_OF(o)); + break; + } +} + +static void writeAttrValue(OFile *fp, VObject *o) +{ + if (NAME_OF(o)) { + struct PreDefProp *pi; + pi = lookupPropInfo(NAME_OF(o)); + if (pi && ((pi->flags & PD_INTERNAL) != 0)) return; + appendcOFile(fp,';'); + appendsOFile(fp,NAME_OF(o)); + } + else + appendcOFile(fp,';'); + if (VALUE_TYPE(o)) { + appendcOFile(fp,'='); + writeValue(fp,o,0); + } +} + +static void writeGroup(OFile *fp, VObject *o) +{ + char buf1[256]; + char buf2[256]; + strcpy(buf1,NAME_OF(o)); + while ((o=isAPropertyOf(o,VCGroupingProp)) != 0) { + strncpy(buf2,STRINGZ_VALUE_OF(o),sizeof(buf2)); + buf2[sizeof(buf2)] = '\0'; + strncat(buf2,".",sizeof(buf2)-strlen(buf2)-1); + strncat(buf2,buf1,sizeof(buf2)-strlen(buf2)-1); + strcpy(buf1,buf2); + } + appendsOFile(fp,buf1); +} + +static int inList(const char **list, const char *s) +{ + if (list == 0) return 0; + while (*list) { + if (strcasecmp(*list,s) == 0) return 1; + list++; + } + return 0; +} + +static void writeProp(OFile *fp, VObject *o) +{ + if (NAME_OF(o)) { + struct PreDefProp *pi; + VObjectIterator t; + const char **fields_ = 0; + pi = lookupPropInfo(NAME_OF(o)); + if (pi && ((pi->flags & PD_BEGIN) != 0)) { + writeVObject_(fp,o); + return; + } + if (isAPropertyOf(o,VCGroupingProp)) + writeGroup(fp,o); + else + appendsOFile(fp,NAME_OF(o)); + if (pi) fields_ = pi->fields; + initPropIterator(&t,o); + while (moreIteration(&t)) { + const char *s; + VObject *eachProp = nextVObject(&t); + s = NAME_OF(eachProp); + if (strcasecmp(VCGroupingProp,s) && !inList(fields_,s)) + writeAttrValue(fp,eachProp); + } + if (fields_) { + int i = 0, n = 0; + const char** fields = fields_; + /* output prop as fields */ + appendcOFile(fp,':'); + while (*fields) { + VObject *tl = isAPropertyOf(o,*fields); + i++; + if (tl) n = i; + fields++; + } + fields = fields_; + for (i=0;iflags & PD_BEGIN) != 0)) { + VObjectIterator t; + const char *begin = NAME_OF(o); + appendsOFile(fp,"BEGIN:"); + appendsOFile(fp,begin); + appendcOFile(fp,'\n'); + initPropIterator(&t,o); + while (moreIteration(&t)) { + VObject *eachProp = nextVObject(&t); + writeProp(fp, eachProp); + } + appendsOFile(fp,"END:"); + appendsOFile(fp,begin); + appendsOFile(fp,"\n\n"); + } + } +} + +void writeVObject(FILE *fp, VObject *o) +{ + OFile ofp; + initOFile(&ofp,fp); + writeVObject_(&ofp,o); +} + +void writeVObjectToFile(char *fname, VObject *o) +{ + FILE *fp = fopen(fname,"w"); + if (fp) { + writeVObject(fp,o); + fclose(fp); + } +} + +void writeVObjectsToFile(char *fname, VObject *list) +{ + FILE *fp = fopen(fname,"w"); + if (fp) { + while (list) { + writeVObject(fp,list); + list = nextVObjectInList(list); + } + fclose(fp); + } +} + +char* writeMemVObject(char *s, int *len, VObject *o) +{ + OFile ofp; + initMemOFile(&ofp,s,len?*len:0); + writeVObject_(&ofp,o); + if (len) *len = ofp.len; + appendcOFile(&ofp,0); + return ofp.s; +} + +char* writeMemVObjects(char *s, int *len, VObject *list) +{ + OFile ofp; + initMemOFile(&ofp,s,len?*len:0); + while (list) { + writeVObject_(&ofp,list); + list = nextVObjectInList(list); + } + if (len) *len = ofp.len; + appendcOFile(&ofp,0); + return ofp.s; +} + +/*---------------------------------------------------------------------- + APIs to do fake Unicode stuff. + ----------------------------------------------------------------------*/ +wchar_t* fakeUnicode(const char *ps, int *bytes) +{ + wchar_t *r, *pw; + int len = strlen(ps)+1; + + pw = r = (wchar_t*)malloc(sizeof(wchar_t)*len); + if (bytes) + *bytes = len * sizeof(wchar_t); + + while (*ps) { + if (*ps == '\n') + *pw = (wchar_t)0x2028; + else if (*ps == '\r') + *pw = (wchar_t)0x2029; + else + *pw = (wchar_t)(unsigned char)*ps; + ps++; pw++; + } + *pw = (wchar_t)0; + + return r; +} + +int uStrLen(const wchar_t *u) +{ + int i = 0; + while (*u != (wchar_t)0) { u++; i++; } + return i; +} + +char* fakeCString(const wchar_t *u) +{ + char *s, *t; + int len = uStrLen(u) + 1; + t = s = (char*)malloc(len+1); + while (*u) { + if (*u == (wchar_t)0x2028) + *t = '\n'; + else if (*u == (wchar_t)0x2029) + *t = '\r'; + else + *t = (char)*u; + u++; t++; + } + *t = 0; + return s; +} + +/* end of source file vobject.c */ diff --git a/libkcal/versit/vobject.h b/libkcal/versit/vobject.h new file mode 100644 index 0000000..0ec8b31 --- a/dev/null +++ b/libkcal/versit/vobject.h @@ -0,0 +1,384 @@ +/*************************************************************************** +(C) Copyright 1996 Apple Computer, Inc., AT&T Corp., International +Business Machines Corporation and Siemens Rolm Communications Inc. + +For purposes of this license notice, the term Licensors shall mean, +collectively, Apple Computer, Inc., AT&T Corp., International +Business Machines Corporation and Siemens Rolm Communications Inc. +The term Licensor shall mean any of the Licensors. + +Subject to acceptance of the following conditions, permission is hereby +granted by Licensors without the need for written agreement and without +license or royalty fees, to use, copy, modify and distribute this +software for any purpose. + +The above copyright notice and the following four paragraphs must be +reproduced in all copies of this software and any software including +this software. + +THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS AND NO LICENSOR SHALL HAVE +ANY OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS OR +MODIFICATIONS. + +IN NO EVENT SHALL ANY LICENSOR BE LIABLE TO ANY PARTY FOR DIRECT, +INDIRECT, SPECIAL OR CONSEQUENTIAL DAMAGES OR LOST PROFITS ARISING OUT +OF THE USE OF THIS SOFTWARE EVEN IF ADVISED OF THE POSSIBILITY OF SUCH +DAMAGE. + +EACH LICENSOR SPECIFICALLY DISCLAIMS ANY WARRANTIES, EXPRESS OR IMPLIED, +INCLUDING BUT NOT LIMITED TO ANY WARRANTY OF NONINFRINGEMENT OR THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. + +The software is provided with RESTRICTED RIGHTS. Use, duplication, or +disclosure by the government are subject to restrictions set forth in +DFARS 252.227-7013 or 48 CFR 52.227-19, as applicable. + +***************************************************************************/ + +/* + +The vCard/vCalendar C interface is implemented in the set +of files as follows: + +vcc.y, yacc source, and vcc.c, the yacc output you will use +implements the core parser + +vobject.c implements an API that insulates the caller from +the parser and changes in the vCard/vCalendar BNF + +port.h defines compilation environment dependent stuff + +vcc.h and vobject.h are header files for their .c counterparts + +vcaltmp.h and vcaltmp.c implement vCalendar "macro" functions +which you may find useful. + +test.c is a standalone test driver that exercises some of +the features of the APIs provided. Invoke test.exe on a +VCARD/VCALENDAR input text file and you will see the pretty +print output of the internal representation (this pretty print +output should give you a good idea of how the internal +representation looks like -- there is one such output in the +following too). Also, a file with the .out suffix is generated +to show that the internal representation can be written back +in the original text format. + +For more information on this API see the readme.txt file +which accompanied this distribution. + + Also visit: + + http://www.versit.com + http://www.ralden.com + +*/ + + +#ifndef __VOBJECT_H__ +#define __VOBJECT_H__ 1 + + +#include "port.h" +#include +#include + +#if defined(__CPLUSPLUS__) || defined(__cplusplus) +extern "C" { +#endif + + +#define VC7bitProp "7BIT" +#define VC8bitProp "8BIT" +#define VCAAlarmProp "AALARM" +#define VCAdditionalNamesProp "ADDN" +#define VCAdrProp "ADR" +#define VCAgentProp "AGENT" +#define VCAIFFProp "AIFF" +#define VCAOLProp "AOL" +#define VCAppleLinkProp "APPLELINK" +#define VCAttachProp "ATTACH" +#define VCAttendeeProp "ATTENDEE" +#define VCATTMailProp "ATTMAIL" +#define VCAudioContentProp "AUDIOCONTENT" +#define VCAVIProp "AVI" +#define VCBase64Prop "BASE64" +#define VCBBSProp "BBS" +#define VCBirthDateProp "BDAY" +#define VCBMPProp "BMP" +#define VCBodyProp "BODY" +#define VCBusinessRoleProp "ROLE" +#define VCCalProp "VCALENDAR" +#define VCCaptionProp "CAP" +#define VCCardProp "VCARD" +#define VCCarProp "CAR" +#define VCCategoriesProp "CATEGORIES" +#define VCCellularProp "CELL" +#define VCCGMProp "CGM" +#define VCCharSetProp "CS" +#define VCCIDProp "CID" +#define VCCISProp "CIS" +#define VCCityProp "L" +#define VCClassProp "CLASS" +#define VCCommentProp "NOTE" +#define VCCompletedProp "COMPLETED" +#define VCContentIDProp "CONTENT-ID" +#define VCCountryNameProp "C" +#define VCDAlarmProp "DALARM" +#define VCDataSizeProp "DATASIZE" +#define VCDayLightProp "DAYLIGHT" +#define VCDCreatedProp "DCREATED" +#define VCDeliveryLabelProp "LABEL" +#define VCDescriptionProp "DESCRIPTION" +#define VCDIBProp "DIB" +#define VCDisplayStringProp "DISPLAYSTRING" +#define VCDomesticProp "DOM" +#define VCDTendProp "DTEND" +#define VCDTstartProp "DTSTART" +#define VCDueProp "DUE" +#define VCEmailAddressProp "EMAIL" +#define VCEncodingProp "ENCODING" +#define VCEndProp "END" +#define VCEventProp "VEVENT" +#define VCEWorldProp "EWORLD" +#define VCExNumProp "EXNUM" +#define VCExDateProp "EXDATE" +#define VCExpectProp "EXPECT" +#define VCExtAddressProp "EXT ADD" +#define VCFamilyNameProp "F" +#define VCFaxProp "FAX" +#define VCFullNameProp "FN" +#define VCGeoProp "GEO" +#define VCGeoLocationProp "GEO" +#define VCGIFProp "GIF" +#define VCGivenNameProp "G" +#define VCGroupingProp "Grouping" +#define VCHomeProp "HOME" +#define VCIBMMailProp "IBMMail" +#define VCInlineProp "INLINE" +#define VCInternationalProp "INTL" +#define VCInternetProp "INTERNET" +#define VCISDNProp "ISDN" +#define VCJPEGProp "JPEG" +#define VCLanguageProp "LANG" +#define VCLastModifiedProp "LAST-MODIFIED" +#define VCLastRevisedProp "REV" +#define VCLocationProp "LOCATION" +#define VCLogoProp "LOGO" +#define VCMailerProp "MAILER" +#define VCMAlarmProp "MALARM" +#define VCMCIMailProp "MCIMAIL" +#define VCMessageProp "MSG" +#define VCMETProp "MET" +#define VCModemProp "MODEM" +#define VCMPEG2Prop "MPEG2" +#define VCMPEGProp "MPEG" +#define VCMSNProp "MSN" +#define VCNamePrefixesProp "NPRE" +#define VCNameProp "N" +#define VCNameSuffixesProp "NSUF" +#define VCNoteProp "NOTE" +#define VCOrgNameProp "ORGNAME" +#define VCOrgProp "ORG" +#define VCOrgUnit2Prop "OUN2" +#define VCOrgUnit3Prop "OUN3" +#define VCOrgUnit4Prop "OUN4" +#define VCOrgUnitProp "OUN" +#define VCPagerProp "PAGER" +#define VCPAlarmProp "PALARM" +#define VCParcelProp "PARCEL" +#define VCPartProp "PART" +#define VCPCMProp "PCM" +#define VCPDFProp "PDF" +#define VCPGPProp "PGP" +#define VCPhotoProp "PHOTO" +#define VCPICTProp "PICT" +#define VCPMBProp "PMB" +#define VCPostalBoxProp "BOX" +#define VCPostalCodeProp "PC" +#define VCPostalProp "POSTAL" +#define VCPowerShareProp "POWERSHARE" +#define VCPreferredProp "PREF" +#define VCPriorityProp "PRIORITY" +#define VCProcedureNameProp "PROCEDURENAME" +#define VCProdIdProp "PRODID" +#define VCProdigyProp "PRODIGY" +#define VCPronunciationProp "SOUND" +#define VCPSProp "PS" +#define VCPublicKeyProp "KEY" +#define VCQPProp "QP" +#define VCQuickTimeProp "QTIME" +#define VCQuotedPrintableProp "QUOTED-PRINTABLE" +#define VCRDateProp "RDATE" +#define VCRegionProp "R" +#define VCRelatedToProp "RELATED-TO" +#define VCRepeatCountProp "REPEATCOUNT" +#define VCResourcesProp "RESOURCES" +#define VCRNumProp "RNUM" +#define VCRoleProp "ROLE" +#define VCRRuleProp "RRULE" +#define VCRSVPProp "RSVP" +#define VCRunTimeProp "RUNTIME" +#define VCSequenceProp "SEQUENCE" +#define VCSnoozeTimeProp "SNOOZETIME" +#define VCStartProp "START" +#define VCStatusProp "STATUS" +#define VCStreetAddressProp "STREET" +#define VCSubTypeProp "SUBTYPE" +#define VCSummaryProp "SUMMARY" +#define VCTelephoneProp "TEL" +#define VCTIFFProp "TIFF" +#define VCTimeZoneProp "TZ" +#define VCTitleProp "TITLE" +#define VCTLXProp "TLX" +#define VCTodoProp "VTODO" +#define VCTranspProp "TRANSP" +#define VCUniqueStringProp "UID" +#define VCURLProp "URL" +#define VCURLValueProp "URLVAL" +#define VCValueProp "VALUE" +#define VCVersionProp "VERSION" +#define VCVideoProp "VIDEO" +#define VCVoiceProp "VOICE" +#define VCWAVEProp "WAVE" +#define VCWMFProp "WMF" +#define VCWorkProp "WORK" +#define VCX400Prop "X400" +#define VCX509Prop "X509" +#define VCXRuleProp "XRULE" + +/* extensions for KOrganizer / KPilot */ +#define KPilotIdProp "X-PILOTID" +#define KPilotStatusProp "X-PILOTSTAT" + +/* extensions for iMIP / iTIP */ +#define ICOrganizerProp "X-ORGANIZER" +#define ICMethodProp "X-METHOD" +#define ICRequestStatusProp "X-REQUEST-STATUS" + +typedef struct VObject VObject; + +typedef union ValueItem { + const char *strs; + const wchar_t *ustrs; + unsigned int i; + unsigned long l; + void *any; + VObject *vobj; + } ValueItem; + +struct VObject { + VObject *next; + const char *id; + VObject *prop; + unsigned short valType; + ValueItem val; + }; + +typedef struct StrItem StrItem; + +struct StrItem { + StrItem *next; + const char *s; + unsigned int refCnt; + }; + +typedef struct VObjectIterator { + VObject* start; + VObject* next; + } VObjectIterator; + +extern VObject* newVObject(const char *id); +extern void deleteVObject(VObject *p); +extern char* dupStr(const char *s, unsigned int size); +extern void deleteStr(const char *p); +extern void unUseStr(const char *s); + +extern void setVObjectName(VObject *o, const char* id); +extern void setVObjectStringZValue(VObject *o, const char *s); +extern void setVObjectStringZValue_(VObject *o, const char *s); +extern void setVObjectUStringZValue(VObject *o, const wchar_t *s); +extern void setVObjectUStringZValue_(VObject *o, const wchar_t *s); +extern void setVObjectIntegerValue(VObject *o, unsigned int i); +extern void setVObjectLongValue(VObject *o, unsigned long l); +extern void setVObjectAnyValue(VObject *o, void *t); +extern VObject* setValueWithSize(VObject *prop, void *val, unsigned int size); +extern VObject* setValueWithSize_(VObject *prop, void *val, unsigned int size); + +extern const char* vObjectName(VObject *o); +extern const char* vObjectStringZValue(VObject *o); +extern const wchar_t* vObjectUStringZValue(VObject *o); +extern unsigned int vObjectIntegerValue(VObject *o); +extern unsigned long vObjectLongValue(VObject *o); +extern void* vObjectAnyValue(VObject *o); +extern VObject* vObjectVObjectValue(VObject *o); +extern void setVObjectVObjectValue(VObject *o, VObject *p); + +extern VObject* addVObjectProp(VObject *o, VObject *p); +extern VObject* addProp(VObject *o, const char *id); +extern VObject* addProp_(VObject *o, const char *id); +extern VObject* addPropValue(VObject *o, const char *p, const char *v); +extern VObject* addPropSizedValue_(VObject *o, const char *p, const char *v, unsigned int size); +extern VObject* addPropSizedValue(VObject *o, const char *p, const char *v, unsigned int size); +extern VObject* addGroup(VObject *o, const char *g); +extern void addList(VObject **o, VObject *p); + +extern VObject* isAPropertyOf(VObject *o, const char *id); + +extern VObject* nextVObjectInList(VObject *o); +extern void initPropIterator(VObjectIterator *i, VObject *o); +extern int moreIteration(VObjectIterator *i); +extern VObject* nextVObject(VObjectIterator *i); + +extern char* writeMemVObject(char *s, int *len, VObject *o); +extern char* writeMemVObjects(char *s, int *len, VObject *list); + +extern const char* lookupStr(const char *s); +extern void cleanStrTbl(); + +extern void cleanVObject(VObject *o); +extern void cleanVObjects(VObject *list); + +extern const char* lookupProp(const char* str); +extern const char* lookupProp_(const char* str); + +extern wchar_t* fakeUnicode(const char *ps, int *bytes); +extern int uStrLen(const wchar_t *u); +extern char* fakeCString(const wchar_t *u); + +extern void printVObjectToFile(char *fname,VObject *o); +extern void printVObjectsToFile(char *fname,VObject *list); +extern void writeVObjectToFile(char *fname, VObject *o); +extern void writeVObjectsToFile(char *fname, VObject *list); + +extern int vObjectValueType(VObject *o); + +/* return type of vObjectValueType: */ +#define VCVT_NOVALUE 0 + /* if the VObject has no value associated with it. */ +#define VCVT_STRINGZ 1 + /* if the VObject has value set by setVObjectStringZValue. */ +#define VCVT_USTRINGZ 2 + /* if the VObject has value set by setVObjectUStringZValue. */ +#define VCVT_UINT 3 + /* if the VObject has value set by setVObjectIntegerValue. */ +#define VCVT_ULONG 4 + /* if the VObject has value set by setVObjectLongValue. */ +#define VCVT_RAW 5 + /* if the VObject has value set by setVObjectAnyValue. */ +#define VCVT_VOBJECT 6 + /* if the VObject has value set by setVObjectVObjectValue. */ + +extern const char** fieldedProp; + +extern void printVObject(FILE *fp,VObject *o); +extern void writeVObject(FILE *fp, VObject *o); + + +#if defined(__CPLUSPLUS__) || defined(__cplusplus) +} +#endif + +#endif /* __VOBJECT_H__ */ + + -- cgit v0.9.0.2