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

BUG:215923


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

1 files changed, 3488 insertions, 0 deletions

diff --git a/kalarm/alarmevent.cpp b/kalarm/alarmevent.cpp
new file mode 100644
index 00000000..28b0a55a
--- /dev/null
+++ b/kalarm/alarmevent.cpp
@@ -0,0 +1,3488 @@
+/*
+ *  alarmevent.cpp  -  represents calendar alarms and events
+ *  Program:  kalarm
+ *  Copyright © 2001-2009 by David Jarvie <djarvie@kde.org>
+ *
+ *  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 of the License, 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.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#include "kalarm.h"
+
+#include <stdlib.h>
+#include <time.h>
+#include <ctype.h>
+#include <qcolor.h>
+#include <qregexp.h>
+
+#include <klocale.h>
+#include <kdebug.h>
+
+#include "alarmtext.h"
+#include "functions.h"
+#include "kalarmapp.h"
+#include "kamail.h"
+#include "preferences.h"
+#include "alarmcalendar.h"
+#include "alarmevent.h"
+using namespace KCal;
+
+
+const QCString APPNAME("KALARM");
+
+// KAlarm version which first used the current calendar/event format.
+// If this changes, KAEvent::convertKCalEvents() must be changed correspondingly.
+// The string version is the KAlarm version string used in the calendar file.
+QString KAEvent::calVersionString()  { return QString::fromLatin1("1.5.0"); }
+int     KAEvent::calVersion()        { return KAlarm::Version(1,5,0); }
+
+// Custom calendar properties.
+// Note that all custom property names are prefixed with X-KDE-KALARM- in the calendar file.
+// - Event properties
+static const QCString NEXT_RECUR_PROPERTY("NEXTRECUR");     // X-KDE-KALARM-NEXTRECUR property
+static const QCString REPEAT_PROPERTY("REPEAT");            // X-KDE-KALARM-REPEAT property
+// - General alarm properties
+static const QCString TYPE_PROPERTY("TYPE");    // X-KDE-KALARM-TYPE property
+static const QString FILE_TYPE                  = QString::fromLatin1("FILE");
+static const QString AT_LOGIN_TYPE              = QString::fromLatin1("LOGIN");
+static const QString REMINDER_TYPE              = QString::fromLatin1("REMINDER");
+static const QString REMINDER_ONCE_TYPE         = QString::fromLatin1("REMINDER_ONCE");
+static const QString ARCHIVE_REMINDER_ONCE_TYPE = QString::fromLatin1("ONCE");
+static const QString TIME_DEFERRAL_TYPE         = QString::fromLatin1("DEFERRAL");
+static const QString DATE_DEFERRAL_TYPE         = QString::fromLatin1("DATE_DEFERRAL");
+static const QString DISPLAYING_TYPE            = QString::fromLatin1("DISPLAYING");   // used only in displaying calendar
+static const QString PRE_ACTION_TYPE            = QString::fromLatin1("PRE");
+static const QString POST_ACTION_TYPE           = QString::fromLatin1("POST");
+static const QCString NEXT_REPEAT_PROPERTY("NEXTREPEAT");   // X-KDE-KALARM-NEXTREPEAT property
+// - Display alarm properties
+static const QCString FONT_COLOUR_PROPERTY("FONTCOLOR");    // X-KDE-KALARM-FONTCOLOR property
+// - Email alarm properties
+static const QCString EMAIL_ID_PROPERTY("EMAILID");         // X-KDE-KALARM-EMAILID property
+// - Audio alarm properties
+static const QCString VOLUME_PROPERTY("VOLUME");            // X-KDE-KALARM-VOLUME property
+static const QCString SPEAK_PROPERTY("SPEAK");              // X-KDE-KALARM-SPEAK property
+
+// Event categories
+static const QString DATE_ONLY_CATEGORY        = QString::fromLatin1("DATE");
+static const QString EMAIL_BCC_CATEGORY        = QString::fromLatin1("BCC");
+static const QString CONFIRM_ACK_CATEGORY      = QString::fromLatin1("ACKCONF");
+static const QString LATE_CANCEL_CATEGORY      = QString::fromLatin1("LATECANCEL;");
+static const QString AUTO_CLOSE_CATEGORY       = QString::fromLatin1("LATECLOSE;");
+static const QString TEMPL_AFTER_TIME_CATEGORY = QString::fromLatin1("TMPLAFTTIME;");
+static const QString KMAIL_SERNUM_CATEGORY     = QString::fromLatin1("KMAIL:");
+static const QString KORGANIZER_CATEGORY       = QString::fromLatin1("KORG");
+static const QString DEFER_CATEGORY            = QString::fromLatin1("DEFER;");
+static const QString ARCHIVE_CATEGORY          = QString::fromLatin1("SAVE");
+static const QString ARCHIVE_CATEGORIES        = QString::fromLatin1("SAVE:");
+static const QString LOG_CATEGORY              = QString::fromLatin1("LOG:");
+static const QString xtermURL = QString::fromLatin1("xterm:");
+
+// Event status strings
+static const QString DISABLED_STATUS           = QString::fromLatin1("DISABLED");
+
+static const QString EXPIRED_UID    = QString::fromLatin1("-exp-");
+static const QString DISPLAYING_UID = QString::fromLatin1("-disp-");
+static const QString TEMPLATE_UID   = QString::fromLatin1("-tmpl-");
+static const QString KORGANIZER_UID = QString::fromLatin1("-korg-");
+
+struct AlarmData
+{
+	const Alarm*           alarm;
+	QString                cleanText;       // text or audio file name
+	uint                   emailFromId;
+	EmailAddressList       emailAddresses;
+	QString                emailSubject;
+	QStringList            emailAttachments;
+	QFont                  font;
+	QColor                 bgColour, fgColour;
+	float                  soundVolume;
+	float                  fadeVolume;
+	int                    fadeSeconds;
+	int                    startOffsetSecs;
+	bool                   speak;
+	KAAlarm::SubType       type;
+	KAAlarmEventBase::Type action;
+	int                    displayingFlags;
+	bool                   defaultFont;
+	bool                   reminderOnceOnly;
+	bool                   isEmailText;
+	bool                   commandScript;
+	int                    repeatCount;
+	int                    repeatInterval;
+	int                    nextRepeat;
+};
+typedef QMap<KAAlarm::SubType, AlarmData> AlarmMap;
+
+static void setProcedureAlarm(Alarm*, const QString& commandLine);
+
+
+/*=============================================================================
+= Class KAEvent
+= Corresponds to a KCal::Event instance.
+=============================================================================*/
+
+inline void KAEvent::set_deferral(DeferType type)
+{
+	if (type)
+	{
+		if (!mDeferral)
+			++mAlarmCount;
+	}
+	else
+	{
+		if (mDeferral)
+			--mAlarmCount;
+	}
+	mDeferral = type;
+}
+
+inline void KAEvent::set_reminder(int minutes)
+{
+	if (minutes  &&  !mReminderMinutes)
+		++mAlarmCount;
+	else if (!minutes  &&  mReminderMinutes)
+		--mAlarmCount;
+	mReminderMinutes        = minutes;
+	mArchiveReminderMinutes = 0;
+}
+
+inline void KAEvent::set_archiveReminder()
+{
+	if (mReminderMinutes)
+		--mAlarmCount;
+	mArchiveReminderMinutes = mReminderMinutes;
+	mReminderMinutes        = 0;
+}
+
+
+void KAEvent::copy(const KAEvent& event)
+{
+	KAAlarmEventBase::copy(event);
+	mTemplateName            = event.mTemplateName;
+	mAudioFile               = event.mAudioFile;
+	mPreAction               = event.mPreAction;
+	mPostAction              = event.mPostAction;
+	mStartDateTime           = event.mStartDateTime;
+	mSaveDateTime            = event.mSaveDateTime;
+	mAtLoginDateTime         = event.mAtLoginDateTime;
+	mDeferralTime            = event.mDeferralTime;
+	mDisplayingTime          = event.mDisplayingTime;
+	mDisplayingFlags         = event.mDisplayingFlags;
+	mReminderMinutes         = event.mReminderMinutes;
+	mArchiveReminderMinutes  = event.mArchiveReminderMinutes;
+	mDeferDefaultMinutes     = event.mDeferDefaultMinutes;
+	mRevision                = event.mRevision;
+	mAlarmCount              = event.mAlarmCount;
+	mDeferral                = event.mDeferral;
+	mLogFile                 = event.mLogFile;
+	mCommandXterm            = event.mCommandXterm;
+	mKMailSerialNumber       = event.mKMailSerialNumber;
+	mCopyToKOrganizer        = event.mCopyToKOrganizer;
+	mReminderOnceOnly        = event.mReminderOnceOnly;
+	mMainExpired             = event.mMainExpired;
+	mArchiveRepeatAtLogin    = event.mArchiveRepeatAtLogin;
+	mArchive                 = event.mArchive;
+	mTemplateAfterTime       = event.mTemplateAfterTime;
+	mEnabled                 = event.mEnabled;
+	mUpdated                 = event.mUpdated;
+	delete mRecurrence;
+	if (event.mRecurrence)
+		mRecurrence = new KARecurrence(*event.mRecurrence);
+	else
+		mRecurrence = 0;
+}
+
+/******************************************************************************
+ * Initialise the KAEvent from a KCal::Event.
+ */
+void KAEvent::set(const Event& event)
+{
+	// Extract status from the event
+	mEventID                = event.uid();
+	mRevision               = event.revision();
+	mTemplateName           = QString::null;
+	mLogFile                = QString::null;
+	mTemplateAfterTime      = -1;
+	mBeep                   = false;
+	mSpeak                  = false;
+	mEmailBcc               = false;
+	mCommandXterm           = false;
+	mCopyToKOrganizer       = false;
+	mConfirmAck             = false;
+	mArchive                = false;
+	mReminderOnceOnly       = false;
+	mAutoClose              = false;
+	mArchiveRepeatAtLogin   = false;
+	mArchiveReminderMinutes = 0;
+	mDeferDefaultMinutes    = 0;
+	mLateCancel             = 0;
+	mKMailSerialNumber      = 0;
+	mBgColour               = QColor(255, 255, 255);    // missing/invalid colour - return white background
+	mFgColour               = QColor(0, 0, 0);          // and black foreground
+	mDefaultFont            = true;
+	mEnabled                = true;
+	clearRecur();
+	bool ok;
+	bool dateOnly = false;
+	const QStringList cats = event.categories();
+	for (unsigned int i = 0;  i < cats.count();  ++i)
+	{
+		if (cats[i] == DATE_ONLY_CATEGORY)
+			dateOnly = true;
+		else if (cats[i] == CONFIRM_ACK_CATEGORY)
+			mConfirmAck = true;
+		else if (cats[i] == EMAIL_BCC_CATEGORY)
+			mEmailBcc = true;
+		else if (cats[i] == ARCHIVE_CATEGORY)
+			mArchive = true;
+		else if (cats[i] == KORGANIZER_CATEGORY)
+			mCopyToKOrganizer = true;
+		else if (cats[i].startsWith(KMAIL_SERNUM_CATEGORY))
+			mKMailSerialNumber = cats[i].mid(KMAIL_SERNUM_CATEGORY.length()).toULong();
+		else if (cats[i].startsWith(LOG_CATEGORY))
+		{
+			QString logUrl = cats[i].mid(LOG_CATEGORY.length());
+			if (logUrl == xtermURL)
+				mCommandXterm = true;
+			else
+				mLogFile = logUrl;
+		}
+		else if (cats[i].startsWith(ARCHIVE_CATEGORIES))
+		{
+			// It's the archive flag plus a reminder time and/or repeat-at-login flag
+			mArchive = true;
+			QStringList list = QStringList::split(';', cats[i].mid(ARCHIVE_CATEGORIES.length()));
+			for (unsigned int j = 0;  j < list.count();  ++j)
+			{
+				if (list[j] == AT_LOGIN_TYPE)
+					mArchiveRepeatAtLogin = true;
+				else if (list[j] == ARCHIVE_REMINDER_ONCE_TYPE)
+					mReminderOnceOnly = true;
+				else
+				{
+					char ch;
+					const char* cat = list[j].latin1();
+					while ((ch = *cat) != 0  &&  (ch < '0' || ch > '9'))
+						++cat;
+					if (ch)
+					{
+						mArchiveReminderMinutes = ch - '0';
+						while ((ch = *++cat) >= '0'  &&  ch <= '9')
+							mArchiveReminderMinutes = mArchiveReminderMinutes * 10 + ch - '0';
+						switch (ch)
+						{
+							case 'M':  break;
+							case 'H':  mArchiveReminderMinutes *= 60;    break;
+							case 'D':  mArchiveReminderMinutes *= 1440;  break;
+						}
+					}
+				}
+			}
+		}
+		else if (cats[i].startsWith(DEFER_CATEGORY))
+		{
+			mDeferDefaultMinutes = static_cast<int>(cats[i].mid(DEFER_CATEGORY.length()).toUInt(&ok));
+			if (!ok)
+				mDeferDefaultMinutes = 0;    // invalid parameter
+		}
+		else if (cats[i].startsWith(TEMPL_AFTER_TIME_CATEGORY))
+		{
+			mTemplateAfterTime = static_cast<int>(cats[i].mid(TEMPL_AFTER_TIME_CATEGORY.length()).toUInt(&ok));
+			if (!ok)
+				mTemplateAfterTime = -1;    // invalid parameter
+		}
+		else if (cats[i].startsWith(LATE_CANCEL_CATEGORY))
+		{
+			mLateCancel = static_cast<int>(cats[i].mid(LATE_CANCEL_CATEGORY.length()).toUInt(&ok));
+			if (!ok  ||  !mLateCancel)
+				mLateCancel = 1;    // invalid parameter defaults to 1 minute
+		}
+		else if (cats[i].startsWith(AUTO_CLOSE_CATEGORY))
+		{
+			mLateCancel = static_cast<int>(cats[i].mid(AUTO_CLOSE_CATEGORY.length()).toUInt(&ok));
+			if (!ok  ||  !mLateCancel)
+				mLateCancel = 1;    // invalid parameter defaults to 1 minute
+			mAutoClose = true;
+		}
+	}
+	QString prop = event.customProperty(APPNAME, REPEAT_PROPERTY);
+	if (!prop.isEmpty())
+	{
+		// This property is used when the main alarm has expired
+		QStringList list = QStringList::split(':', prop);
+		if (list.count() >= 2)
+		{
+			int interval = static_cast<int>(list[0].toUInt());
+			int count = static_cast<int>(list[1].toUInt());
+			if (interval && count)
+			{
+				mRepeatInterval = interval;
+				mRepeatCount    = count;
+			}
+		}
+	}
+ 	mNextMainDateTime = readDateTime(event, dateOnly, mStartDateTime);
+	mSaveDateTime = event.created();
+	if (uidStatus() == TEMPLATE)
+		mTemplateName = event.summary();
+	if (event.statusStr() == DISABLED_STATUS)
+		mEnabled = false;
+
+	// Extract status from the event's alarms.
+	// First set up defaults.
+	mActionType        = T_MESSAGE;
+	mMainExpired       = true;
+	mRepeatAtLogin     = false;
+	mDisplaying        = false;
+	mRepeatSound       = false;
+	mCommandScript     = false;
+	mDeferral          = NO_DEFERRAL;
+	mSoundVolume       = -1;
+	mFadeVolume        = -1;
+	mFadeSeconds       = 0;
+	mReminderMinutes   = 0;
+	mEmailFromIdentity = 0;
+	mText              = "";
+	mAudioFile         = "";
+	mPreAction         = "";
+	mPostAction        = "";
+	mEmailSubject      = "";
+	mEmailAddresses.clear();
+	mEmailAttachments.clear();
+
+	// Extract data from all the event's alarms and index the alarms by sequence number
+	AlarmMap alarmMap;
+	readAlarms(event, &alarmMap);
+
+	// Incorporate the alarms' details into the overall event
+	mAlarmCount = 0;       // initialise as invalid
+	DateTime alTime;
+	bool set = false;
+	bool isEmailText = false;
+	bool setDeferralTime = false;
+	Duration deferralOffset;
+	for (AlarmMap::ConstIterator it = alarmMap.begin();  it != alarmMap.end();  ++it)
+	{
+		const AlarmData& data = it.data();
+		DateTime dateTime = data.alarm->hasStartOffset() ? mNextMainDateTime.addSecs(data.alarm->startOffset().asSeconds()) : data.alarm->time();
+		switch (data.type)
+		{
+			case KAAlarm::MAIN__ALARM:
+				mMainExpired = false;
+				alTime = dateTime;
+				alTime.setDateOnly(mStartDateTime.isDateOnly());
+				if (data.repeatCount  &&  data.repeatInterval)
+				{
+					mRepeatInterval = data.repeatInterval;   // values may be adjusted in setRecurrence()
+					mRepeatCount    = data.repeatCount;
+					mNextRepeat     = data.nextRepeat;
+				}
+				break;
+			case KAAlarm::AT_LOGIN__ALARM:
+				mRepeatAtLogin   = true;
+				mAtLoginDateTime = dateTime.rawDateTime();
+				alTime = mAtLoginDateTime;
+				break;
+			case KAAlarm::REMINDER__ALARM:
+				mReminderMinutes = -(data.startOffsetSecs / 60);
+				if (mReminderMinutes)
+					mArchiveReminderMinutes = 0;
+				break;
+			case KAAlarm::DEFERRED_REMINDER_DATE__ALARM:
+			case KAAlarm::DEFERRED_DATE__ALARM:
+				mDeferral = (data.type == KAAlarm::DEFERRED_REMINDER_DATE__ALARM) ? REMINDER_DEFERRAL : NORMAL_DEFERRAL;
+				mDeferralTime = dateTime;
+				mDeferralTime.setDateOnly(true);
+				if (data.alarm->hasStartOffset())
+					deferralOffset = data.alarm->startOffset();
+				break;
+			case KAAlarm::DEFERRED_REMINDER_TIME__ALARM:
+			case KAAlarm::DEFERRED_TIME__ALARM:
+				mDeferral = (data.type == KAAlarm::DEFERRED_REMINDER_TIME__ALARM) ? REMINDER_DEFERRAL : NORMAL_DEFERRAL;
+				mDeferralTime = dateTime;
+				if (data.alarm->hasStartOffset())
+					deferralOffset = data.alarm->startOffset();
+				break;
+			case KAAlarm::DISPLAYING__ALARM:
+			{
+				mDisplaying      = true;
+				mDisplayingFlags = data.displayingFlags;
+				bool dateOnly = (mDisplayingFlags & DEFERRAL) ? !(mDisplayingFlags & TIMED_FLAG)
+				              : mStartDateTime.isDateOnly();
+				mDisplayingTime = dateTime;
+				mDisplayingTime.setDateOnly(dateOnly);
+				alTime = mDisplayingTime;
+				break;
+			}
+			case KAAlarm::AUDIO__ALARM:
+				mAudioFile   = data.cleanText;
+				mSpeak       = data.speak  &&  mAudioFile.isEmpty();
+				mBeep        = !mSpeak  &&  mAudioFile.isEmpty();
+				mSoundVolume = (!mBeep && !mSpeak) ? data.soundVolume : -1;
+				mFadeVolume  = (mSoundVolume >= 0  &&  data.fadeSeconds > 0) ? data.fadeVolume : -1;
+				mFadeSeconds = (mFadeVolume >= 0) ? data.fadeSeconds : 0;
+				mRepeatSound = (!mBeep && !mSpeak)  &&  (data.repeatCount < 0);
+				break;
+			case KAAlarm::PRE_ACTION__ALARM:
+				mPreAction = data.cleanText;
+				break;
+			case KAAlarm::POST_ACTION__ALARM:
+				mPostAction = data.cleanText;
+				break;
+			case KAAlarm::INVALID__ALARM:
+			default:
+				break;
+		}
+
+		if (data.reminderOnceOnly)
+			mReminderOnceOnly = true;
+		bool noSetNextTime = false;
+		switch (data.type)
+		{
+			case KAAlarm::DEFERRED_REMINDER_DATE__ALARM:
+			case KAAlarm::DEFERRED_DATE__ALARM:
+			case KAAlarm::DEFERRED_REMINDER_TIME__ALARM:
+			case KAAlarm::DEFERRED_TIME__ALARM:
+				if (!set)
+				{
+					// The recurrence has to be evaluated before we can
+					// calculate the time of a deferral alarm.
+					setDeferralTime = true;
+					noSetNextTime = true;
+				}
+				// fall through to AT_LOGIN__ALARM etc.
+			case KAAlarm::AT_LOGIN__ALARM:
+			case KAAlarm::REMINDER__ALARM:
+			case KAAlarm::DISPLAYING__ALARM:
+				if (!set  &&  !noSetNextTime)
+					mNextMainDateTime = alTime;
+				// fall through to MAIN__ALARM
+			case KAAlarm::MAIN__ALARM:
+				// Ensure that the basic fields are set up even if there is no main
+				// alarm in the event (if it has expired and then been deferred)
+				if (!set)
+				{
+					mActionType = data.action;
+					mText = (mActionType == T_COMMAND) ? data.cleanText.stripWhiteSpace() : data.cleanText;
+					switch (data.action)
+					{
+						case T_MESSAGE:
+							mFont        = data.font;
+							mDefaultFont = data.defaultFont;
+							if (data.isEmailText)
+								isEmailText = true;
+							// fall through to T_FILE
+						case T_FILE:
+							mBgColour    = data.bgColour;
+							mFgColour    = data.fgColour;
+							break;
+						case T_COMMAND:
+							mCommandScript = data.commandScript;
+							break;
+						case T_EMAIL:
+							mEmailFromIdentity = data.emailFromId;
+							mEmailAddresses    = data.emailAddresses;
+							mEmailSubject      = data.emailSubject;
+							mEmailAttachments  = data.emailAttachments;
+							break;
+						default:
+							break;
+					}
+					set = true;
+				}
+				if (data.action == T_FILE  &&  mActionType == T_MESSAGE)
+					mActionType = T_FILE;
+				++mAlarmCount;
+				break;
+			case KAAlarm::AUDIO__ALARM:
+			case KAAlarm::PRE_ACTION__ALARM:
+			case KAAlarm::POST_ACTION__ALARM:
+			case KAAlarm::INVALID__ALARM:
+			default:
+				break;
+		}
+	}
+	if (!isEmailText)
+		mKMailSerialNumber = 0;
+	if (mRepeatAtLogin)
+		mArchiveRepeatAtLogin = false;
+
+	Recurrence* recur = event.recurrence();
+	if (recur  &&  recur->doesRecur())
+	{
+		int nextRepeat = mNextRepeat;    // setRecurrence() clears mNextRepeat
+		setRecurrence(*recur);
+		if (nextRepeat <= mRepeatCount)
+			mNextRepeat = nextRepeat;
+	}
+	else
+		checkRepetition();
+
+	if (mMainExpired  &&  deferralOffset.asSeconds()  &&  checkRecur() != KARecurrence::NO_RECUR)
+	{
+		// Adjust the deferral time for an expired recurrence, since the
+		// offset is relative to the first actual occurrence.
+		DateTime dt = mRecurrence->getNextDateTime(mStartDateTime.dateTime().addDays(-1));
+		dt.setDateOnly(mStartDateTime.isDateOnly());
+		if (mDeferralTime.isDateOnly())
+		{
+			mDeferralTime = dt.addSecs(deferralOffset.asSeconds());
+			mDeferralTime.setDateOnly(true);
+		}
+		else
+			mDeferralTime = deferralOffset.end(dt.dateTime());
+	}
+	if (mDeferral)
+	{
+		if (mNextMainDateTime == mDeferralTime)
+			mDeferral = CANCEL_DEFERRAL;     // it's a cancelled deferral
+		if (setDeferralTime)
+			mNextMainDateTime = mDeferralTime;
+	}
+
+	mUpdated = false;
+}
+
+/******************************************************************************
+* Fetch the start and next date/time for a KCal::Event.
+* Reply = next main date/time.
+*/
+DateTime KAEvent::readDateTime(const Event& event, bool dateOnly, DateTime& start)
+{
+	start.set(event.dtStart(), dateOnly);
+	DateTime next = start;
+	QString prop = event.customProperty(APPNAME, NEXT_RECUR_PROPERTY);
+	if (prop.length() >= 8)
+	{
+		// The next due recurrence time is specified
+		QDate d(prop.left(4).toInt(), prop.mid(4,2).toInt(), prop.mid(6,2).toInt());
+		if (d.isValid())
+		{
+			if (dateOnly  &&  prop.length() == 8)
+				next = d;
+			else if (!dateOnly  &&  prop.length() == 15  &&  prop[8] == QChar('T'))
+			{
+				QTime t(prop.mid(9,2).toInt(), prop.mid(11,2).toInt(), prop.mid(13,2).toInt());
+				if (t.isValid())
+					next = QDateTime(d, t);
+			}
+		}
+	}
+	return next;
+}
+
+/******************************************************************************
+ * Parse the alarms for a KCal::Event.
+ * Reply = map of alarm data, indexed by KAAlarm::Type
+ */
+void KAEvent::readAlarms(const Event& event, void* almap)
+{
+	AlarmMap* alarmMap = (AlarmMap*)almap;
+	Alarm::List alarms = event.alarms();
+	for (Alarm::List::ConstIterator it = alarms.begin();  it != alarms.end();  ++it)
+	{
+		// Parse the next alarm's text
+		AlarmData data;
+		readAlarm(**it, data);
+		if (data.type != KAAlarm::INVALID__ALARM)
+			alarmMap->insert(data.type, data);
+	}
+}
+
+/******************************************************************************
+ * Parse a KCal::Alarm.
+ * Reply = alarm ID (sequence number)
+ */
+void KAEvent::readAlarm(const Alarm& alarm, AlarmData& data)
+{
+	// Parse the next alarm's text
+	data.alarm           = &alarm;
+	data.startOffsetSecs = alarm.startOffset().asSeconds();    // can have start offset but no valid date/time (e.g. reminder in template)
+	data.displayingFlags = 0;
+	data.isEmailText     = false;
+	data.nextRepeat      = 0;
+	data.repeatInterval  = alarm.snoozeTime();
+	data.repeatCount     = alarm.repeatCount();
+	if (data.repeatCount)
+	{
+		bool ok;
+		QString property = alarm.customProperty(APPNAME, NEXT_REPEAT_PROPERTY);
+		int n = static_cast<int>(property.toUInt(&ok));
+		if (ok)
+			data.nextRepeat = n;
+	}
+	switch (alarm.type())
+	{
+		case Alarm::Procedure:
+			data.action        = T_COMMAND;
+			data.cleanText     = alarm.programFile();
+			data.commandScript = data.cleanText.isEmpty();   // blank command indicates a script
+			if (!alarm.programArguments().isEmpty())
+			{
+				if (!data.commandScript)
+					data.cleanText += ' ';
+				data.cleanText += alarm.programArguments();
+			}
+			break;
+		case Alarm::Email:
+			data.action           = T_EMAIL;
+			data.emailFromId      = alarm.customProperty(APPNAME, EMAIL_ID_PROPERTY).toUInt();
+			data.emailAddresses   = alarm.mailAddresses();
+			data.emailSubject     = alarm.mailSubject();
+			data.emailAttachments = alarm.mailAttachments();
+			data.cleanText        = alarm.mailText();
+			break;
+		case Alarm::Display:
+		{
+			data.action    = T_MESSAGE;
+			data.cleanText = AlarmText::fromCalendarText(alarm.text(), data.isEmailText);
+			QString property = alarm.customProperty(APPNAME, FONT_COLOUR_PROPERTY);
+			QStringList list = QStringList::split(QChar(';'), property, true);
+			data.bgColour = QColor(255, 255, 255);   // white
+			data.fgColour = QColor(0, 0, 0);         // black
+			int n = list.count();
+			if (n > 0)
+			{
+				if (!list[0].isEmpty())
+				{
+					QColor c(list[0]);
+					if (c.isValid())
+						data.bgColour = c;
+				}
+				if (n > 1  &&  !list[1].isEmpty())
+				{
+					QColor c(list[1]);
+					if (c.isValid())
+						data.fgColour = c;
+				}
+			}
+			data.defaultFont = (n <= 2 || list[2].isEmpty());
+			if (!data.defaultFont)
+				data.font.fromString(list[2]);
+			break;
+		}
+		case Alarm::Audio:
+		{
+			data.action      = T_AUDIO;
+			data.cleanText   = alarm.audioFile();
+			data.type        = KAAlarm::AUDIO__ALARM;
+			data.soundVolume = -1;
+			data.fadeVolume  = -1;
+			data.fadeSeconds = 0;
+			data.speak       = !alarm.customProperty(APPNAME, SPEAK_PROPERTY).isNull();
+			QString property = alarm.customProperty(APPNAME, VOLUME_PROPERTY);
+			if (!property.isEmpty())
+			{
+				bool ok;
+				float fadeVolume;
+				int   fadeSecs = 0;
+				QStringList list = QStringList::split(QChar(';'), property, true);
+				data.soundVolume = list[0].toFloat(&ok);
+				if (!ok)
+					data.soundVolume = -1;
+				if (data.soundVolume >= 0  &&  list.count() >= 3)
+				{
+					fadeVolume = list[1].toFloat(&ok);
+					if (ok)
+						fadeSecs = static_cast<int>(list[2].toUInt(&ok));
+					if (ok  &&  fadeVolume >= 0  &&  fadeSecs > 0)
+					{
+						data.fadeVolume  = fadeVolume;
+						data.fadeSeconds = fadeSecs;
+					}
+				}
+			}
+			return;
+		}
+		case Alarm::Invalid:
+			data.type = KAAlarm::INVALID__ALARM;
+			return;
+	}
+
+	bool atLogin          = false;
+	bool reminder         = false;
+	bool deferral         = false;
+	bool dateDeferral     = false;
+	data.reminderOnceOnly = false;
+	data.type = KAAlarm::MAIN__ALARM;
+	QString property = alarm.customProperty(APPNAME, TYPE_PROPERTY);
+	QStringList types = QStringList::split(QChar(','), property);
+	for (unsigned int i = 0;  i < types.count();  ++i)
+	{
+		QString type = types[i];
+		if (type == AT_LOGIN_TYPE)
+			atLogin = true;
+		else if (type == FILE_TYPE  &&  data.action == T_MESSAGE)
+			data.action = T_FILE;
+		else if (type == REMINDER_TYPE)
+			reminder = true;
+		else if (type == REMINDER_ONCE_TYPE)
+			reminder = data.reminderOnceOnly = true;
+		else if (type == TIME_DEFERRAL_TYPE)
+			deferral = true;
+		else if (type == DATE_DEFERRAL_TYPE)
+			dateDeferral = deferral = true;
+		else if (type == DISPLAYING_TYPE)
+			data.type = KAAlarm::DISPLAYING__ALARM;
+		else if (type == PRE_ACTION_TYPE  &&  data.action == T_COMMAND)
+			data.type = KAAlarm::PRE_ACTION__ALARM;
+		else if (type == POST_ACTION_TYPE  &&  data.action == T_COMMAND)
+			data.type = KAAlarm::POST_ACTION__ALARM;
+	}
+
+	if (reminder)
+	{
+		if (data.type == KAAlarm::MAIN__ALARM)
+			data.type = dateDeferral ? KAAlarm::DEFERRED_REMINDER_DATE__ALARM
+			          : deferral ? KAAlarm::DEFERRED_REMINDER_TIME__ALARM : KAAlarm::REMINDER__ALARM;
+		else if (data.type == KAAlarm::DISPLAYING__ALARM)
+			data.displayingFlags = dateDeferral ? REMINDER | DATE_DEFERRAL
+			                     : deferral ? REMINDER | TIME_DEFERRAL : REMINDER;
+	}
+	else if (deferral)
+	{
+		if (data.type == KAAlarm::MAIN__ALARM)
+			data.type = dateDeferral ? KAAlarm::DEFERRED_DATE__ALARM : KAAlarm::DEFERRED_TIME__ALARM;
+		else if (data.type == KAAlarm::DISPLAYING__ALARM)
+			data.displayingFlags = dateDeferral ? DATE_DEFERRAL : TIME_DEFERRAL;
+	}
+	if (atLogin)
+	{
+		if (data.type == KAAlarm::MAIN__ALARM)
+			data.type = KAAlarm::AT_LOGIN__ALARM;
+		else if (data.type == KAAlarm::DISPLAYING__ALARM)
+			data.displayingFlags = REPEAT_AT_LOGIN;
+	}
+//kdDebug(5950)<<"ReadAlarm(): text="<<alarm.text()<<", time="<<alarm.time().toString()<<", valid time="<<alarm.time().isValid()<<endl;
+}
+
+/******************************************************************************
+ * Initialise the KAEvent with the specified parameters.
+ */
+void KAEvent::set(const QDateTime& dateTime, const QString& text, const QColor& bg, const QColor& fg,
+                  const QFont& font, Action action, int lateCancel, int flags)
+{
+	clearRecur();
+	mStartDateTime.set(dateTime, flags & ANY_TIME);
+	mNextMainDateTime = mStartDateTime;
+	switch (action)
+	{
+		case MESSAGE:
+		case FILE:
+		case COMMAND:
+		case EMAIL:
+			mActionType = (KAAlarmEventBase::Type)action;
+			break;
+		default:
+			mActionType = T_MESSAGE;
+			break;
+	}
+	mText                   = (mActionType == T_COMMAND) ? text.stripWhiteSpace() : text;
+	mEventID                = QString::null;
+	mTemplateName           = QString::null;
+	mPreAction              = QString::null;
+	mPostAction             = QString::null;
+	mAudioFile              = "";
+	mSoundVolume            = -1;
+	mFadeVolume             = -1;
+	mTemplateAfterTime      = -1;
+	mFadeSeconds            = 0;
+	mBgColour               = bg;
+	mFgColour               = fg;
+	mFont                   = font;
+	mAlarmCount             = 1;
+	mLateCancel             = lateCancel;     // do this before setting flags
+	mDeferral               = NO_DEFERRAL;    // do this before setting flags
+
+	KAAlarmEventBase::set(flags & ~READ_ONLY_FLAGS);
+	mStartDateTime.setDateOnly(flags & ANY_TIME);
+	set_deferral((flags & DEFERRAL) ? NORMAL_DEFERRAL : NO_DEFERRAL);
+	mCommandXterm           = flags & EXEC_IN_XTERM;
+	mCopyToKOrganizer       = flags & COPY_KORGANIZER;
+	mEnabled                = !(flags & DISABLED);
+
+	mKMailSerialNumber      = 0;
+	mReminderMinutes        = 0;
+	mArchiveReminderMinutes = 0;
+	mDeferDefaultMinutes    = 0;
+	mArchiveRepeatAtLogin   = false;
+	mReminderOnceOnly       = false;
+	mDisplaying             = false;
+	mMainExpired            = false;
+	mArchive                = false;
+	mUpdated                = false;
+}
+
+void KAEvent::setLogFile(const QString& logfile)
+{
+	mLogFile = logfile;
+	if (!logfile.isEmpty())
+		mCommandXterm = false;
+}
+
+void KAEvent::setEmail(uint from, const EmailAddressList& addresses, const QString& subject, const QStringList& attachments)
+{
+	mEmailFromIdentity = from;
+	mEmailAddresses    = addresses;
+	mEmailSubject      = subject;
+	mEmailAttachments  = attachments;
+}
+
+void KAEvent::setAudioFile(const QString& filename, float volume, float fadeVolume, int fadeSeconds)
+{
+	mAudioFile = filename;
+	mSoundVolume = filename.isEmpty() ? -1 : volume;
+	if (mSoundVolume >= 0)
+	{
+		mFadeVolume  = (fadeSeconds > 0) ? fadeVolume : -1;
+		mFadeSeconds = (mFadeVolume >= 0) ? fadeSeconds : 0;
+	}
+	else
+	{
+		mFadeVolume  = -1;
+		mFadeSeconds = 0;
+	}
+	mUpdated = true;
+}
+
+void KAEvent::setReminder(int minutes, bool onceOnly)
+{
+	if (minutes != mReminderMinutes)
+	{
+		set_reminder(minutes);
+		mReminderOnceOnly = onceOnly;
+		mUpdated          = true;
+	}
+}
+
+/******************************************************************************
+ * Return the time of the next scheduled occurrence of the event.
+ * Reminders and deferred reminders can optionally be ignored.
+ */
+DateTime KAEvent::displayDateTime() const
+{
+	DateTime dt = mainDateTime(true);
+	if (mDeferral > 0  &&  mDeferral != REMINDER_DEFERRAL)
+	{
+		if (mMainExpired)
+			return mDeferralTime;
+		return QMIN(mDeferralTime, dt);
+	}
+	return dt;
+}
+
+/******************************************************************************
+ * Convert a unique ID to indicate that the event is in a specified calendar file.
+ */
+QString KAEvent::uid(const QString& id, Status status)
+{
+	QString result = id;
+	Status oldStatus;
+	int i, len;
+	if ((i = result.find(EXPIRED_UID)) > 0)
+	{
+		oldStatus = EXPIRED;
+		len = EXPIRED_UID.length();
+	}
+	else if ((i = result.find(DISPLAYING_UID)) > 0)
+	{
+		oldStatus = DISPLAYING;
+		len = DISPLAYING_UID.length();
+	}
+	else if ((i = result.find(TEMPLATE_UID)) > 0)
+	{
+		oldStatus = TEMPLATE;
+		len = TEMPLATE_UID.length();
+	}
+	else if ((i = result.find(KORGANIZER_UID)) > 0)
+	{
+		oldStatus = KORGANIZER;
+		len = KORGANIZER_UID.length();
+	}
+	else
+	{
+		oldStatus = ACTIVE;
+		i = result.findRev('-');
+		len = 1;
+	}
+	if (status != oldStatus  &&  i > 0)
+	{
+		QString part;
+		switch (status)
+		{
+			case ACTIVE:      part = "-";  break;
+			case EXPIRED:     part = EXPIRED_UID;  break;
+			case DISPLAYING:  part = DISPLAYING_UID;  break;
+			case TEMPLATE:    part = TEMPLATE_UID;  break;
+			case KORGANIZER:  part = KORGANIZER_UID;  break;
+		}
+		result.replace(i, len, part);
+	}
+	return result;
+}
+
+/******************************************************************************
+ * Get the calendar type for a unique ID.
+ */
+KAEvent::Status KAEvent::uidStatus(const QString& uid)
+{
+	if (uid.find(EXPIRED_UID) > 0)
+		return EXPIRED;
+	if (uid.find(DISPLAYING_UID) > 0)
+		return DISPLAYING;
+	if (uid.find(TEMPLATE_UID) > 0)
+		return TEMPLATE;
+	if (uid.find(KORGANIZER_UID) > 0)
+		return KORGANIZER;
+	return ACTIVE;
+}
+
+int KAEvent::flags() const
+{
+	return KAAlarmEventBase::flags()
+	     | (mStartDateTime.isDateOnly() ? ANY_TIME : 0)
+	     | (mDeferral > 0               ? DEFERRAL : 0)
+	     | (mCommandXterm               ? EXEC_IN_XTERM : 0)
+	     | (mCopyToKOrganizer           ? COPY_KORGANIZER : 0)
+	     | (mEnabled                    ? 0 : DISABLED);
+}
+
+/******************************************************************************
+ * Create a new Event from the KAEvent data.
+ */
+Event* KAEvent::event() const
+{
+	KCal::Event* ev = new KCal::Event;
+	ev->setUid(mEventID);
+	updateKCalEvent(*ev, false);
+	return ev;
+}
+
+/******************************************************************************
+ * Update an existing KCal::Event with the KAEvent data.
+ * If 'original' is true, the event start date/time is adjusted to its original
+ * value instead of its next occurrence, and the expired main alarm is
+ * reinstated.
+ */
+bool KAEvent::updateKCalEvent(Event& ev, bool checkUid, bool original, bool cancelCancelledDefer) const
+{
+	if (checkUid  &&  !mEventID.isEmpty()  &&  mEventID != ev.uid()
+	||  !mAlarmCount  &&  (!original || !mMainExpired))
+		return false;
+
+	checkRecur();     // ensure recurrence/repetition data is consistent
+	bool readOnly = ev.isReadOnly();
+	ev.setReadOnly(false);
+	ev.setTransparency(Event::Transparent);
+
+	// Set up event-specific data
+
+	// Set up custom properties.
+	ev.removeCustomProperty(APPNAME, NEXT_RECUR_PROPERTY);
+	ev.removeCustomProperty(APPNAME, REPEAT_PROPERTY);
+
+	QStringList cats;
+	if (mStartDateTime.isDateOnly())
+		cats.append(DATE_ONLY_CATEGORY);
+	if (mConfirmAck)
+		cats.append(CONFIRM_ACK_CATEGORY);
+	if (mEmailBcc)
+		cats.append(EMAIL_BCC_CATEGORY);
+	if (mKMailSerialNumber)
+		cats.append(QString("%1%2").arg(KMAIL_SERNUM_CATEGORY).arg(mKMailSerialNumber));
+	if (mCopyToKOrganizer)
+		cats.append(KORGANIZER_CATEGORY);
+	if (mCommandXterm)
+		cats.append(LOG_CATEGORY + xtermURL);
+	else if (!mLogFile.isEmpty())
+		cats.append(LOG_CATEGORY + mLogFile);
+	if (mLateCancel)
+		cats.append(QString("%1%2").arg(mAutoClose ? AUTO_CLOSE_CATEGORY : LATE_CANCEL_CATEGORY).arg(mLateCancel));
+	if (mDeferDefaultMinutes)
+		cats.append(QString("%1%2").arg(DEFER_CATEGORY).arg(mDeferDefaultMinutes));
+	if (!mTemplateName.isEmpty()  &&  mTemplateAfterTime >= 0)
+		cats.append(QString("%1%2").arg(TEMPL_AFTER_TIME_CATEGORY).arg(mTemplateAfterTime));
+	if (mArchive  &&  !original)
+	{
+		QStringList params;
+		if (mArchiveReminderMinutes)
+		{
+			if (mReminderOnceOnly)
+				params += ARCHIVE_REMINDER_ONCE_TYPE;
+			char unit = 'M';
+			int count = mArchiveReminderMinutes;
+			if (count % 1440 == 0)
+			{
+				unit = 'D';
+				count /= 1440;
+			}
+			else if (count % 60 == 0)
+			{
+				unit = 'H';
+				count /= 60;
+			}
+			params += QString("%1%2").arg(count).arg(unit);
+		}
+		if (mArchiveRepeatAtLogin)
+			params += AT_LOGIN_TYPE;
+		if (params.count() > 0)
+		{
+			QString cat = ARCHIVE_CATEGORIES;
+			cat += params.join(QString::fromLatin1(";"));
+			cats.append(cat);
+		}
+		else
+			cats.append(ARCHIVE_CATEGORY);
+	}
+	ev.setCategories(cats);
+	ev.setCustomStatus(mEnabled ? QString::null : DISABLED_STATUS);
+	ev.setRevision(mRevision);
+	ev.clearAlarms();
+
+	// Always set DTSTART as date/time, since alarm times can only be specified
+	// in local time (instead of UTC) if they are relative to a DTSTART or DTEND
+	// which is also specified in local time. Instead of calling setFloats() to
+	// indicate a date-only event, the category "DATE" is included.
+	ev.setDtStart(mStartDateTime.dateTime());
+	ev.setFloats(false);
+	ev.setHasEndDate(false);
+
+	DateTime dtMain = original ? mStartDateTime : mNextMainDateTime;
+	int      ancillaryType = 0;   // 0 = invalid, 1 = time, 2 = offset
+	DateTime ancillaryTime;       // time for ancillary alarms (audio, pre-action, etc)
+	int      ancillaryOffset = 0; // start offset for ancillary alarms
+	if (!mMainExpired  ||  original)
+	{
+		/* The alarm offset must always be zero for the main alarm. To determine
+		 * which recurrence is due, the property X-KDE-KALARM_NEXTRECUR is used.
+		 * If the alarm offset was non-zero, exception dates and rules would not
+		 * work since they apply to the event time, not the alarm time.
+		 */
+		if (!original  &&  checkRecur() != KARecurrence::NO_RECUR)
+		{
+			QDateTime dt = mNextMainDateTime.dateTime();
+			ev.setCustomProperty(APPNAME, NEXT_RECUR_PROPERTY,
+			                     dt.toString(mNextMainDateTime.isDateOnly() ? "yyyyMMdd" : "yyyyMMddThhmmss"));
+		}
+		// Add the main alarm
+		initKCalAlarm(ev, 0, QStringList(), KAAlarm::MAIN_ALARM);
+		ancillaryOffset = 0;
+		ancillaryType = dtMain.isValid() ? 2 : 0;
+	}
+	else if (mRepeatCount  &&  mRepeatInterval)
+	{
+		// Alarm repetition is normally held in the main alarm, but since
+		// the main alarm has expired, store in a custom property.
+		QString param = QString("%1:%2").arg(mRepeatInterval).arg(mRepeatCount);
+		ev.setCustomProperty(APPNAME, REPEAT_PROPERTY, param);
+	}
+
+	// Add subsidiary alarms
+	if (mRepeatAtLogin  ||  mArchiveRepeatAtLogin && original)
+	{
+		DateTime dtl;
+		if (mArchiveRepeatAtLogin)
+			dtl = mStartDateTime.dateTime().addDays(-1);
+		else if (mAtLoginDateTime.isValid())
+			dtl = mAtLoginDateTime;
+		else if (mStartDateTime.isDateOnly())
+			dtl = QDate::currentDate().addDays(-1);
+		else
+			dtl = QDateTime::currentDateTime();
+		initKCalAlarm(ev, dtl, AT_LOGIN_TYPE);
+		if (!ancillaryType  &&  dtl.isValid())
+		{
+			ancillaryTime = dtl;
+			ancillaryType = 1;
+		}
+	}
+	if (mReminderMinutes  ||  mArchiveReminderMinutes && original)
+	{
+		int minutes = mReminderMinutes ? mReminderMinutes : mArchiveReminderMinutes;
+		initKCalAlarm(ev, -minutes * 60, QStringList(mReminderOnceOnly ? REMINDER_ONCE_TYPE : REMINDER_TYPE));
+		if (!ancillaryType)
+		{
+			ancillaryOffset = -minutes * 60;
+			ancillaryType = 2;
+		}
+	}
+	if (mDeferral > 0  ||  mDeferral == CANCEL_DEFERRAL && !cancelCancelledDefer)
+	{
+		DateTime nextDateTime = mNextMainDateTime;
+		if (mMainExpired)
+		{
+			if (checkRecur() == KARecurrence::NO_RECUR)
+				nextDateTime = mStartDateTime;
+			else if (!original)
+			{
+				// It's a deferral of an expired recurrence.
+				// Need to ensure that the alarm offset is to an occurrence
+				// which isn't excluded by an exception - otherwise, it will
+				// never be triggered. So choose the first recurrence which
+				// isn't an exception.
+				nextDateTime = mRecurrence->getNextDateTime(mStartDateTime.dateTime().addDays(-1));
+				nextDateTime.setDateOnly(mStartDateTime.isDateOnly());
+			}
+		}
+		int startOffset;
+		QStringList list;
+		if (mDeferralTime.isDateOnly())
+		{
+			startOffset = nextDateTime.secsTo(mDeferralTime.dateTime());
+			list += DATE_DEFERRAL_TYPE;
+		}
+		else
+		{
+			startOffset = nextDateTime.dateTime().secsTo(mDeferralTime.dateTime());
+			list += TIME_DEFERRAL_TYPE;
+		}
+		if (mDeferral == REMINDER_DEFERRAL)
+			list += mReminderOnceOnly ? REMINDER_ONCE_TYPE : REMINDER_TYPE;
+		initKCalAlarm(ev, startOffset, list);
+		if (!ancillaryType  &&  mDeferralTime.isValid())
+		{
+			ancillaryOffset = startOffset;
+			ancillaryType = 2;
+		}
+	}
+	if (!mTemplateName.isEmpty())
+		ev.setSummary(mTemplateName);
+	else if (mDisplaying)
+	{
+		QStringList list(DISPLAYING_TYPE);
+		if (mDisplayingFlags & REPEAT_AT_LOGIN)
+			list += AT_LOGIN_TYPE;
+		else if (mDisplayingFlags & DEFERRAL)
+		{
+			if (mDisplayingFlags & TIMED_FLAG)
+				list += TIME_DEFERRAL_TYPE;
+			else
+				list += DATE_DEFERRAL_TYPE;
+		}
+		if (mDisplayingFlags & REMINDER)
+			list += mReminderOnceOnly ? REMINDER_ONCE_TYPE : REMINDER_TYPE;
+		initKCalAlarm(ev, mDisplayingTime, list);
+		if (!ancillaryType  &&  mDisplayingTime.isValid())
+		{
+			ancillaryTime = mDisplayingTime;
+			ancillaryType = 1;
+		}
+	}
+	if (mBeep  ||  mSpeak  ||  !mAudioFile.isEmpty())
+	{
+		// A sound is specified
+		if (ancillaryType == 2)
+			initKCalAlarm(ev, ancillaryOffset, QStringList(), KAAlarm::AUDIO_ALARM);
+		else
+			initKCalAlarm(ev, ancillaryTime, QStringList(), KAAlarm::AUDIO_ALARM);
+	}
+	if (!mPreAction.isEmpty())
+	{
+		// A pre-display action is specified
+		if (ancillaryType == 2)
+			initKCalAlarm(ev, ancillaryOffset, QStringList(PRE_ACTION_TYPE), KAAlarm::PRE_ACTION_ALARM);
+		else
+			initKCalAlarm(ev, ancillaryTime, QStringList(PRE_ACTION_TYPE), KAAlarm::PRE_ACTION_ALARM);
+	}
+	if (!mPostAction.isEmpty())
+	{
+		// A post-display action is specified
+		if (ancillaryType == 2)
+			initKCalAlarm(ev, ancillaryOffset, QStringList(POST_ACTION_TYPE), KAAlarm::POST_ACTION_ALARM);
+		else
+			initKCalAlarm(ev, ancillaryTime, QStringList(POST_ACTION_TYPE), KAAlarm::POST_ACTION_ALARM);
+	}
+
+	if (mRecurrence)
+		mRecurrence->writeRecurrence(*ev.recurrence());
+	else
+		ev.clearRecurrence();
+	if (mSaveDateTime.isValid())
+		ev.setCreated(mSaveDateTime);
+	ev.setReadOnly(readOnly);
+	return true;
+}
+
+/******************************************************************************
+ * Create a new alarm for a libkcal event, and initialise it according to the
+ * alarm action. If 'types' is non-null, it is appended to the X-KDE-KALARM-TYPE
+ * property value list.
+ */
+Alarm* KAEvent::initKCalAlarm(Event& event, const DateTime& dt, const QStringList& types, KAAlarm::Type type) const
+{
+	int startOffset = dt.isDateOnly() ? mStartDateTime.secsTo(dt)
+	                                  : mStartDateTime.dateTime().secsTo(dt.dateTime());
+	return initKCalAlarm(event, startOffset, types, type);
+}
+
+Alarm* KAEvent::initKCalAlarm(Event& event, int startOffsetSecs, const QStringList& types, KAAlarm::Type type) const
+{
+	QStringList alltypes;
+	Alarm* alarm = event.newAlarm();
+	alarm->setEnabled(true);
+	if (type != KAAlarm::MAIN_ALARM)
+	{
+		// RFC2445 specifies that absolute alarm times must be stored as UTC.
+		// So, in order to store local times, set the alarm time as an offset to DTSTART.
+		alarm->setStartOffset(startOffsetSecs);
+	}
+
+	switch (type)
+	{
+		case KAAlarm::AUDIO_ALARM:
+			alarm->setAudioAlarm(mAudioFile);  // empty for a beep or for speaking
+			if (mSpeak)
+				alarm->setCustomProperty(APPNAME, SPEAK_PROPERTY, QString::fromLatin1("Y"));
+			if (mRepeatSound)
+			{
+				alarm->setRepeatCount(-1);
+				alarm->setSnoozeTime(0);
+			}
+			if (!mAudioFile.isEmpty()  &&  mSoundVolume >= 0)
+				alarm->setCustomProperty(APPNAME, VOLUME_PROPERTY,
+				              QString::fromLatin1("%1;%2;%3").arg(QString::number(mSoundVolume, 'f', 2))
+				                                             .arg(QString::number(mFadeVolume, 'f', 2))
+				                                             .arg(mFadeSeconds));
+			break;
+		case KAAlarm::PRE_ACTION_ALARM:
+			setProcedureAlarm(alarm, mPreAction);
+			break;
+		case KAAlarm::POST_ACTION_ALARM:
+			setProcedureAlarm(alarm, mPostAction);
+			break;
+		case KAAlarm::MAIN_ALARM:
+			alarm->setSnoozeTime(mRepeatInterval);
+			alarm->setRepeatCount(mRepeatCount);
+			if (mRepeatCount)
+				alarm->setCustomProperty(APPNAME, NEXT_REPEAT_PROPERTY,
+				                         QString::number(mNextRepeat));
+			// fall through to INVALID_ALARM
+		case KAAlarm::INVALID_ALARM:
+			switch (mActionType)
+			{
+				case T_FILE:
+					alltypes += FILE_TYPE;
+					// fall through to T_MESSAGE
+				case T_MESSAGE:
+					alarm->setDisplayAlarm(AlarmText::toCalendarText(mText));
+					alarm->setCustomProperty(APPNAME, FONT_COLOUR_PROPERTY,
+						      QString::fromLatin1("%1;%2;%3").arg(mBgColour.name())
+										     .arg(mFgColour.name())
+										     .arg(mDefaultFont ? QString::null : mFont.toString()));
+					break;
+				case T_COMMAND:
+					if (mCommandScript)
+						alarm->setProcedureAlarm("", mText);
+					else
+						setProcedureAlarm(alarm, mText);
+					break;
+				case T_EMAIL:
+					alarm->setEmailAlarm(mEmailSubject, mText, mEmailAddresses, mEmailAttachments);
+					if (mEmailFromIdentity)
+						alarm->setCustomProperty(APPNAME, EMAIL_ID_PROPERTY, QString::number(mEmailFromIdentity));
+					break;
+				case T_AUDIO:
+					break;
+			}
+			break;
+		case KAAlarm::REMINDER_ALARM:
+		case KAAlarm::DEFERRED_ALARM:
+		case KAAlarm::DEFERRED_REMINDER_ALARM:
+		case KAAlarm::AT_LOGIN_ALARM:
+		case KAAlarm::DISPLAYING_ALARM:
+			break;
+	}
+	alltypes += types;
+	if (alltypes.count() > 0)
+		alarm->setCustomProperty(APPNAME, TYPE_PROPERTY, alltypes.join(","));
+	return alarm;
+}
+
+/******************************************************************************
+ * Return the alarm of the specified type.
+ */
+KAAlarm KAEvent::alarm(KAAlarm::Type type) const
+{
+	checkRecur();     // ensure recurrence/repetition data is consistent
+	KAAlarm al;       // this sets type to INVALID_ALARM
+	if (mAlarmCount)
+	{
+		al.mEventID        = mEventID;
+		al.mActionType     = mActionType;
+		al.mText           = mText;
+		al.mBgColour       = mBgColour;
+		al.mFgColour       = mFgColour;
+		al.mFont           = mFont;
+		al.mDefaultFont    = mDefaultFont;
+		al.mBeep           = mBeep;
+		al.mSpeak          = mSpeak;
+		al.mSoundVolume    = mSoundVolume;
+		al.mFadeVolume     = mFadeVolume;
+		al.mFadeSeconds    = mFadeSeconds;
+		al.mRepeatSound    = mRepeatSound;
+		al.mConfirmAck     = mConfirmAck;
+		al.mRepeatCount    = 0;
+		al.mRepeatInterval = 0;
+		al.mRepeatAtLogin  = false;
+		al.mDeferred       = false;
+		al.mLateCancel     = mLateCancel;
+		al.mAutoClose      = mAutoClose;
+		al.mEmailBcc       = mEmailBcc;
+		al.mCommandScript  = mCommandScript;
+		if (mActionType == T_EMAIL)
+		{
+			al.mEmailFromIdentity = mEmailFromIdentity;
+			al.mEmailAddresses    = mEmailAddresses;
+			al.mEmailSubject      = mEmailSubject;
+			al.mEmailAttachments  = mEmailAttachments;
+		}
+		switch (type)
+		{
+			case KAAlarm::MAIN_ALARM:
+				if (!mMainExpired)
+				{
+					al.mType             = KAAlarm::MAIN__ALARM;
+					al.mNextMainDateTime = mNextMainDateTime;
+					al.mRepeatCount      = mRepeatCount;
+					al.mRepeatInterval   = mRepeatInterval;
+					al.mNextRepeat       = mNextRepeat;
+				}
+				break;
+			case KAAlarm::REMINDER_ALARM:
+				if (mReminderMinutes)
+				{
+					al.mType = KAAlarm::REMINDER__ALARM;
+					if (mReminderOnceOnly)
+						al.mNextMainDateTime = mStartDateTime.addMins(-mReminderMinutes);
+					else
+						al.mNextMainDateTime = mNextMainDateTime.addMins(-mReminderMinutes);
+				}
+				break;
+			case KAAlarm::DEFERRED_REMINDER_ALARM:
+				if (mDeferral != REMINDER_DEFERRAL)
+					break;
+				// fall through to DEFERRED_ALARM
+			case KAAlarm::DEFERRED_ALARM:
+				if (mDeferral > 0)
+				{
+					al.mType = static_cast<KAAlarm::SubType>((mDeferral == REMINDER_DEFERRAL ? KAAlarm::DEFERRED_REMINDER_ALARM : KAAlarm::DEFERRED_ALARM)
+					                                         | (mDeferralTime.isDateOnly() ? 0 : KAAlarm::TIMED_DEFERRAL_FLAG));
+					al.mNextMainDateTime = mDeferralTime;
+					al.mDeferred         = true;
+				}
+				break;
+			case KAAlarm::AT_LOGIN_ALARM:
+				if (mRepeatAtLogin)
+				{
+					al.mType             = KAAlarm::AT_LOGIN__ALARM;
+					al.mNextMainDateTime = mAtLoginDateTime;
+					al.mRepeatAtLogin    = true;
+					al.mLateCancel       = 0;
+					al.mAutoClose        = false;
+				}
+				break;
+			case KAAlarm::DISPLAYING_ALARM:
+				if (mDisplaying)
+				{
+					al.mType             = KAAlarm::DISPLAYING__ALARM;
+					al.mNextMainDateTime = mDisplayingTime;
+					al.mDisplaying       = true;
+				}
+				break;
+			case KAAlarm::AUDIO_ALARM:
+			case KAAlarm::PRE_ACTION_ALARM:
+			case KAAlarm::POST_ACTION_ALARM:
+			case KAAlarm::INVALID_ALARM:
+			default:
+				break;
+		}
+	}
+	return al;
+}
+
+/******************************************************************************
+ * Return the main alarm for the event.
+ * If the main alarm does not exist, one of the subsidiary ones is returned if
+ * possible.
+ * N.B. a repeat-at-login alarm can only be returned if it has been read from/
+ * written to the calendar file.
+ */
+KAAlarm KAEvent::firstAlarm() const
+{
+	if (mAlarmCount)
+	{
+		if (!mMainExpired)
+			return alarm(KAAlarm::MAIN_ALARM);
+		return nextAlarm(KAAlarm::MAIN_ALARM);
+	}
+	return KAAlarm();
+}
+
+/******************************************************************************
+ * Return the next alarm for the event, after the specified alarm.
+ * N.B. a repeat-at-login alarm can only be returned if it has been read from/
+ * written to the calendar file.
+ */
+KAAlarm KAEvent::nextAlarm(KAAlarm::Type prevType) const
+{
+	switch (prevType)
+	{
+		case KAAlarm::MAIN_ALARM:
+			if (mReminderMinutes)
+				return alarm(KAAlarm::REMINDER_ALARM);
+			// fall through to REMINDER_ALARM
+		case KAAlarm::REMINDER_ALARM:
+			// There can only be one deferral alarm
+			if (mDeferral == REMINDER_DEFERRAL)
+				return alarm(KAAlarm::DEFERRED_REMINDER_ALARM);
+			if (mDeferral == NORMAL_DEFERRAL)
+				return alarm(KAAlarm::DEFERRED_ALARM);
+			// fall through to DEFERRED_ALARM
+		case KAAlarm::DEFERRED_REMINDER_ALARM:
+		case KAAlarm::DEFERRED_ALARM:
+			if (mRepeatAtLogin)
+				return alarm(KAAlarm::AT_LOGIN_ALARM);
+			// fall through to AT_LOGIN_ALARM
+		case KAAlarm::AT_LOGIN_ALARM:
+			if (mDisplaying)
+				return alarm(KAAlarm::DISPLAYING_ALARM);
+			// fall through to DISPLAYING_ALARM
+		case KAAlarm::DISPLAYING_ALARM:
+			// fall through to default
+		case KAAlarm::AUDIO_ALARM:
+		case KAAlarm::PRE_ACTION_ALARM:
+		case KAAlarm::POST_ACTION_ALARM:
+		case KAAlarm::INVALID_ALARM:
+		default:
+			break;
+	}
+	return KAAlarm();
+}
+
+/******************************************************************************
+ * Remove the alarm of the specified type from the event.
+ * This must only be called to remove an alarm which has expired, not to
+ * reconfigure the event.
+ */
+void KAEvent::removeExpiredAlarm(KAAlarm::Type type)
+{
+	int count = mAlarmCount;
+	switch (type)
+	{
+		case KAAlarm::MAIN_ALARM:
+			mAlarmCount = 0;    // removing main alarm - also remove subsidiary alarms
+			break;
+		case KAAlarm::AT_LOGIN_ALARM:
+			if (mRepeatAtLogin)
+			{
+				// Remove the at-login alarm, but keep a note of it for archiving purposes
+				mArchiveRepeatAtLogin = true;
+				mRepeatAtLogin = false;
+				--mAlarmCount;
+			}
+			break;
+		case KAAlarm::REMINDER_ALARM:
+			// Remove any reminder alarm, but keep a note of it for archiving purposes
+			set_archiveReminder();
+			break;
+		case KAAlarm::DEFERRED_REMINDER_ALARM:
+		case KAAlarm::DEFERRED_ALARM:
+			set_deferral(NO_DEFERRAL);
+			break;
+		case KAAlarm::DISPLAYING_ALARM:
+			if (mDisplaying)
+			{
+				mDisplaying = false;
+				--mAlarmCount;
+			}
+			break;
+		case KAAlarm::AUDIO_ALARM:
+		case KAAlarm::PRE_ACTION_ALARM:
+		case KAAlarm::POST_ACTION_ALARM:
+		case KAAlarm::INVALID_ALARM:
+		default:
+			break;
+	}
+	if (mAlarmCount != count)
+		mUpdated = true;
+}
+
+/******************************************************************************
+ * Defer the event to the specified time.
+ * If the main alarm time has passed, the main alarm is marked as expired.
+ * If 'adjustRecurrence' is true, ensure that the next scheduled recurrence is
+ * after the current time.
+ * Reply = true if a repetition has been deferred.
+ */
+bool KAEvent::defer(const DateTime& dateTime, bool reminder, bool adjustRecurrence)
+{
+	bool result = false;
+	bool setNextRepetition = false;
+	bool checkRepetition = false;
+	cancelCancelledDeferral();
+	if (checkRecur() == KARecurrence::NO_RECUR)
+	{
+		if (mReminderMinutes  ||  mDeferral == REMINDER_DEFERRAL  ||  mArchiveReminderMinutes)
+		{
+			if (dateTime < mNextMainDateTime.dateTime())
+			{
+				set_deferral(REMINDER_DEFERRAL);   // defer reminder alarm
+				mDeferralTime = dateTime;
+			}
+			else
+			{
+				// Deferring past the main alarm time, so adjust any existing deferral
+				if (mReminderMinutes  ||  mDeferral == REMINDER_DEFERRAL)
+					set_deferral(NO_DEFERRAL);
+			}
+			// Remove any reminder alarm, but keep a note of it for archiving purposes
+			if (mReminderMinutes)
+				set_archiveReminder();
+		}
+		if (mDeferral != REMINDER_DEFERRAL)
+		{
+			// We're deferring the main alarm, not a reminder
+			if (mRepeatCount && mRepeatInterval  &&  dateTime < mainEndRepeatTime())
+			{
+				// The alarm is repeated, and we're deferring to a time before the last repetition
+				set_deferral(NORMAL_DEFERRAL);
+				mDeferralTime = dateTime;
+				result = true;
+				setNextRepetition = true;
+			}
+			else
+			{
+				// Main alarm has now expired
+				mNextMainDateTime = mDeferralTime = dateTime;
+				set_deferral(NORMAL_DEFERRAL);
+				if (!mMainExpired)
+				{
+					// Mark the alarm as expired now
+					mMainExpired = true;
+					--mAlarmCount;
+					if (mRepeatAtLogin)
+					{
+						// Remove the repeat-at-login alarm, but keep a note of it for archiving purposes
+						mArchiveRepeatAtLogin = true;
+						mRepeatAtLogin = false;
+						--mAlarmCount;
+					}
+				}
+			}
+		}
+	}
+	else if (reminder)
+	{
+		// Deferring a reminder for a recurring alarm
+		if (dateTime >= mNextMainDateTime.dateTime())
+			set_deferral(NO_DEFERRAL);    // (error)
+		else
+		{
+			set_deferral(REMINDER_DEFERRAL);
+			mDeferralTime = dateTime;
+			checkRepetition = true;
+		}
+	}
+	else
+	{
+		mDeferralTime = dateTime;
+		if (mDeferral <= 0)
+			set_deferral(NORMAL_DEFERRAL);
+		if (adjustRecurrence)
+		{
+			QDateTime now = QDateTime::currentDateTime();
+			if (mainEndRepeatTime() < now)
+			{
+				// The last repetition (if any) of the current recurrence has already passed.
+				// Adjust to the next scheduled recurrence after now.
+				if (!mMainExpired  &&  setNextOccurrence(now) == NO_OCCURRENCE)
+				{
+					mMainExpired = true;
+					--mAlarmCount;
+				}
+			}
+			else
+				setNextRepetition = (mRepeatCount && mRepeatInterval);
+		}
+		else
+			checkRepetition = true;
+	}
+	if (checkRepetition)
+		setNextRepetition = (mRepeatCount && mRepeatInterval  &&  mDeferralTime < mainEndRepeatTime());
+	if (setNextRepetition)
+	{
+		// The alarm is repeated, and we're deferring to a time before the last repetition.
+		// Set the next scheduled repetition to the one after the deferral.
+		mNextRepeat = (mNextMainDateTime < mDeferralTime)
+		            ? mNextMainDateTime.secsTo(mDeferralTime) / (mRepeatInterval * 60) + 1 : 0;
+	}
+	mUpdated = true;
+	return result;
+}
+
+/******************************************************************************
+ * Cancel any deferral alarm.
+ */
+void KAEvent::cancelDefer()
+{
+	if (mDeferral > 0)
+	{
+		// Set the deferral time to be the same as the next recurrence/repetition.
+		// This prevents an immediate retriggering of the alarm.
+		if (mMainExpired
+		||  nextOccurrence(QDateTime::currentDateTime(), mDeferralTime, RETURN_REPETITION) == NO_OCCURRENCE)
+		{
+			// The main alarm has expired, so simply delete the deferral
+			mDeferralTime = DateTime();
+			set_deferral(NO_DEFERRAL);
+		}
+		else
+			set_deferral(CANCEL_DEFERRAL);
+		mUpdated = true;
+	}
+}
+
+/******************************************************************************
+ * Cancel any cancelled deferral alarm.
+ */
+void KAEvent::cancelCancelledDeferral()
+{
+	if (mDeferral == CANCEL_DEFERRAL)
+	{
+		mDeferralTime = DateTime();
+		set_deferral(NO_DEFERRAL);
+	}
+}
+
+/******************************************************************************
+*  Find the latest time which the alarm can currently be deferred to.
+*/
+DateTime KAEvent::deferralLimit(KAEvent::DeferLimitType* limitType) const
+{
+	DeferLimitType ltype;
+	DateTime endTime;
+	bool recurs = (checkRecur() != KARecurrence::NO_RECUR);
+	if (recurs  ||  mRepeatCount)
+	{
+		// It's a repeated alarm. Don't allow it to be deferred past its
+		// next occurrence or repetition.
+		DateTime reminderTime;
+		QDateTime now = QDateTime::currentDateTime();
+		OccurType type = nextOccurrence(now, endTime, RETURN_REPETITION);
+		if (type & OCCURRENCE_REPEAT)
+			ltype = LIMIT_REPETITION;
+		else if (type == NO_OCCURRENCE)
+			ltype = LIMIT_NONE;
+		else if (mReminderMinutes  &&  (now < (reminderTime = endTime.addMins(-mReminderMinutes))))
+		{
+			endTime = reminderTime;
+			ltype = LIMIT_REMINDER;
+		}
+		else if (type == FIRST_OR_ONLY_OCCURRENCE  &&  !recurs)
+			ltype = LIMIT_REPETITION;
+		else
+			ltype = LIMIT_RECURRENCE;
+	}
+	else if ((mReminderMinutes  ||  mDeferral == REMINDER_DEFERRAL  ||  mArchiveReminderMinutes)
+		 &&  QDateTime::currentDateTime() < mNextMainDateTime.dateTime())
+	{
+		// It's an reminder alarm. Don't allow it to be deferred past its main alarm time.
+		endTime = mNextMainDateTime;
+		ltype = LIMIT_REMINDER;
+	}
+	else
+		ltype = LIMIT_NONE;
+	if (ltype != LIMIT_NONE)
+		endTime = endTime.addMins(-1);
+	if (limitType)
+		*limitType = ltype;
+	return endTime;
+}
+
+/******************************************************************************
+ * Set the event to be a copy of the specified event, making the specified
+ * alarm the 'displaying' alarm.
+ * The purpose of setting up a 'displaying' alarm is to be able to reinstate
+ * the alarm message in case of a crash, or to reinstate it should the user
+ * choose to defer the alarm. Note that even repeat-at-login alarms need to be
+ * saved in case their end time expires before the next login.
+ * Reply = true if successful, false if alarm was not copied.
+ */
+bool KAEvent::setDisplaying(const KAEvent& event, KAAlarm::Type alarmType, const QDateTime& repeatAtLoginTime)
+{
+	if (!mDisplaying
+	&&  (alarmType == KAAlarm::MAIN_ALARM
+	  || alarmType == KAAlarm::REMINDER_ALARM
+	  || alarmType == KAAlarm::DEFERRED_REMINDER_ALARM
+	  || alarmType == KAAlarm::DEFERRED_ALARM
+	  || alarmType == KAAlarm::AT_LOGIN_ALARM))
+	{
+//kdDebug(5950)<<"KAEvent::setDisplaying("<<event.id()<<", "<<(alarmType==KAAlarm::MAIN_ALARM?"MAIN":alarmType==KAAlarm::REMINDER_ALARM?"REMINDER":alarmType==KAAlarm::DEFERRED_REMINDER_ALARM?"REMINDER_DEFERRAL":alarmType==KAAlarm::DEFERRED_ALARM?"DEFERRAL":"LOGIN")<<"): time="<<repeatAtLoginTime.toString()<<endl;
+		KAAlarm al = event.alarm(alarmType);
+		if (al.valid())
+		{
+			*this = event;
+			setUid(DISPLAYING);
+			mDisplaying     = true;
+			mDisplayingTime = (alarmType == KAAlarm::AT_LOGIN_ALARM) ? repeatAtLoginTime : al.dateTime();
+			switch (al.type())
+			{
+				case KAAlarm::AT_LOGIN__ALARM:                mDisplayingFlags = REPEAT_AT_LOGIN;  break;
+				case KAAlarm::REMINDER__ALARM:                mDisplayingFlags = REMINDER;  break;
+				case KAAlarm::DEFERRED_REMINDER_TIME__ALARM:  mDisplayingFlags = REMINDER | TIME_DEFERRAL;  break;
+				case KAAlarm::DEFERRED_REMINDER_DATE__ALARM:  mDisplayingFlags = REMINDER | DATE_DEFERRAL;  break;
+				case KAAlarm::DEFERRED_TIME__ALARM:           mDisplayingFlags = TIME_DEFERRAL;  break;
+				case KAAlarm::DEFERRED_DATE__ALARM:           mDisplayingFlags = DATE_DEFERRAL;  break;
+				default:                                      mDisplayingFlags = 0;  break;
+			}
+			++mAlarmCount;
+			mUpdated = true;
+			return true;
+		}
+	}
+	return false;
+}
+
+/******************************************************************************
+ * Return the original alarm which the displaying alarm refers to.
+ */
+KAAlarm KAEvent::convertDisplayingAlarm() const
+{
+	KAAlarm al;
+	if (mDisplaying)
+	{
+		al = alarm(KAAlarm::DISPLAYING_ALARM);
+		if (mDisplayingFlags & REPEAT_AT_LOGIN)
+		{
+			al.mRepeatAtLogin = true;
+			al.mType = KAAlarm::AT_LOGIN__ALARM;
+		}
+		else if (mDisplayingFlags & DEFERRAL)
+		{
+			al.mDeferred = true;
+			al.mType = (mDisplayingFlags == (REMINDER | DATE_DEFERRAL)) ? KAAlarm::DEFERRED_REMINDER_DATE__ALARM
+			         : (mDisplayingFlags == (REMINDER | TIME_DEFERRAL)) ? KAAlarm::DEFERRED_REMINDER_TIME__ALARM
+			         : (mDisplayingFlags == DATE_DEFERRAL) ? KAAlarm::DEFERRED_DATE__ALARM
+			         : KAAlarm::DEFERRED_TIME__ALARM;
+		}
+		else if (mDisplayingFlags & REMINDER)
+			al.mType = KAAlarm::REMINDER__ALARM;
+		else
+			al.mType = KAAlarm::MAIN__ALARM;
+	}
+	return al;
+}
+
+/******************************************************************************
+ * Reinstate the original event from the 'displaying' event.
+ */
+void KAEvent::reinstateFromDisplaying(const KAEvent& dispEvent)
+{
+	if (dispEvent.mDisplaying)
+	{
+		*this = dispEvent;
+		setUid(ACTIVE);
+		mDisplaying = false;
+		--mAlarmCount;
+		mUpdated = true;
+	}
+}
+
+/******************************************************************************
+ * Determine whether the event will occur after the specified date/time.
+ * If 'includeRepetitions' is true and the alarm has a sub-repetition, it
+ * returns true if any repetitions occur after the specified date/time.
+ */
+bool KAEvent::occursAfter(const QDateTime& preDateTime, bool includeRepetitions) const
+{
+	QDateTime dt;
+	if (checkRecur() != KARecurrence::NO_RECUR)
+	{
+		if (mRecurrence->duration() < 0)
+			return true;    // infinite recurrence
+		dt = mRecurrence->endDateTime();
+	}
+	else
+		dt = mNextMainDateTime.dateTime();
+	if (mStartDateTime.isDateOnly())
+	{
+		QDate pre = preDateTime.date();
+		if (preDateTime.time() < Preferences::startOfDay())
+			pre = pre.addDays(-1);    // today's recurrence (if today recurs) is still to come
+		if (pre < dt.date())
+			return true;
+	}
+	else if (preDateTime < dt)
+		return true;
+
+	if (includeRepetitions  &&  mRepeatCount)
+	{
+		if (preDateTime < dt.addSecs(mRepeatCount * mRepeatInterval * 60))
+			return true;
+	}
+	return false;
+}
+
+/******************************************************************************
+ * Get the date/time of the next occurrence of the event, after the specified
+ * date/time.
+ * 'result' = date/time of next occurrence, or invalid date/time if none.
+ */
+KAEvent::OccurType KAEvent::nextOccurrence(const QDateTime& preDateTime, DateTime& result,
+                                           KAEvent::OccurOption includeRepetitions) const
+{
+	int repeatSecs = 0;
+	QDateTime pre = preDateTime;
+	if (includeRepetitions != IGNORE_REPETITION)
+	{
+		if (!mRepeatCount  ||  !mRepeatInterval)
+			includeRepetitions = IGNORE_REPETITION;
+		else
+		{
+			repeatSecs = mRepeatInterval * 60;
+			pre = preDateTime.addSecs(-mRepeatCount * repeatSecs);
+		}
+	}
+
+	OccurType type;
+	bool recurs = (checkRecur() != KARecurrence::NO_RECUR);
+	if (recurs)
+		type = nextRecurrence(pre, result);
+	else if (pre < mNextMainDateTime.dateTime())
+	{
+		result = mNextMainDateTime;
+		type = FIRST_OR_ONLY_OCCURRENCE;
+	}
+	else
+	{
+		result = DateTime();
+		type = NO_OCCURRENCE;
+	}
+
+	if (type != NO_OCCURRENCE  &&  result <= preDateTime  &&  includeRepetitions != IGNORE_REPETITION)
+	{
+		// The next occurrence is a sub-repetition
+		int repetition = result.secsTo(preDateTime) / repeatSecs + 1;
+		DateTime repeatDT = result.addSecs(repetition * repeatSecs);
+		if (recurs)
+		{
+			// We've found a recurrence before the specified date/time, which has
+			// a sub-repetition after the date/time.
+			// However, if the intervals between recurrences vary, we could possibly
+			// have missed a later recurrence, which fits the criterion, so check again.
+			DateTime dt;
+			OccurType newType = previousOccurrence(repeatDT.dateTime(), dt, false);
+			if (dt > result)
+			{
+				type = newType;
+				result = dt;
+				if (includeRepetitions == RETURN_REPETITION  &&  result <= preDateTime)
+				{
+					// The next occurrence is a sub-repetition
+					int repetition = result.secsTo(preDateTime) / repeatSecs + 1;
+					result = result.addSecs(repetition * repeatSecs);
+					type = static_cast<OccurType>(type | OCCURRENCE_REPEAT);
+				}
+				return type;
+			}
+		}
+		if (includeRepetitions == RETURN_REPETITION)
+		{
+			// The next occurrence is a sub-repetition
+			result = repeatDT;
+			type = static_cast<OccurType>(type | OCCURRENCE_REPEAT);
+		}
+	}
+	return type;
+}
+
+/******************************************************************************
+ * Get the date/time of the last previous occurrence of the event, before the
+ * specified date/time.
+ * If 'includeRepetitions' is true and the alarm has a sub-repetition, the
+ * last previous repetition is returned if appropriate.
+ * 'result' = date/time of previous occurrence, or invalid date/time if none.
+ */
+KAEvent::OccurType KAEvent::previousOccurrence(const QDateTime& afterDateTime, DateTime& result, bool includeRepetitions) const
+{
+	if (mStartDateTime >= afterDateTime)
+	{
+		result = QDateTime();
+		return NO_OCCURRENCE;     // the event starts after the specified date/time
+	}
+
+	// Find the latest recurrence of the event
+	OccurType type;
+	if (checkRecur() == KARecurrence::NO_RECUR)
+	{
+		result = mStartDateTime;
+		type = FIRST_OR_ONLY_OCCURRENCE;
+	}
+	else
+	{
+		QDateTime recurStart = mRecurrence->startDateTime();
+		QDateTime after = afterDateTime;
+		if (mStartDateTime.isDateOnly()  &&  afterDateTime.time() > Preferences::startOfDay())
+			after = after.addDays(1);    // today's recurrence (if today recurs) has passed
+		QDateTime dt = mRecurrence->getPreviousDateTime(after);
+		result.set(dt, mStartDateTime.isDateOnly());
+		if (!dt.isValid())
+			return NO_OCCURRENCE;
+		if (dt == recurStart)
+			type = FIRST_OR_ONLY_OCCURRENCE;
+		else if (mRecurrence->getNextDateTime(dt).isValid())
+			type = result.isDateOnly() ? RECURRENCE_DATE : RECURRENCE_DATE_TIME;
+		else
+			type = LAST_RECURRENCE;
+	}
+
+	if (includeRepetitions  &&  mRepeatCount)
+	{
+		// Find the latest repetition which is before the specified time.
+		// N.B. This is coded to avoid 32-bit integer overflow which occurs
+		//      in QDateTime::secsTo() for large enough time differences.
+		int repeatSecs = mRepeatInterval * 60;
+		DateTime lastRepetition = result.addSecs(mRepeatCount * repeatSecs);
+		if (lastRepetition < afterDateTime)
+		{
+			result = lastRepetition;
+			return static_cast<OccurType>(type | OCCURRENCE_REPEAT);
+		}
+		int repetition = (result.dateTime().secsTo(afterDateTime) - 1) / repeatSecs;
+		if (repetition > 0)
+		{
+			result = result.addSecs(repetition * repeatSecs);
+			return static_cast<OccurType>(type | OCCURRENCE_REPEAT);
+		}
+	}
+	return type;
+}
+
+/******************************************************************************
+ * Set the date/time of the event to the next scheduled occurrence after the
+ * specified date/time, provided that this is later than its current date/time.
+ * Any reminder alarm is adjusted accordingly.
+ * If the alarm has a sub-repetition, and a repetition of a previous
+ * recurrence occurs after the specified date/time, that repetition is set as
+ * the next occurrence.
+ */
+KAEvent::OccurType KAEvent::setNextOccurrence(const QDateTime& preDateTime)
+{
+	if (preDateTime < mNextMainDateTime.dateTime())
+		return FIRST_OR_ONLY_OCCURRENCE;    // it might not be the first recurrence - tant pis
+	QDateTime pre = preDateTime;
+	// If there are repetitions, adjust the comparison date/time so that
+	// we find the earliest recurrence which has a repetition falling after
+	// the specified preDateTime.
+	if (mRepeatCount  &&  mRepeatInterval)
+		pre = preDateTime.addSecs(-mRepeatCount * mRepeatInterval * 60);
+
+	DateTime dt;
+	OccurType type;
+	if (pre < mNextMainDateTime.dateTime())
+	{
+		dt = mNextMainDateTime;
+		type = FIRST_OR_ONLY_OCCURRENCE;   // may not actually be the first occurrence
+	}
+	else if (checkRecur() != KARecurrence::NO_RECUR)
+	{
+		type = nextRecurrence(pre, dt);
+		if (type == NO_OCCURRENCE)
+			return NO_OCCURRENCE;
+		if (type != FIRST_OR_ONLY_OCCURRENCE  &&  dt != mNextMainDateTime)
+		{
+			// Need to reschedule the next trigger date/time
+			mNextMainDateTime = dt;
+			// Reinstate the reminder (if any) for the rescheduled recurrence
+			if (mDeferral == REMINDER_DEFERRAL  ||  mArchiveReminderMinutes)
+			{
+				if (mReminderOnceOnly)
+				{
+					if (mReminderMinutes)
+						set_archiveReminder();
+				}
+				else
+					set_reminder(mArchiveReminderMinutes);
+			}
+			if (mDeferral == REMINDER_DEFERRAL)
+				set_deferral(NO_DEFERRAL);
+			mUpdated = true;
+		}
+	}
+	else
+		return NO_OCCURRENCE;
+
+	if (mRepeatCount  &&  mRepeatInterval)
+	{
+		int secs = dt.dateTime().secsTo(preDateTime);
+		if (secs >= 0)
+		{
+			// The next occurrence is a sub-repetition.
+			type = static_cast<OccurType>(type | OCCURRENCE_REPEAT);
+			mNextRepeat = (secs / (60 * mRepeatInterval)) + 1;
+			// Repetitions can't have a reminder, so remove any.
+			if (mReminderMinutes)
+				set_archiveReminder();
+			if (mDeferral == REMINDER_DEFERRAL)
+				set_deferral(NO_DEFERRAL);
+			mUpdated = true;
+		}
+		else if (mNextRepeat)
+		{
+			// The next occurrence is the main occurrence, not a repetition
+			mNextRepeat = 0;
+			mUpdated = true;
+		}
+	}
+	return type;
+}
+
+/******************************************************************************
+ * Get the date/time of the next recurrence of the event, after the specified
+ * date/time.
+ * 'result' = date/time of next occurrence, or invalid date/time if none.
+ */
+KAEvent::OccurType KAEvent::nextRecurrence(const QDateTime& preDateTime, DateTime& result) const
+{
+	QDateTime recurStart = mRecurrence->startDateTime();
+	QDateTime pre = preDateTime;
+	if (mStartDateTime.isDateOnly()  &&  preDateTime.time() < Preferences::startOfDay())
+	{
+		pre = pre.addDays(-1);    // today's recurrence (if today recurs) is still to come
+		pre.setTime(Preferences::startOfDay());
+	}
+	QDateTime dt = mRecurrence->getNextDateTime(pre);
+	result.set(dt, mStartDateTime.isDateOnly());
+	if (!dt.isValid())
+		return NO_OCCURRENCE;
+	if (dt == recurStart)
+		return FIRST_OR_ONLY_OCCURRENCE;
+	if (mRecurrence->duration() >= 0  &&  dt == mRecurrence->endDateTime())
+		return LAST_RECURRENCE;
+	return result.isDateOnly() ? RECURRENCE_DATE : RECURRENCE_DATE_TIME;
+}
+
+/******************************************************************************
+ * Return the recurrence interval as text suitable for display.
+ */
+QString KAEvent::recurrenceText(bool brief) const
+{
+	if (mRepeatAtLogin)
+		return brief ? i18n("Brief form of 'At Login'", "Login") : i18n("At login");
+	if (mRecurrence)
+	{
+		int frequency = mRecurrence->frequency();
+		switch (mRecurrence->defaultRRuleConst()->recurrenceType())
+		{
+			case RecurrenceRule::rMinutely:
+				if (frequency < 60)
+					return i18n("1 Minute", "%n Minutes", frequency);
+				else if (frequency % 60 == 0)
+					return i18n("1 Hour", "%n Hours", frequency/60);
+				else
+				{
+					QString mins;
+					return i18n("Hours and Minutes", "%1H %2M").arg(QString::number(frequency/60)).arg(mins.sprintf("%02d", frequency%60));
+				}
+			case RecurrenceRule::rDaily:
+				return i18n("1 Day", "%n Days", frequency);
+			case RecurrenceRule::rWeekly:
+				return i18n("1 Week", "%n Weeks", frequency);
+			case RecurrenceRule::rMonthly:
+				return i18n("1 Month", "%n Months", frequency);
+			case RecurrenceRule::rYearly:
+				return i18n("1 Year", "%n Years", frequency);
+			case RecurrenceRule::rNone:
+			default:
+				break;
+		}
+	}
+	return brief ? QString::null : i18n("None");
+}
+
+/******************************************************************************
+ * Return the repetition interval as text suitable for display.
+ */
+QString KAEvent::repetitionText(bool brief) const
+{
+	if (mRepeatCount)
+	{
+		if (mRepeatInterval % 1440)
+		{
+			if (mRepeatInterval < 60)
+				return i18n("1 Minute", "%n Minutes", mRepeatInterval);
+			if (mRepeatInterval % 60 == 0)
+				return i18n("1 Hour", "%n Hours", mRepeatInterval/60);
+			QString mins;
+			return i18n("Hours and Minutes", "%1H %2M").arg(QString::number(mRepeatInterval/60)).arg(mins.sprintf("%02d", mRepeatInterval%60));
+		}
+		if (mRepeatInterval % (7*1440))
+			return i18n("1 Day", "%n Days", mRepeatInterval/1440);
+		return i18n("1 Week", "%n Weeks", mRepeatInterval/(7*1440));
+	}
+	return brief ? QString::null : i18n("None");
+}
+
+/******************************************************************************
+ * Adjust the event date/time to the first recurrence of the event, on or after
+ * start date/time. The event start date may not be a recurrence date, in which
+ * case a later date will be set.
+ */
+void KAEvent::setFirstRecurrence()
+{
+	switch (checkRecur())
+	{
+		case KARecurrence::NO_RECUR:
+		case KARecurrence::MINUTELY:
+			return;
+		case KARecurrence::ANNUAL_DATE:
+		case KARecurrence::ANNUAL_POS:
+			if (mRecurrence->yearMonths().isEmpty())
+				return;    // (presumably it's a template)
+			break;
+		case KARecurrence::DAILY:
+		case KARecurrence::WEEKLY:
+		case KARecurrence::MONTHLY_POS:
+		case KARecurrence::MONTHLY_DAY:
+			break;
+	}
+	QDateTime recurStart = mRecurrence->startDateTime();
+	if (mRecurrence->recursOn(recurStart.date()))
+		return;           // it already recurs on the start date
+
+	// Set the frequency to 1 to find the first possible occurrence
+	int frequency = mRecurrence->frequency();
+	mRecurrence->setFrequency(1);
+	DateTime next;
+	nextRecurrence(mNextMainDateTime.dateTime(), next);
+	if (!next.isValid())
+		mRecurrence->setStartDateTime(recurStart);   // reinstate the old value
+	else
+	{
+		mRecurrence->setStartDateTime(next.dateTime());
+		mStartDateTime = mNextMainDateTime = next;
+		mUpdated = true;
+	}
+	mRecurrence->setFrequency(frequency);    // restore the frequency
+}
+
+/******************************************************************************
+*  Initialise the event's recurrence from a KCal::Recurrence.
+*  The event's start date/time is not changed.
+*/
+void KAEvent::setRecurrence(const KARecurrence& recurrence)
+{
+	mUpdated = true;
+	delete mRecurrence;
+	if (recurrence.doesRecur())
+	{
+		mRecurrence = new KARecurrence(recurrence);
+		mRecurrence->setStartDateTime(mStartDateTime.dateTime());
+		mRecurrence->setFloats(mStartDateTime.isDateOnly());
+	}
+	else
+		mRecurrence = 0;
+
+	// Adjust sub-repetition values to fit the recurrence
+	setRepetition(mRepeatInterval, mRepeatCount);
+}
+
+/******************************************************************************
+*  Initialise the event's sub-repetition.
+*  The repetition length is adjusted if necessary to fit any recurrence interval.
+*  Reply = false if a non-daily interval was specified for a date-only recurrence.
+*/
+bool KAEvent::setRepetition(int interval, int count)
+{
+	mUpdated        = true;
+	mRepeatInterval = 0;
+	mRepeatCount    = 0;
+	mNextRepeat     = 0;
+	if (interval > 0  &&  count > 0  &&  !mRepeatAtLogin)
+	{
+		Q_ASSERT(checkRecur() != KARecurrence::NO_RECUR);
+		if (interval % 1440  &&  mStartDateTime.isDateOnly())
+			return false;    // interval must be in units of days for date-only alarms
+		if (checkRecur() != KARecurrence::NO_RECUR)
+		{
+			int longestInterval = mRecurrence->longestInterval() - 1;
+			if (interval * count > longestInterval)
+				count = longestInterval / interval;
+		}
+		mRepeatInterval = interval;
+		mRepeatCount    = count;
+	}
+	return true;
+}
+
+/******************************************************************************
+ * Set the recurrence to recur at a minutes interval.
+ * Parameters:
+ *    freq  = how many minutes between recurrences.
+ *    count = number of occurrences, including first and last.
+ *          = -1 to recur indefinitely.
+ *          = 0 to use 'end' instead.
+ *    end   = end date/time (invalid to use 'count' instead).
+ * Reply = false if no recurrence was set up.
+ */
+bool KAEvent::setRecurMinutely(int freq, int count, const QDateTime& end)
+{
+	return setRecur(RecurrenceRule::rMinutely, freq, count, end);
+}
+
+/******************************************************************************
+ * Set the recurrence to recur daily.
+ * Parameters:
+ *    freq  = how many days between recurrences.
+ *    days  = which days of the week alarms are allowed to occur on.
+ *    count = number of occurrences, including first and last.
+ *          = -1 to recur indefinitely.
+ *          = 0 to use 'end' instead.
+ *    end   = end date (invalid to use 'count' instead).
+ * Reply = false if no recurrence was set up.
+ */
+bool KAEvent::setRecurDaily(int freq, const QBitArray& days, int count, const QDate& end)
+{
+	if (!setRecur(RecurrenceRule::rDaily, freq, count, end))
+		return false;
+	int n = 0;
+	for (int i = 0;  i < 7;  ++i)
+	{
+		if (days.testBit(i))
+			++n;
+	}
+	if (n < 7)
+		mRecurrence->addWeeklyDays(days);
+	return true;
+}
+
+/******************************************************************************
+ * Set the recurrence to recur weekly, on the specified weekdays.
+ * Parameters:
+ *    freq  = how many weeks between recurrences.
+ *    days  = which days of the week alarms should occur on.
+ *    count = number of occurrences, including first and last.
+ *          = -1 to recur indefinitely.
+ *          = 0 to use 'end' instead.
+ *    end   = end date (invalid to use 'count' instead).
+ * Reply = false if no recurrence was set up.
+ */
+bool KAEvent::setRecurWeekly(int freq, const QBitArray& days, int count, const QDate& end)
+{
+	if (!setRecur(RecurrenceRule::rWeekly, freq, count, end))
+		return false;
+	mRecurrence->addWeeklyDays(days);
+	return true;
+}
+
+/******************************************************************************
+ * Set the recurrence to recur monthly, on the specified days within the month.
+ * Parameters:
+ *    freq  = how many months between recurrences.
+ *    days  = which days of the month alarms should occur on.
+ *    count = number of occurrences, including first and last.
+ *          = -1 to recur indefinitely.
+ *          = 0 to use 'end' instead.
+ *    end   = end date (invalid to use 'count' instead).
+ * Reply = false if no recurrence was set up.
+ */
+bool KAEvent::setRecurMonthlyByDate(int freq, const QValueList<int>& days, int count, const QDate& end)
+{
+	if (!setRecur(RecurrenceRule::rMonthly, freq, count, end))
+		return false;
+	for (QValueListConstIterator<int> it = days.begin();  it != days.end();  ++it)
+		mRecurrence->addMonthlyDate(*it);
+	return true;
+}
+
+/******************************************************************************
+ * Set the recurrence to recur monthly, on the specified weekdays in the
+ * specified weeks of the month.
+ * Parameters:
+ *    freq  = how many months between recurrences.
+ *    posns = which days of the week/weeks of the month alarms should occur on.
+ *    count = number of occurrences, including first and last.
+ *          = -1 to recur indefinitely.
+ *          = 0 to use 'end' instead.
+ *    end   = end date (invalid to use 'count' instead).
+ * Reply = false if no recurrence was set up.
+ */
+bool KAEvent::setRecurMonthlyByPos(int freq, const QValueList<MonthPos>& posns, int count, const QDate& end)
+{
+	if (!setRecur(RecurrenceRule::rMonthly, freq, count, end))
+		return false;
+	for (QValueListConstIterator<MonthPos> it = posns.begin();  it != posns.end();  ++it)
+		mRecurrence->addMonthlyPos((*it).weeknum, (*it).days);
+	return true;
+}
+
+/******************************************************************************
+ * Set the recurrence to recur annually, on the specified start date in each
+ * of the specified months.
+ * Parameters:
+ *    freq   = how many years between recurrences.
+ *    months = which months of the year alarms should occur on.
+ *    day    = day of month, or 0 to use start date
+ *    feb29  = when February 29th should recur in non-leap years.
+ *    count  = number of occurrences, including first and last.
+ *           = -1 to recur indefinitely.
+ *           = 0 to use 'end' instead.
+ *    end    = end date (invalid to use 'count' instead).
+ * Reply = false if no recurrence was set up.
+ */
+bool KAEvent::setRecurAnnualByDate(int freq, const QValueList<int>& months, int day, KARecurrence::Feb29Type feb29, int count, const QDate& end)
+{
+	if (!setRecur(RecurrenceRule::rYearly, freq, count, end, feb29))
+		return false;
+	for (QValueListConstIterator<int> it = months.begin();  it != months.end();  ++it)
+		mRecurrence->addYearlyMonth(*it);
+	if (day)
+		mRecurrence->addMonthlyDate(day);
+	return true;
+}
+
+/******************************************************************************
+ * Set the recurrence to recur annually, on the specified weekdays in the
+ * specified weeks of the specified months.
+ * Parameters:
+ *    freq   = how many years between recurrences.
+ *    posns  = which days of the week/weeks of the month alarms should occur on.
+ *    months = which months of the year alarms should occur on.
+ *    count  = number of occurrences, including first and last.
+ *           = -1 to recur indefinitely.
+ *           = 0 to use 'end' instead.
+ *    end    = end date (invalid to use 'count' instead).
+ * Reply = false if no recurrence was set up.
+ */
+bool KAEvent::setRecurAnnualByPos(int freq, const QValueList<MonthPos>& posns, const QValueList<int>& months, int count, const QDate& end)
+{
+	if (!setRecur(RecurrenceRule::rYearly, freq, count, end))
+		return false;
+	for (QValueListConstIterator<int> it = months.begin();  it != months.end();  ++it)
+		mRecurrence->addYearlyMonth(*it);
+	for (QValueListConstIterator<MonthPos> it = posns.begin();  it != posns.end();  ++it)
+		mRecurrence->addYearlyPos((*it).weeknum, (*it).days);
+	return true;
+}
+
+/******************************************************************************
+ * Initialise the event's recurrence data.
+ * Parameters:
+ *    freq  = how many intervals between recurrences.
+ *    count = number of occurrences, including first and last.
+ *          = -1 to recur indefinitely.
+ *          = 0 to use 'end' instead.
+ *    end   = end date/time (invalid to use 'count' instead).
+ * Reply = false if no recurrence was set up.
+ */
+bool KAEvent::setRecur(RecurrenceRule::PeriodType recurType, int freq, int count, const QDateTime& end, KARecurrence::Feb29Type feb29)
+{
+	if (count >= -1  &&  (count || end.date().isValid()))
+	{
+		if (!mRecurrence)
+			mRecurrence = new KARecurrence;
+		if (mRecurrence->init(recurType, freq, count, mNextMainDateTime, end, feb29))
+		{
+			mUpdated = true;
+			return true;
+		}
+	}
+	clearRecur();
+	return false;
+}
+
+/******************************************************************************
+ * Clear the event's recurrence and alarm repetition data.
+ */
+void KAEvent::clearRecur()
+{
+	delete mRecurrence;
+	mRecurrence     = 0;
+	mRepeatInterval = 0;
+	mRepeatCount    = 0;
+	mNextRepeat     = 0;
+	mUpdated        = true;
+}
+
+/******************************************************************************
+* Validate the event's recurrence data, correcting any inconsistencies (which
+* should never occur!).
+* Reply = true if a recurrence (as opposed to a login repetition) exists.
+*/
+KARecurrence::Type KAEvent::checkRecur() const
+{
+	if (mRecurrence)
+	{
+		KARecurrence::Type type = mRecurrence->type();
+		switch (type)
+		{
+			case KARecurrence::MINUTELY:     // hourly		
+			case KARecurrence::DAILY:        // daily
+			case KARecurrence::WEEKLY:       // weekly on multiple days of week
+			case KARecurrence::MONTHLY_DAY:  // monthly on multiple dates in month
+			case KARecurrence::MONTHLY_POS:  // monthly on multiple nth day of week
+			case KARecurrence::ANNUAL_DATE:  // annually on multiple months (day of month = start date)
+			case KARecurrence::ANNUAL_POS:   // annually on multiple nth day of week in multiple months
+				return type;
+			default:
+				if (mRecurrence)
+					const_cast<KAEvent*>(this)->clearRecur();  // recurrence shouldn't exist!!
+				break;
+		}
+	}
+	return KARecurrence::NO_RECUR;
+}
+
+
+/******************************************************************************
+ * Return the recurrence interval in units of the recurrence period type.
+ */
+int KAEvent::recurInterval() const
+{
+	if (mRecurrence)
+	{
+		switch (mRecurrence->type())
+		{
+			case KARecurrence::MINUTELY:
+			case KARecurrence::DAILY:
+			case KARecurrence::WEEKLY:
+			case KARecurrence::MONTHLY_DAY:
+			case KARecurrence::MONTHLY_POS:
+			case KARecurrence::ANNUAL_DATE:
+			case KARecurrence::ANNUAL_POS:
+				return mRecurrence->frequency();
+			default:
+				break;
+		}
+	}
+	return 0;
+}
+
+/******************************************************************************
+* Validate the event's alarm sub-repetition data, correcting any
+* inconsistencies (which should never occur!).
+*/
+void KAEvent::checkRepetition() const
+{
+	if (mRepeatCount  &&  !mRepeatInterval)
+		const_cast<KAEvent*>(this)->mRepeatCount = 0;
+	if (!mRepeatCount  &&  mRepeatInterval)
+		const_cast<KAEvent*>(this)->mRepeatInterval = 0;
+}
+
+#if 0
+/******************************************************************************
+ * Convert a QValueList<WDayPos> to QValueList<MonthPos>.
+ */
+QValueList<KAEvent::MonthPos> KAEvent::convRecurPos(const QValueList<KCal::RecurrenceRule::WDayPos>& wdaypos)
+{
+	QValueList<MonthPos> mposns;
+	for (QValueList<KCal::RecurrenceRule::WDayPos>::ConstIterator it = wdaypos.begin();  it != wdaypos.end();  ++it)
+	{
+		int daybit  = (*it).day() - 1;
+		int weeknum = (*it).pos();
+		bool found = false;
+		for (QValueList<MonthPos>::Iterator mit = mposns.begin();  mit != mposns.end();  ++mit)
+		{
+			if ((*mit).weeknum == weeknum)
+			{
+				(*mit).days.setBit(daybit);
+				found = true;
+				break;
+			}
+		}
+		if (!found)
+		{
+			MonthPos mpos;
+			mpos.days.fill(false);
+			mpos.days.setBit(daybit);
+			mpos.weeknum = weeknum;
+			mposns.append(mpos);
+		}
+	}
+	return mposns;
+}
+#endif
+
+/******************************************************************************
+ * Find the alarm template with the specified name.
+ * Reply = invalid event if not found.
+ */
+KAEvent KAEvent::findTemplateName(AlarmCalendar& calendar, const QString& name)
+{
+	KAEvent event;
+	Event::List events = calendar.events();
+	for (Event::List::ConstIterator evit = events.begin();  evit != events.end();  ++evit)
+	{
+		Event* ev = *evit;
+		if (ev->summary() == name)
+		{
+			event.set(*ev);
+			if (!event.isTemplate())
+				return KAEvent();    // this shouldn't ever happen
+			break;
+		}
+	}
+	return event;
+}
+
+/******************************************************************************
+ * Adjust the time at which date-only events will occur for each of the events
+ * in a list. Events for which both date and time are specified are left
+ * unchanged.
+ * Reply = true if any events have been updated.
+ */
+bool KAEvent::adjustStartOfDay(const Event::List& events)
+{
+	bool changed = false;
+	QTime startOfDay = Preferences::startOfDay();
+	for (Event::List::ConstIterator evit = events.begin();  evit != events.end();  ++evit)
+	{
+		Event* event = *evit;
+		const QStringList cats = event->categories();
+		if (cats.find(DATE_ONLY_CATEGORY) != cats.end())
+		{
+			// It's an untimed event, so fix it
+			QTime oldTime = event->dtStart().time();
+			int adjustment = oldTime.secsTo(startOfDay);
+			if (adjustment)
+			{
+				event->setDtStart(QDateTime(event->dtStart().date(), startOfDay));
+				Alarm::List alarms = event->alarms();
+				int deferralOffset = 0;
+				for (Alarm::List::ConstIterator alit = alarms.begin();  alit != alarms.end();  ++alit)
+				{
+					// Parse the next alarm's text
+					Alarm& alarm = **alit;
+					AlarmData data;
+					readAlarm(alarm, data);
+					if (data.type & KAAlarm::TIMED_DEFERRAL_FLAG)
+					{
+						// Timed deferral alarm, so adjust the offset
+						deferralOffset = alarm.startOffset().asSeconds();
+						alarm.setStartOffset(deferralOffset - adjustment);
+					}
+					else if (data.type == KAAlarm::AUDIO__ALARM
+					&&       alarm.startOffset().asSeconds() == deferralOffset)
+					{
+						// Audio alarm is set for the same time as the deferral alarm
+						alarm.setStartOffset(deferralOffset - adjustment);
+					}
+				}
+				changed = true;
+			}
+		}
+		else
+		{
+			// It's a timed event. Fix any untimed alarms.
+			int deferralOffset = 0;
+			int newDeferralOffset = 0;
+			DateTime start;
+			QDateTime nextMainDateTime = readDateTime(*event, false, start).rawDateTime();
+			AlarmMap alarmMap;
+			readAlarms(*event, &alarmMap);
+			for (AlarmMap::Iterator it = alarmMap.begin();  it != alarmMap.end();  ++it)
+			{
+				const AlarmData& data = it.data();
+				if (!data.alarm->hasStartOffset())
+					continue;
+				if ((data.type & KAAlarm::DEFERRED_ALARM)
+				&&  !(data.type & KAAlarm::TIMED_DEFERRAL_FLAG))
+				{
+					// Date-only deferral alarm, so adjust its time
+					QDateTime altime = nextMainDateTime.addSecs(data.alarm->startOffset().asSeconds());
+					altime.setTime(startOfDay);
+					deferralOffset = data.alarm->startOffset().asSeconds();
+					newDeferralOffset = event->dtStart().secsTo(altime);
+					const_cast<Alarm*>(data.alarm)->setStartOffset(newDeferralOffset);
+					changed = true;
+				}
+				else if (data.type == KAAlarm::AUDIO__ALARM
+				&&       data.alarm->startOffset().asSeconds() == deferralOffset)
+				{
+					// Audio alarm is set for the same time as the deferral alarm
+					const_cast<Alarm*>(data.alarm)->setStartOffset(newDeferralOffset);
+					changed = true;
+				}
+			}
+		}
+	}
+	return changed;
+}
+
+/******************************************************************************
+ * If the calendar was written by a previous version of KAlarm, do any
+ * necessary format conversions on the events to ensure that when the calendar
+ * is saved, no information is lost or corrupted.
+ */
+void KAEvent::convertKCalEvents(KCal::Calendar& calendar, int version, bool adjustSummerTime)
+{
+	// KAlarm pre-0.9 codes held in the alarm's DESCRIPTION property
+	static const QChar   SEPARATOR        = ';';
+	static const QChar   LATE_CANCEL_CODE = 'C';
+	static const QChar   AT_LOGIN_CODE    = 'L';   // subsidiary alarm at every login
+	static const QChar   DEFERRAL_CODE    = 'D';   // extra deferred alarm
+	static const QString TEXT_PREFIX      = QString::fromLatin1("TEXT:");
+	static const QString FILE_PREFIX      = QString::fromLatin1("FILE:");
+	static const QString COMMAND_PREFIX   = QString::fromLatin1("CMD:");
+
+	// KAlarm pre-0.9.2 codes held in the event's CATEGORY property
+	static const QString BEEP_CATEGORY    = QString::fromLatin1("BEEP");
+
+	// KAlarm pre-1.1.1 LATECANCEL category with no parameter
+	static const QString LATE_CANCEL_CAT = QString::fromLatin1("LATECANCEL");
+
+	// KAlarm pre-1.3.0 TMPLDEFTIME category with no parameter
+	static const QString TEMPL_DEF_TIME_CAT = QString::fromLatin1("TMPLDEFTIME");
+
+	// KAlarm pre-1.3.1 XTERM category
+	static const QString EXEC_IN_XTERM_CAT  = QString::fromLatin1("XTERM");
+
+	// KAlarm pre-1.4.22 properties
+	static const QCString KMAIL_ID_PROPERTY("KMAILID");    // X-KDE-KALARM-KMAILID property
+
+	if (version >= calVersion())
+		return;
+
+	kdDebug(5950) << "KAEvent::convertKCalEvents(): adjusting version " << version << endl;
+	bool pre_0_7   = (version < KAlarm::Version(0,7,0));
+	bool pre_0_9   = (version < KAlarm::Version(0,9,0));
+	bool pre_0_9_2 = (version < KAlarm::Version(0,9,2));
+	bool pre_1_1_1 = (version < KAlarm::Version(1,1,1));
+	bool pre_1_2_1 = (version < KAlarm::Version(1,2,1));
+	bool pre_1_3_0 = (version < KAlarm::Version(1,3,0));
+	bool pre_1_3_1 = (version < KAlarm::Version(1,3,1));
+	bool pre_1_4_14 = (version < KAlarm::Version(1,4,14));
+	bool pre_1_5_0 = (version < KAlarm::Version(1,5,0));
+	Q_ASSERT(calVersion() == KAlarm::Version(1,5,0));
+
+	QDateTime dt0(QDate(1970,1,1), QTime(0,0,0));
+	QTime startOfDay = Preferences::startOfDay();
+
+	Event::List events = calendar.rawEvents();
+	for (Event::List::ConstIterator evit = events.begin();  evit != events.end();  ++evit)
+	{
+		Event* event = *evit;
+		Alarm::List alarms = event->alarms();
+		if (alarms.isEmpty())
+			continue;    // KAlarm isn't interested in events without alarms
+		QStringList cats = event->categories();
+		bool addLateCancel = false;
+
+		if (pre_0_7  &&  event->doesFloat())
+		{
+			// It's a KAlarm pre-0.7 calendar file.
+			// Ensure that when the calendar is saved, the alarm time isn't lost.
+			event->setFloats(false);
+		}
+
+		if (pre_0_9)
+		{
+			/*
+			 * It's a KAlarm pre-0.9 calendar file.
+			 * All alarms were of type DISPLAY. Instead of the X-KDE-KALARM-TYPE
+			 * alarm property, characteristics were stored as a prefix to the
+			 * alarm DESCRIPTION property, as follows:
+			 *   SEQNO;[FLAGS];TYPE:TEXT
+			 * where
+			 *   SEQNO = sequence number of alarm within the event
+			 *   FLAGS = C for late-cancel, L for repeat-at-login, D for deferral
+			 *   TYPE = TEXT or FILE or CMD
+			 *   TEXT = message text, file name/URL or command
+			 */
+			for (Alarm::List::ConstIterator alit = alarms.begin();  alit != alarms.end();  ++alit)
+			{
+				Alarm* alarm = *alit;
+				bool atLogin    = false;
+				bool deferral   = false;
+				bool lateCancel = false;
+				KAAlarmEventBase::Type action = T_MESSAGE;
+				QString txt = alarm->text();
+				int length = txt.length();
+				int i = 0;
+				if (txt[0].isDigit())
+				{
+					while (++i < length  &&  txt[i].isDigit()) ;
+					if (i < length  &&  txt[i++] == SEPARATOR)
+					{
+						while (i < length)
+						{
+							QChar ch = txt[i++];
+							if (ch == SEPARATOR)
+								break;
+							if (ch == LATE_CANCEL_CODE)
+								lateCancel = true;
+							else if (ch == AT_LOGIN_CODE)
+								atLogin = true;
+							else if (ch == DEFERRAL_CODE)
+								deferral = true;
+						}
+					}
+					else
+						i = 0;     // invalid prefix
+				}
+				if (txt.find(TEXT_PREFIX, i) == i)
+					i += TEXT_PREFIX.length();
+				else if (txt.find(FILE_PREFIX, i) == i)
+				{
+					action = T_FILE;
+					i += FILE_PREFIX.length();
+				}
+				else if (txt.find(COMMAND_PREFIX, i) == i)
+				{
+					action = T_COMMAND;
+					i += COMMAND_PREFIX.length();
+				}
+				else
+					i = 0;
+				txt = txt.mid(i);
+
+				QStringList types;
+				switch (action)
+				{
+					case T_FILE:
+						types += FILE_TYPE;
+						// fall through to T_MESSAGE
+					case T_MESSAGE:
+						alarm->setDisplayAlarm(txt);
+						break;
+					case T_COMMAND:
+						setProcedureAlarm(alarm, txt);
+						break;
+					case T_EMAIL:     // email alarms were introduced in KAlarm 0.9
+					case T_AUDIO:     // never occurs in this context
+						break;
+				}
+				if (atLogin)
+				{
+					types += AT_LOGIN_TYPE;
+					lateCancel = false;
+				}
+				else if (deferral)
+					types += TIME_DEFERRAL_TYPE;
+				if (lateCancel)
+					addLateCancel = true;
+				if (types.count() > 0)
+					alarm->setCustomProperty(APPNAME, TYPE_PROPERTY, types.join(","));
+
+				if (pre_0_7  &&  alarm->repeatCount() > 0  &&  alarm->snoozeTime() > 0)
+				{
+					// It's a KAlarm pre-0.7 calendar file.
+					// Minutely recurrences were stored differently.
+					Recurrence* recur = event->recurrence();
+					if (recur  &&  recur->doesRecur())
+					{
+						recur->setMinutely(alarm->snoozeTime());
+						recur->setDuration(alarm->repeatCount() + 1);
+						alarm->setRepeatCount(0);
+						alarm->setSnoozeTime(0);
+					}
+				}
+
+				if (adjustSummerTime)
+				{
+					// The calendar file was written by the KDE 3.0.0 version of KAlarm 0.5.7.
+					// Summer time was ignored when converting to UTC.
+					QDateTime dt = alarm->time();
+					time_t t = dt0.secsTo(dt);
+					struct tm* dtm = localtime(&t);
+					if (dtm->tm_isdst)
+					{
+						dt = dt.addSecs(-3600);
+						alarm->setTime(dt);
+					}
+				}
+			}
+		}
+
+		if (pre_0_9_2)
+		{
+			/*
+			 * It's a KAlarm pre-0.9.2 calendar file.
+			 * For the expired calendar, set the CREATED time to the DTEND value.
+			 * Convert date-only DTSTART to date/time, and add category "DATE".
+			 * Set the DTEND time to the DTSTART time.
+			 * Convert all alarm times to DTSTART offsets.
+			 * For display alarms, convert the first unlabelled category to an
+			 * X-KDE-KALARM-FONTCOLOUR property.
+			 * Convert BEEP category into an audio alarm with no audio file.
+			 */
+			if (uidStatus(event->uid()) == EXPIRED)
+				event->setCreated(event->dtEnd());
+			QDateTime start = event->dtStart();
+			if (event->doesFloat())
+			{
+				event->setFloats(false);
+				start.setTime(startOfDay);
+				cats.append(DATE_ONLY_CATEGORY);
+			}
+			event->setHasEndDate(false);
+
+			Alarm::List::ConstIterator alit;
+			for (alit = alarms.begin();  alit != alarms.end();  ++alit)
+			{
+				Alarm* alarm = *alit;
+				QDateTime dt = alarm->time();
+				alarm->setStartOffset(start.secsTo(dt));
+			}
+
+			if (cats.count() > 0)
+			{
+				for (alit = alarms.begin();  alit != alarms.end();  ++alit)
+				{
+					Alarm* alarm = *alit;
+					if (alarm->type() == Alarm::Display)
+						alarm->setCustomProperty(APPNAME, FONT_COLOUR_PROPERTY,
+						                         QString::fromLatin1("%1;;").arg(cats[0]));
+				}
+				cats.remove(cats.begin());
+			}
+
+			for (QStringList::Iterator it = cats.begin();  it != cats.end();  ++it)
+			{
+				if (*it == BEEP_CATEGORY)
+				{
+					cats.remove(it);
+
+					Alarm* alarm = event->newAlarm();
+					alarm->setEnabled(true);
+					alarm->setAudioAlarm();
+					QDateTime dt = event->dtStart();    // default
+
+					// Parse and order the alarms to know which one's date/time to use
+					AlarmMap alarmMap;
+					readAlarms(*event, &alarmMap);
+					AlarmMap::ConstIterator it = alarmMap.begin();
+					if (it != alarmMap.end())
+					{
+						dt = it.data().alarm->time();
+						break;
+					}
+					alarm->setStartOffset(start.secsTo(dt));
+					break;
+				}
+			}
+		}
+
+		if (pre_1_1_1)
+		{
+			/*
+			 * It's a KAlarm pre-1.1.1 calendar file.
+			 * Convert simple LATECANCEL category to LATECANCEL:n where n = minutes late.
+			 */
+			QStringList::Iterator it;
+			while ((it = cats.find(LATE_CANCEL_CAT)) != cats.end())
+			{
+				cats.remove(it);
+				addLateCancel = true;
+			}
+		}
+
+		if (pre_1_2_1)
+		{
+			/*
+			 * It's a KAlarm pre-1.2.1 calendar file.
+			 * Convert email display alarms from translated to untranslated header prefixes.
+			 */
+			for (Alarm::List::ConstIterator alit = alarms.begin();  alit != alarms.end();  ++alit)
+			{
+				Alarm* alarm = *alit;
+				if (alarm->type() == Alarm::Display)
+				{
+					QString oldtext = alarm->text();
+					QString newtext = AlarmText::toCalendarText(oldtext);
+					if (oldtext != newtext)
+						alarm->setDisplayAlarm(newtext);
+				}
+			}
+		}
+
+		if (pre_1_3_0)
+		{
+			/*
+			 * It's a KAlarm pre-1.3.0 calendar file.
+			 * Convert simple TMPLDEFTIME category to TMPLAFTTIME:n where n = minutes after.
+			 */
+			QStringList::Iterator it;
+			while ((it = cats.find(TEMPL_DEF_TIME_CAT)) != cats.end())
+			{
+				cats.remove(it);
+				cats.append(QString("%1%2").arg(TEMPL_AFTER_TIME_CATEGORY).arg(0));
+			}
+		}
+
+		if (pre_1_3_1)
+		{
+			/*
+			 * It's a KAlarm pre-1.3.1 calendar file.
+			 * Convert simple XTERM category to LOG:xterm:
+			 */
+			QStringList::Iterator it;
+			while ((it = cats.find(EXEC_IN_XTERM_CAT)) != cats.end())
+			{
+				cats.remove(it);
+				cats.append(LOG_CATEGORY + xtermURL);
+			}
+		}
+
+		if (addLateCancel)
+			cats.append(QString("%1%2").arg(LATE_CANCEL_CATEGORY).arg(1));
+
+		event->setCategories(cats);
+
+
+		if (pre_1_4_14
+		&&  event->recurrence()  &&  event->recurrence()->doesRecur())
+		{
+			/*
+			 * It's a KAlarm pre-1.4.14 calendar file.
+			 * For recurring events, convert the main alarm offset to an absolute
+			 * time in the X-KDE-KALARM-NEXTRECUR property, and convert main
+			 * alarm offsets to zero and deferral alarm offsets to be relative to
+			 * the next recurrence.
+			 */
+			bool dateOnly = (cats.find(DATE_ONLY_CATEGORY) != cats.end());
+			DateTime startDateTime(event->dtStart(), dateOnly);
+			// Convert the main alarm and get the next main trigger time from it
+			DateTime nextMainDateTime;
+			bool mainExpired = true;
+			Alarm::List::ConstIterator alit;
+			for (alit = alarms.begin();  alit != alarms.end();  ++alit)
+			{
+				Alarm* alarm = *alit;
+				if (!alarm->hasStartOffset())
+					continue;
+				bool mainAlarm = true;
+				QString property = alarm->customProperty(APPNAME, TYPE_PROPERTY);
+				QStringList types = QStringList::split(QChar(','), property);
+				for (unsigned int i = 0;  i < types.count();  ++i)
+				{
+					QString type = types[i];
+					if (type == AT_LOGIN_TYPE
+					||  type == TIME_DEFERRAL_TYPE
+					||  type == DATE_DEFERRAL_TYPE
+					||  type == REMINDER_TYPE
+					||  type == REMINDER_ONCE_TYPE
+					||  type == DISPLAYING_TYPE
+					||  type == PRE_ACTION_TYPE
+					||  type == POST_ACTION_TYPE)
+						mainAlarm = false;
+				}
+				if (mainAlarm)
+				{
+					mainExpired = false;
+					nextMainDateTime = alarm->time();
+					nextMainDateTime.setDateOnly(dateOnly);
+					if (nextMainDateTime != startDateTime)
+					{
+						QDateTime dt = nextMainDateTime.dateTime();
+						event->setCustomProperty(APPNAME, NEXT_RECUR_PROPERTY,
+						                         dt.toString(dateOnly ? "yyyyMMdd" : "yyyyMMddThhmmss"));
+					}
+					alarm->setStartOffset(0);
+				}
+			}
+			int adjustment;
+			if (mainExpired)
+			{
+				// It's an expired recurrence.
+				// Set the alarm offset relative to the first actual occurrence
+				// (taking account of possible exceptions).
+				DateTime dt = event->recurrence()->getNextDateTime(startDateTime.dateTime().addDays(-1));
+				dt.setDateOnly(dateOnly);
+				adjustment = startDateTime.secsTo(dt);
+			}
+			else
+				adjustment = startDateTime.secsTo(nextMainDateTime);
+			if (adjustment)
+			{
+				// Convert deferred alarms
+				for (alit = alarms.begin();  alit != alarms.end();  ++alit)
+				{
+					Alarm* alarm = *alit;
+					if (!alarm->hasStartOffset())
+						continue;
+					QString property = alarm->customProperty(APPNAME, TYPE_PROPERTY);
+					QStringList types = QStringList::split(QChar(','), property);
+					for (unsigned int i = 0;  i < types.count();  ++i)
+					{
+						QString type = types[i];
+						if (type == TIME_DEFERRAL_TYPE
+						||  type == DATE_DEFERRAL_TYPE)
+						{
+							alarm->setStartOffset(alarm->startOffset().asSeconds() - adjustment);
+							break;
+						}
+					}
+				}
+			}
+		}
+		
+		if (pre_1_5_0)
+		{
+			/*
+			 * It's a KAlarm pre-1.5.0 calendar file.
+			 * Convert email identity names to uoids.
+			 * Convert simple repetitions without a recurrence, to a recurrence.
+			 */
+			for (Alarm::List::ConstIterator alit = alarms.begin();  alit != alarms.end();  ++alit)
+			{
+				Alarm* alarm = *alit;
+				QString name = alarm->customProperty(APPNAME, KMAIL_ID_PROPERTY);
+				if (name.isEmpty())
+					continue;
+				uint id = KAMail::identityUoid(name);
+				if (id)
+					alarm->setCustomProperty(APPNAME, EMAIL_ID_PROPERTY, QString::number(id));
+				alarm->removeCustomProperty(APPNAME, KMAIL_ID_PROPERTY);
+			}
+			convertRepetition(event);
+		}
+	}
+}
+
+/******************************************************************************
+* If the calendar was written by a pre-1.4.22 version of KAlarm, or another
+* program, convert simple repetitions in events without a recurrence, to a
+* recurrence.
+* Reply = true if any conversions were done.
+*/
+void KAEvent::convertRepetitions(KCal::CalendarLocal& calendar)
+{
+
+	Event::List events = calendar.rawEvents();
+	for (Event::List::ConstIterator ev = events.begin();  ev != events.end();  ++ev)
+		convertRepetition(*ev);
+}
+
+/******************************************************************************
+* Convert simple repetitions in an event without a recurrence, to a
+* recurrence. Repetitions which are an exact multiple of 24 hours are converted
+* to daily recurrences; else they are converted to minutely recurrences. Note
+* that daily and minutely recurrences produce different results when they span
+* a daylight saving time change.
+* Reply = true if any conversions were done.
+*/
+bool KAEvent::convertRepetition(KCal::Event* event)
+{
+	Alarm::List alarms = event->alarms();
+	if (alarms.isEmpty())
+		return false;
+	Recurrence* recur = event->recurrence();   // guaranteed to return non-null
+	if (!recur->doesRecur())
+		return false;
+	bool converted = false;
+	bool readOnly = event->isReadOnly();
+	for (Alarm::List::ConstIterator alit = alarms.begin();  alit != alarms.end();  ++alit)
+	{
+		Alarm* alarm = *alit;
+		if (alarm->repeatCount() > 0  &&  alarm->snoozeTime() > 0)
+		{
+			if (!converted)
+			{
+				if (readOnly)
+					event->setReadOnly(false);
+				if (alarm->snoozeTime() % (24*3600))
+					recur->setMinutely(alarm->snoozeTime());
+				else
+					recur->setDaily(alarm->snoozeTime() / (24*3600));
+				recur->setDuration(alarm->repeatCount() + 1);
+				converted = true;
+			}
+			alarm->setRepeatCount(0);
+			alarm->setSnoozeTime(0);
+		}
+	}
+	if (converted)
+	{
+		if (readOnly)
+			event->setReadOnly(true);
+	}
+	return converted;
+}
+
+#ifndef NDEBUG
+void KAEvent::dumpDebug() const
+{
+	kdDebug(5950) << "KAEvent dump:\n";
+	KAAlarmEventBase::dumpDebug();
+	if (!mTemplateName.isEmpty())
+	{
+		kdDebug(5950) << "-- mTemplateName:" << mTemplateName << ":\n";
+		kdDebug(5950) << "-- mTemplateAfterTime:" << mTemplateAfterTime << ":\n";
+	}
+	if (mActionType == T_MESSAGE  ||  mActionType == T_FILE)
+	{
+		kdDebug(5950) << "-- mAudioFile:" << mAudioFile << ":\n";
+		kdDebug(5950) << "-- mPreAction:" << mPreAction << ":\n";
+		kdDebug(5950) << "-- mPostAction:" << mPostAction << ":\n";
+	}
+	else if (mActionType == T_COMMAND)
+	{
+		kdDebug(5950) << "-- mCommandXterm:" << (mCommandXterm ? "true" : "false") << ":\n";
+		kdDebug(5950) << "-- mLogFile:" << mLogFile << ":\n";
+	}
+	kdDebug(5950) << "-- mKMailSerialNumber:" << mKMailSerialNumber << ":\n";
+	kdDebug(5950) << "-- mCopyToKOrganizer:" << (mCopyToKOrganizer ? "true" : "false") << ":\n";
+	kdDebug(5950) << "-- mStartDateTime:" << mStartDateTime.toString() << ":\n";
+	kdDebug(5950) << "-- mSaveDateTime:" << mSaveDateTime.toString() << ":\n";
+	if (mRepeatAtLogin)
+		kdDebug(5950) << "-- mAtLoginDateTime:" << mAtLoginDateTime.toString() << ":\n";
+	kdDebug(5950) << "-- mArchiveRepeatAtLogin:" << (mArchiveRepeatAtLogin ? "true" : "false") << ":\n";
+	kdDebug(5950) << "-- mEnabled:" << (mEnabled ? "true" : "false") << ":\n";
+	if (mReminderMinutes)
+		kdDebug(5950) << "-- mReminderMinutes:" << mReminderMinutes << ":\n";
+	if (mArchiveReminderMinutes)
+		kdDebug(5950) << "-- mArchiveReminderMinutes:" << mArchiveReminderMinutes << ":\n";
+	if (mReminderMinutes  ||  mArchiveReminderMinutes)
+		kdDebug(5950) << "-- mReminderOnceOnly:" << mReminderOnceOnly << ":\n";
+	else if (mDeferral > 0)
+	{
+		kdDebug(5950) << "-- mDeferral:" << (mDeferral == NORMAL_DEFERRAL ? "normal" : "reminder") << ":\n";
+		kdDebug(5950) << "-- mDeferralTime:" << mDeferralTime.toString() << ":\n";
+	}
+	else if (mDeferral == CANCEL_DEFERRAL)
+		kdDebug(5950) << "-- mDeferral:cancel:\n";
+	kdDebug(5950) << "-- mDeferDefaultMinutes:" << mDeferDefaultMinutes << ":\n";
+	if (mDisplaying)
+	{
+		kdDebug(5950) << "-- mDisplayingTime:" << mDisplayingTime.toString() << ":\n";
+		kdDebug(5950) << "-- mDisplayingFlags:" << mDisplayingFlags << ":\n";
+	}
+	kdDebug(5950) << "-- mRevision:" << mRevision << ":\n";
+	kdDebug(5950) << "-- mRecurrence:" << (mRecurrence ? "true" : "false") << ":\n";
+	kdDebug(5950) << "-- mAlarmCount:" << mAlarmCount << ":\n";
+	kdDebug(5950) << "-- mMainExpired:" << (mMainExpired ? "true" : "false") << ":\n";
+	kdDebug(5950) << "KAEvent dump end\n";
+}
+#endif
+
+
+/*=============================================================================
+= Class KAAlarm
+= Corresponds to a single KCal::Alarm instance.
+=============================================================================*/
+
+KAAlarm::KAAlarm(const KAAlarm& alarm)
+	: KAAlarmEventBase(alarm),
+	  mType(alarm.mType),
+	  mRecurs(alarm.mRecurs),
+	  mDeferred(alarm.mDeferred)
+{ }
+
+
+int KAAlarm::flags() const
+{
+	return KAAlarmEventBase::flags()
+	     | (mDeferred ? KAEvent::DEFERRAL : 0);
+
+}
+
+#ifndef NDEBUG
+void KAAlarm::dumpDebug() const
+{
+	kdDebug(5950) << "KAAlarm dump:\n";
+	KAAlarmEventBase::dumpDebug();
+	const char* altype = 0;
+	switch (mType)
+	{
+		case MAIN__ALARM:                    altype = "MAIN";  break;
+		case REMINDER__ALARM:                altype = "REMINDER";  break;
+		case DEFERRED_DATE__ALARM:           altype = "DEFERRED(DATE)";  break;
+		case DEFERRED_TIME__ALARM:           altype = "DEFERRED(TIME)";  break;
+		case DEFERRED_REMINDER_DATE__ALARM:  altype = "DEFERRED_REMINDER(DATE)";  break;
+		case DEFERRED_REMINDER_TIME__ALARM:  altype = "DEFERRED_REMINDER(TIME)";  break;
+		case AT_LOGIN__ALARM:                altype = "LOGIN";  break;
+		case DISPLAYING__ALARM:              altype = "DISPLAYING";  break;
+		case AUDIO__ALARM:                   altype = "AUDIO";  break;
+		case PRE_ACTION__ALARM:              altype = "PRE_ACTION";  break;
+		case POST_ACTION__ALARM:             altype = "POST_ACTION";  break;
+		default:                             altype = "INVALID";  break;
+	}
+	kdDebug(5950) << "-- mType:" << altype << ":\n";
+	kdDebug(5950) << "-- mRecurs:" << (mRecurs ? "true" : "false") << ":\n";
+	kdDebug(5950) << "-- mDeferred:" << (mDeferred ? "true" : "false") << ":\n";
+	kdDebug(5950) << "KAAlarm dump end\n";
+}
+
+const char* KAAlarm::debugType(Type type)
+{
+	switch (type)
+	{
+		case MAIN_ALARM:               return "MAIN";
+		case REMINDER_ALARM:           return "REMINDER";
+		case DEFERRED_ALARM:           return "DEFERRED";
+		case DEFERRED_REMINDER_ALARM:  return "DEFERRED_REMINDER";
+		case AT_LOGIN_ALARM:           return "LOGIN";
+		case DISPLAYING_ALARM:         return "DISPLAYING";
+		case AUDIO_ALARM:              return "AUDIO";
+		case PRE_ACTION_ALARM:         return "PRE_ACTION";
+		case POST_ACTION_ALARM:        return "POST_ACTION";
+		default:                       return "INVALID";
+	}
+}
+#endif
+
+
+/*=============================================================================
+= Class KAAlarmEventBase
+=============================================================================*/
+
+void KAAlarmEventBase::copy(const KAAlarmEventBase& rhs)
+{
+	mEventID           = rhs.mEventID;
+	mText              = rhs.mText;
+	mNextMainDateTime  = rhs.mNextMainDateTime;
+	mBgColour          = rhs.mBgColour;
+	mFgColour          = rhs.mFgColour;
+	mFont              = rhs.mFont;
+	mEmailFromIdentity = rhs.mEmailFromIdentity;
+	mEmailAddresses    = rhs.mEmailAddresses;
+	mEmailSubject      = rhs.mEmailSubject;
+	mEmailAttachments  = rhs.mEmailAttachments;
+	mSoundVolume       = rhs.mSoundVolume;
+	mFadeVolume        = rhs.mFadeVolume;
+	mFadeSeconds       = rhs.mFadeSeconds;
+	mActionType        = rhs.mActionType;
+	mCommandScript     = rhs.mCommandScript;
+	mRepeatCount       = rhs.mRepeatCount;
+	mRepeatInterval    = rhs.mRepeatInterval;
+	mNextRepeat        = rhs.mNextRepeat;
+	mBeep              = rhs.mBeep;
+	mSpeak             = rhs.mSpeak;
+	mRepeatSound       = rhs.mRepeatSound;
+	mRepeatAtLogin     = rhs.mRepeatAtLogin;
+	mDisplaying        = rhs.mDisplaying;
+	mLateCancel        = rhs.mLateCancel;
+	mAutoClose         = rhs.mAutoClose;
+	mEmailBcc          = rhs.mEmailBcc;
+	mConfirmAck        = rhs.mConfirmAck;
+	mDefaultFont       = rhs.mDefaultFont;
+}
+
+void KAAlarmEventBase::set(int flags)
+{
+	mSpeak         = flags & KAEvent::SPEAK;
+	mBeep          = (flags & KAEvent::BEEP) && !mSpeak;
+	mRepeatSound   = flags & KAEvent::REPEAT_SOUND;
+	mRepeatAtLogin = flags & KAEvent::REPEAT_AT_LOGIN;
+	mAutoClose     = (flags & KAEvent::AUTO_CLOSE) && mLateCancel;
+	mEmailBcc      = flags & KAEvent::EMAIL_BCC;
+	mConfirmAck    = flags & KAEvent::CONFIRM_ACK;
+	mDisplaying    = flags & KAEvent::DISPLAYING_;
+	mDefaultFont   = flags & KAEvent::DEFAULT_FONT;
+	mCommandScript = flags & KAEvent::SCRIPT;
+}
+
+int KAAlarmEventBase::flags() const
+{
+	return (mBeep && !mSpeak ? KAEvent::BEEP : 0)
+	     | (mSpeak           ? KAEvent::SPEAK : 0)
+	     | (mRepeatSound     ? KAEvent::REPEAT_SOUND : 0)
+	     | (mRepeatAtLogin   ? KAEvent::REPEAT_AT_LOGIN : 0)
+	     | (mAutoClose       ? KAEvent::AUTO_CLOSE : 0)
+	     | (mEmailBcc        ? KAEvent::EMAIL_BCC : 0)
+	     | (mConfirmAck      ? KAEvent::CONFIRM_ACK : 0)
+	     | (mDisplaying      ? KAEvent::DISPLAYING_ : 0)
+	     | (mDefaultFont     ? KAEvent::DEFAULT_FONT : 0)
+	     | (mCommandScript   ? KAEvent::SCRIPT : 0);
+}
+
+const QFont& KAAlarmEventBase::font() const
+{
+	return mDefaultFont ? Preferences::messageFont() : mFont;
+}
+
+#ifndef NDEBUG
+void KAAlarmEventBase::dumpDebug() const
+{
+	kdDebug(5950) << "-- mEventID:" << mEventID << ":\n";
+	kdDebug(5950) << "-- mActionType:" << (mActionType == T_MESSAGE ? "MESSAGE" : mActionType == T_FILE ? "FILE" : mActionType == T_COMMAND ? "COMMAND" : mActionType == T_EMAIL ? "EMAIL" : mActionType == T_AUDIO ? "AUDIO" : "??") << ":\n";
+	kdDebug(5950) << "-- mText:" << mText << ":\n";
+	if (mActionType == T_COMMAND)
+		kdDebug(5950) << "-- mCommandScript:" << (mCommandScript ? "true" : "false") << ":\n";
+	kdDebug(5950) << "-- mNextMainDateTime:" << mNextMainDateTime.toString() << ":\n";
+	if (mActionType == T_EMAIL)
+	{
+		kdDebug(5950) << "-- mEmail: FromKMail:" << mEmailFromIdentity << ":\n";
+		kdDebug(5950) << "--         Addresses:" << mEmailAddresses.join(", ") << ":\n";
+		kdDebug(5950) << "--         Subject:" << mEmailSubject << ":\n";
+		kdDebug(5950) << "--         Attachments:" << mEmailAttachments.join(", ") << ":\n";
+		kdDebug(5950) << "--         Bcc:" << (mEmailBcc ? "true" : "false") << ":\n";
+	}
+	kdDebug(5950) << "-- mBgColour:" << mBgColour.name() << ":\n";
+	kdDebug(5950) << "-- mFgColour:" << mFgColour.name() << ":\n";
+	kdDebug(5950) << "-- mDefaultFont:" << (mDefaultFont ? "true" : "false") << ":\n";
+	if (!mDefaultFont)
+		kdDebug(5950) << "-- mFont:" << mFont.toString() << ":\n";
+	kdDebug(5950) << "-- mBeep:" << (mBeep ? "true" : "false") << ":\n";
+	kdDebug(5950) << "-- mSpeak:" << (mSpeak ? "true" : "false") << ":\n";
+	if (mActionType == T_AUDIO)
+	{
+		if (mSoundVolume >= 0)
+		{
+			kdDebug(5950) << "-- mSoundVolume:" << mSoundVolume << ":\n";
+			if (mFadeVolume >= 0)
+			{
+				kdDebug(5950) << "-- mFadeVolume:" << mFadeVolume << ":\n";
+				kdDebug(5950) << "-- mFadeSeconds:" << mFadeSeconds << ":\n";
+			}
+			else
+				kdDebug(5950) << "-- mFadeVolume:-:\n";
+		}
+		else
+			kdDebug(5950) << "-- mSoundVolume:-:\n";
+		kdDebug(5950) << "-- mRepeatSound:" << (mRepeatSound ? "true" : "false") << ":\n";
+	}
+	kdDebug(5950) << "-- mConfirmAck:" << (mConfirmAck ? "true" : "false") << ":\n";
+	kdDebug(5950) << "-- mRepeatAtLogin:" << (mRepeatAtLogin ? "true" : "false") << ":\n";
+	kdDebug(5950) << "-- mRepeatCount:" << mRepeatCount << ":\n";
+	kdDebug(5950) << "-- mRepeatInterval:" << mRepeatInterval << ":\n";
+	kdDebug(5950) << "-- mNextRepeat:" << mNextRepeat << ":\n";
+	kdDebug(5950) << "-- mDisplaying:" << (mDisplaying ? "true" : "false") << ":\n";
+	kdDebug(5950) << "-- mLateCancel:" << mLateCancel << ":\n";
+	kdDebug(5950) << "-- mAutoClose:" << (mAutoClose ? "true" : "false") << ":\n";
+}
+#endif
+
+
+/*=============================================================================
+= Class EmailAddressList
+=============================================================================*/
+
+/******************************************************************************
+ * Sets the list of email addresses, removing any empty addresses.
+ * Reply = false if empty addresses were found.
+ */
+EmailAddressList& EmailAddressList::operator=(const QValueList<Person>& addresses)
+{
+	clear();
+	for (QValueList<Person>::ConstIterator it = addresses.begin();  it != addresses.end();  ++it)
+	{
+		if (!(*it).email().isEmpty())
+			append(*it);
+	}
+	return *this;
+}
+
+/******************************************************************************
+ * Return the email address list as a string, each address being delimited by
+ * the specified separator string.
+ */
+QString EmailAddressList::join(const QString& separator) const
+{
+	QString result;
+	bool first = true;
+	for (QValueList<Person>::ConstIterator it = begin();  it != end();  ++it)
+	{
+		if (first)
+			first = false;
+		else
+			result += separator;
+
+		bool quote = false;
+		QString name = (*it).name();
+		if (!name.isEmpty())
+		{
+			// Need to enclose the name in quotes if it has any special characters
+			int len = name.length();
+			for (int i = 0;  i < len;  ++i)
+			{
+				QChar ch = name[i];
+				if (!ch.isLetterOrNumber())
+				{
+					quote = true;
+					result += '\"';
+					break;
+				}
+			}
+			result += (*it).name();
+			result += (quote ? "\" <" : " <");
+			quote = true;    // need angle brackets round email address
+		}
+
+		result += (*it).email();
+		if (quote)
+			result += '>';
+	}
+	return result;
+}
+
+
+/*=============================================================================
+= Static functions
+=============================================================================*/
+
+/******************************************************************************
+ * Set the specified alarm to be a procedure alarm with the given command line.
+ * The command line is first split into its program file and arguments before
+ * initialising the alarm.
+ */
+static void setProcedureAlarm(Alarm* alarm, const QString& commandLine)
+{
+	QString command   = QString::null;
+	QString arguments = QString::null;
+	QChar quoteChar;
+	bool quoted = false;
+	uint posMax = commandLine.length();
+	uint pos;
+	for (pos = 0;  pos < posMax;  ++pos)
+	{
+		QChar ch = commandLine[pos];
+		if (quoted)
+		{
+			if (ch == quoteChar)
+			{
+				++pos;    // omit the quote character
+				break;
+			}
+			command += ch;
+		}
+		else
+		{
+			bool done = false;
+			switch (ch)
+			{
+				case ' ':
+				case ';':
+				case '|':
+				case '<':
+				case '>':
+					done = !command.isEmpty();
+					break;
+				case '\'':
+				case '"':
+					if (command.isEmpty())
+					{
+						// Start of a quoted string. Omit the quote character.
+						quoted = true;
+						quoteChar = ch;
+						break;
+					}
+					// fall through to default
+				default:
+					command += ch;
+					break;
+			}
+			if (done)
+				break;
+		}
+	}
+
+	// Skip any spaces after the command
+	for ( ;  pos < posMax  &&  commandLine[pos] == ' ';  ++pos) ;
+	arguments = commandLine.mid(pos);
+
+	alarm->setProcedureAlarm(command, arguments);
+}