Initial revision

1 files changed, 1121 insertions, 0 deletions

diff --git a/library/datebookdb.cpp b/library/datebookdb.cpp
new file mode 100644
index 0000000..bf7fd94
--- a/dev/null
+++ b/library/datebookdb.cpp
@@ -0,0 +1,1121 @@
+/**********************************************************************
+** Copyright (C) 2000 Trolltech AS.  All rights reserved.
+**
+** This file is part of Qtopia Environment.
+**
+** This file may be distributed and/or modified under the terms of the
+** GNU General Public License version 2 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.
+**
+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+**
+** See http://www.trolltech.com/gpl/ for GPL licensing information.
+**
+** Contact info@trolltech.com if any conditions of this licensing are
+** not clear to you.
+**
+**********************************************************************/
+
+#include <qasciidict.h>
+#include <qfile.h>
+#include <qmessagebox.h>
+#include <qstring.h>
+#include <qtextcodec.h>
+#include <qtextstream.h>
+#include <qtl.h>
+
+#include <qpe/alarmserver.h>
+#include <qpe/global.h>
+#include "datebookdb.h"
+#include <qpe/stringutil.h>
+#include <qpe/timeconversion.h>
+
+#include <errno.h>
+#include <stdlib.h>
+
+
+class DateBookDBPrivate
+{
+public:
+    bool clean;  // indcate whether we need to write to disk...
+};
+
+
+// Helper functions
+
+static QString dateBookJournalFile()
+{
+    QString str = getenv("HOME");
+    return QString( str +"/.caljournal" );
+}
+
+static QString dateBookFilename()
+{
+    return Global::applicationFileName("datebook","datebook.xml");
+}
+
+/* Calculating the next event of a recuring event is actually
+   computationally inexpensive, esp. compared to checking each day
+   individually.  There are bad worse cases for say the 29th of
+   february or the 31st of some other months.  However
+   these are still bounded */
+bool nextOccurance(const Event &e, const QDate &from, QDateTime &next)
+{
+    // easy checks, first are we too far in the future or too far in the past?
+    QDate tmpDate;
+    int freq = e.repeatPattern().frequency;
+    int diff, diff2, a;
+    int iday, imonth, iyear;
+    int dayOfWeek = 0;
+    int firstOfWeek = 0;
+    int weekOfMonth;
+    
+
+    if (e.repeatPattern().hasEndDate && e.repeatPattern().endDate() < from)
+	return FALSE;
+
+    if (e.start() >= from) {
+	next = e.start();
+	return TRUE;
+    }
+
+    switch ( e.repeatPattern().type ) {
+	case Event::Weekly:
+	    /* weekly is just daily by 7 */
+	    /* first convert the repeatPattern.Days() mask to the next
+	       day of week valid after from */
+            dayOfWeek = from.dayOfWeek();
+	    dayOfWeek--; /* we want 0-6, doco for above specs 1-7 */
+
+	    /* this is done in case freq > 1 and from in week not
+	       for this round */
+	    // firstOfWeek = 0; this is already done at decl.
+	    while(!((1 << firstOfWeek) & e.repeatPattern().days))
+		firstOfWeek++;
+
+	    /* there is at least one 'day', or there would be no event */
+	    while(!((1 << (dayOfWeek % 7)) & e.repeatPattern().days))
+		dayOfWeek++;
+
+	    dayOfWeek = dayOfWeek % 7; /* the actual day of week */
+	    dayOfWeek -= e.start().date().dayOfWeek() -1;
+
+	    firstOfWeek = firstOfWeek % 7; /* the actual first of week */
+	    firstOfWeek -= e.start().date().dayOfWeek() -1;
+
+	    // dayOfWeek may be negitive now
+	    // day of week is number of days to add to start day
+
+	    freq *= 7;
+	    // FALL-THROUGH !!!!!
+	case Event::Daily:
+	    // the add is for the possible fall through from weekly */
+	    if(e.start().date().addDays(dayOfWeek) > from) {
+		/* first week exception */
+		next = QDateTime(e.start().date().addDays(dayOfWeek),
+				 e.start().time());
+		if ((next.date() > e.repeatPattern().endDate())
+		    && e.repeatPattern().hasEndDate)
+		    return FALSE;
+		return TRUE;
+	    }
+	    /* if from is middle of a non-week */
+
+	    diff = e.start().date().addDays(dayOfWeek).daysTo(from) % freq;
+	    diff2 = e.start().date().addDays(firstOfWeek).daysTo(from) % freq;
+
+	    if(diff != 0)
+		diff = freq - diff;
+	    if(diff2 != 0)
+		diff2 = freq - diff2;
+	    diff = QMIN(diff, diff2);
+
+	    next = QDateTime(from.addDays(diff), e.start().time());
+	    if ( (next.date() > e.repeatPattern().endDate())
+		 && e.repeatPattern().hasEndDate )
+		return FALSE;
+	    return TRUE;
+	case Event::MonthlyDay:
+	    iday = from.day();
+	    iyear = from.year();
+	    imonth = from.month();
+	    /* find equivelent day of month for this month */
+	    dayOfWeek = e.start().date().dayOfWeek();
+	    weekOfMonth = (e.start().date().day() - 1) / 7;
+
+	    /* work out when the next valid month is */
+	    a = from.year() - e.start().date().year();
+	    a *= 12;
+	    a = a + (imonth - e.start().date().month());
+	    /* a is e.start()monthsFrom(from); */
+	    if(a % freq) {
+		a = freq - (a % freq);
+		imonth = from.month() + a;
+		if (imonth > 12) {
+		    imonth--;
+		    iyear += imonth / 12;
+		    imonth = imonth % 12;
+		    imonth++;
+		}
+	    }
+	    /* imonth is now the first month after or on
+	       from that matches the frequency given */
+
+	    /* find for this month */
+	    tmpDate = QDate( iyear, imonth, 1 );
+
+	    iday = 1;
+	    iday += (7 + dayOfWeek - tmpDate.dayOfWeek()) % 7;
+	    iday += 7 * weekOfMonth;
+	    while (iday > tmpDate.daysInMonth()) {
+		imonth += freq;
+		if (imonth > 12) {
+		    imonth--;
+		    iyear += imonth / 12;
+		    imonth = imonth % 12;
+		    imonth++;
+		}
+		tmpDate = QDate( iyear, imonth, 1 );
+		/* these loops could go for a while, check end case now */
+		if ((tmpDate > e.repeatPattern().endDate()) && e.repeatPattern().hasEndDate)
+		    return FALSE;
+		iday = 1;
+		iday += (7 + dayOfWeek - tmpDate.dayOfWeek()) % 7;
+		iday += 7 * weekOfMonth;
+	    }
+	    tmpDate = QDate(iyear, imonth, iday);
+
+	    if (tmpDate >= from) {
+		next = QDateTime(tmpDate, e.start().time());
+		if ((next.date() > e.repeatPattern().endDate()) && e.repeatPattern().hasEndDate)
+		    return FALSE;
+		return TRUE;
+	    }
+
+	    /* need to find the next iteration */
+	    do {
+		imonth += freq;
+		if (imonth > 12) {
+		    imonth--;
+		    iyear += imonth / 12;
+		    imonth = imonth % 12;
+		    imonth++;
+		}
+		tmpDate = QDate( iyear, imonth, 1 );
+		/* these loops could go for a while, check end case now */
+		if ((tmpDate > e.repeatPattern().endDate()) && e.repeatPattern().hasEndDate)
+		    return FALSE;
+		iday = 1;
+		iday += (7 + dayOfWeek - tmpDate.dayOfWeek()) % 7;
+		iday += 7 * weekOfMonth;
+	    } while (iday > tmpDate.daysInMonth());
+	    tmpDate = QDate(iyear, imonth, iday);
+
+	    next = QDateTime(tmpDate, e.start().time());
+	    if ((next.date() > e.repeatPattern().endDate()) && e.repeatPattern().hasEndDate)
+		return FALSE;
+	    return TRUE;
+	case Event::MonthlyDate:
+	    iday = e.start().date().day();
+	    iyear = from.year();
+	    imonth = from.month();
+
+	    a = from.year() - e.start().date().year();
+	    a *= 12;
+	    a = a + (imonth - e.start().date().month());
+	    /* a is e.start()monthsFrom(from); */
+	    if(a % freq) {
+		a = freq - (a % freq);
+		imonth = from.month() + a;
+		if (imonth > 12) {
+		    imonth--;
+		    iyear += imonth / 12;
+		    imonth = imonth % 12;
+		    imonth++;
+		}
+	    }
+	    /* imonth is now the first month after or on
+	       from that matches the frequencey given */
+
+	    /* this could go for a while, worse case, 4*12 iterations, probably */
+	    while(!QDate::isValid(iyear, imonth, iday) ) {
+		imonth += freq;
+		if (imonth > 12) {
+		    imonth--;
+		    iyear += imonth / 12;
+		    imonth = imonth % 12;
+		    imonth++;
+		}
+		/* these loops could go for a while, check end case now */
+		if ((QDate(iyear, imonth, 1) > e.repeatPattern().endDate()) && e.repeatPattern().hasEndDate)
+		    return FALSE;
+	    }
+
+	    if(QDate(iyear, imonth, iday) >= from) {
+		/* done */
+		next = QDateTime(QDate(iyear, imonth, iday),
+			e.start().time());
+		if ((next.date() > e.repeatPattern().endDate()) && e.repeatPattern().hasEndDate)
+		    return FALSE;
+		return TRUE;
+	    }
+
+	    /* ok, need to cycle */
+	    imonth += freq;
+	    imonth--;
+	    iyear += imonth / 12;
+	    imonth = imonth % 12;
+	    imonth++;
+
+	    while(!QDate::isValid(iyear, imonth, iday) ) {
+		imonth += freq;
+		imonth--;
+		iyear += imonth / 12;
+		imonth = imonth % 12;
+		imonth++;
+		if ((QDate(iyear, imonth, 1) > e.repeatPattern().endDate()) && e.repeatPattern().hasEndDate)
+		    return FALSE;
+	    }
+
+	    next = QDateTime(QDate(iyear, imonth, iday), e.start().time());
+	    if ((next.date() > e.repeatPattern().endDate()) && e.repeatPattern().hasEndDate)
+		return FALSE;
+	    return TRUE;
+	case Event::Yearly:
+	    iday = e.start().date().day();
+	    imonth = e.start().date().month();
+	    iyear = from.year(); // after all, we want to start in this year
+
+	    diff = 1;
+	    if(imonth == 2 && iday > 28) {
+		/* leap year, and it counts, calculate actual frequency */
+		if(freq % 4)
+		    if (freq % 2)
+			freq = freq * 4;
+		    else
+			freq = freq * 2;
+		/* else divides by 4 already, leave freq alone */
+		diff = 4;
+	    }
+
+	    a = from.year() - e.start().date().year();
+	    if(a % freq) {
+		a = freq - (a % freq);
+		iyear = iyear + a;
+	    }
+
+	    /* under the assumption we won't hit one of the special not-leap years twice */
+	    if(!QDate::isValid(iyear, imonth, iday)) {
+		/* must have been skipping by leap years and hit one that wasn't, (e.g. 2100) */
+		iyear += freq;
+	    }
+
+	    if(QDate(iyear, imonth, iday) >= from) {
+		next = QDateTime(QDate(iyear, imonth, iday),
+			e.start().time());
+		if ((next.date() > e.repeatPattern().endDate()) && e.repeatPattern().hasEndDate)
+		    return FALSE;
+		return TRUE;
+	    }
+	    /* iyear == from.year(), need to advance again */
+	    iyear += freq;
+	    /* under the assumption we won't hit one of the special not-leap years twice */
+	    if(!QDate::isValid(iyear, imonth, iday)) {
+		/* must have been skipping by leap years and hit one that wasn't, (e.g. 2100) */
+		iyear += freq;
+	    }
+
+	    next = QDateTime(QDate(iyear, imonth, iday), e.start().time());
+	    if ((next.date() > e.repeatPattern().endDate()) && e.repeatPattern().hasEndDate)
+		return FALSE;
+	    return TRUE;
+	default:
+	    return FALSE;
+    }
+}
+
+static bool nextAlarm( const Event &ev, QDateTime& when, int& warn)
+{
+    QDateTime now = QDateTime::currentDateTime();
+    if ( ev.hasRepeat() ) {
+	QDateTime ralarm;
+	if (nextOccurance(ev, now.date(), ralarm)) {
+	    ralarm = ralarm.addSecs(-ev.alarmTime()*60);
+	    if ( ralarm > now ) {
+		when = ralarm;
+		warn = ev.alarmTime();
+	    } else if ( nextOccurance(ev, now.date().addDays(1), ralarm) ) {
+		ralarm = ralarm.addSecs( -ev.alarmTime()*60 );
+		if ( ralarm > now ) {
+		    when = ralarm;
+		    warn = ev.alarmTime();
+		}
+	    }
+	}
+    } else {
+	warn = ev.alarmTime();
+	when = ev.start().addSecs( -ev.alarmTime()*60 );
+    }
+    return when > now;
+}
+
+static void addEventAlarm( const Event &ev )
+{
+    QDateTime when;
+    int warn;
+    if ( nextAlarm(ev,when,warn) )
+	AlarmServer::addAlarm( when,
+			       "QPE/Application/datebook",
+			       "alarm(QDateTime,int)", warn );
+}
+
+static void delEventAlarm( const Event &ev )
+{
+    QDateTime when;
+    int warn;
+    if ( nextAlarm(ev,when,warn) )
+	AlarmServer::deleteAlarm( when,
+				  "QPE/Application/datebook",
+				  "alarm(QDateTime,int)", warn );
+}
+
+
+DateBookDB::DateBookDB()
+{
+    init();
+}
+
+DateBookDB::~DateBookDB()
+{
+    save();
+    eventList.clear();
+    repeatEvents.clear();
+}
+
+
+//#### Why is this code duplicated in getEffectiveEvents ?????
+//#### Addendum.  Don't use this function, lets faze it out if we can.
+QValueList<Event> DateBookDB::getEvents( const QDate &from, const QDate &to )
+{
+    QValueList<Event> tmpList;
+    tmpList = getNonRepeatingEvents( from, to );
+
+    // check for repeating events...
+    for (QValueList<Event>::ConstIterator it = repeatEvents.begin();
+	 it != repeatEvents.end(); ++it) {
+	QDate itDate = from;
+	QDateTime due;
+
+	/* create a false end date, to short circuit on hard
+	   MonthlyDay recurences */
+	Event dummy_event = *it;
+	Event::RepeatPattern r = dummy_event.repeatPattern();
+	if ( !r.hasEndDate || r.endDate() > to ) {
+	    r.setEndDate( to );
+	    r.hasEndDate = TRUE;
+	}
+	dummy_event.setRepeat(TRUE, r);
+
+	while (nextOccurance(dummy_event, itDate, due)) {
+	    if (due.date() > to)
+		break;
+	    Event newEvent = *it;
+	    newEvent.setStart(due);
+	    newEvent.setEnd(due.addSecs((*it).start().secsTo((*it).end())));
+
+	    tmpList.append(newEvent);
+	    itDate = due.date().addDays(1);  /* the next event */
+	}
+    }
+    qHeapSort(tmpList);
+    return tmpList;
+}
+
+QValueList<Event> DateBookDB::getEvents( const QDateTime &start )
+{
+    QValueList<Event> day = getEvents(start.date(),start.date());
+
+    QValueListConstIterator<Event> it;
+    QDateTime dtTmp;
+    QValueList<Event> tmpList;
+    for (it = day.begin(); it != day.end(); ++it ) {
+        dtTmp = (*it).start(TRUE);
+        if ( dtTmp == start )
+            tmpList.append( *it );
+    }
+    return tmpList;
+}
+
+//#### Why is this code duplicated in getEvents ?????
+
+QValueList<EffectiveEvent> DateBookDB::getEffectiveEvents( const QDate &from,
+							   const QDate &to )
+{
+    QValueList<EffectiveEvent> tmpList;
+    QValueListIterator<Event> it;
+
+    EffectiveEvent effEv;
+    QDateTime dtTmp,
+	      dtEnd;
+
+    for (it = eventList.begin(); it != eventList.end(); ++it ) {
+        dtTmp = (*it).start(TRUE);
+	dtEnd = (*it).end(TRUE);
+
+        if ( dtTmp.date() >= from && dtTmp.date() <= to ) {
+	    Event tmpEv = *it;
+	    effEv.setEvent(tmpEv);
+	    effEv.setDate( dtTmp.date() );
+	    effEv.setStart( dtTmp.time() );
+	    if ( dtTmp.date() != dtEnd.date() )
+		effEv.setEnd( QTime(23, 59, 0) );
+	    else
+		effEv.setEnd( dtEnd.time() );
+            tmpList.append( effEv );
+	}
+	// we must also check for end date information...
+	if ( dtEnd.date() != dtTmp.date() && dtEnd.date() >= from ) {
+	    QDateTime dt = dtTmp.addDays( 1 );
+	    dt.setTime( QTime(0, 0, 0) );
+	    QDateTime dtStop;
+	    if ( dtEnd > to ) {
+		dtStop = to;
+	    } else
+		dtStop = dtEnd;
+	    while ( dt <= dtStop ) {
+		Event tmpEv = *it;
+		effEv.setEvent( tmpEv );
+		effEv.setDate( dt.date() );
+		if ( dt >= from ) {
+		    effEv.setStart( QTime(0, 0, 0) );
+		    if ( dt.date() == dtEnd.date() )
+			effEv.setEnd( dtEnd.time() );
+		    else
+			effEv.setEnd( QTime(23, 59, 59) );
+		    tmpList.append( effEv );
+		}
+		dt = dt.addDays( 1 );
+	    }
+	}
+    }
+    // check for repeating events...
+    QDateTime repeat;
+    for ( it = repeatEvents.begin(); it != repeatEvents.end(); ++it ) {
+
+	/* create a false end date, to short circuit on hard
+	   MonthlyDay recurences */
+	Event dummy_event = *it;
+	int duration = (*it).start().date().daysTo( (*it).end().date() );
+	QDate itDate = from.addDays(-duration);
+
+	Event::RepeatPattern r = dummy_event.repeatPattern();
+	if ( !r.hasEndDate || r.endDate() > to ) {
+	    r.setEndDate( to );
+	    r.hasEndDate = TRUE;
+	}
+	dummy_event.setRepeat(TRUE, r);
+
+	while (nextOccurance(dummy_event, itDate, repeat)) {
+	    if(repeat.date() > to)
+		break;
+	    effEv.setDate( repeat.date() );
+	    if ((*it).type() == Event::AllDay) {
+		effEv.setStart( QTime(0,0,0) );
+		effEv.setEnd( QTime(23,59,59) );
+	    } else {
+		/* we only occur by days, not hours/minutes/seconds.  Hence
+		   the actual end and start times will be the same for
+		   every repeated event.  For multi day events this is
+		   fixed up later if on wronge day span */
+		effEv.setStart( (*it).start().time() );
+		effEv.setEnd( (*it).end().time() );
+	    }
+	    if ( duration != 0 ) {
+		// multi-day repeating events
+		QDate sub_it = QMAX( repeat.date(), from );
+		QDate startDate = repeat.date();
+		QDate endDate = startDate.addDays( duration );
+
+		while ( sub_it <= endDate && sub_it  <= to ) {
+		    EffectiveEvent tmpEffEv = effEv;
+		    Event tmpEv = *it;
+		    tmpEffEv.setEvent( tmpEv );
+
+		    if ( sub_it != startDate )
+			tmpEffEv.setStart( QTime(0,0,0) );
+		    if ( sub_it != endDate )
+			tmpEffEv.setEnd( QTime(23,59,59) );
+		    tmpEffEv.setDate( sub_it );
+		    tmpEffEv.setEffectiveDates( startDate, endDate );
+		    tmpList.append( tmpEffEv );
+		    sub_it = sub_it.addDays( 1 );
+		}
+		itDate = endDate;
+	    } else {
+		Event tmpEv = *it;
+		effEv.setEvent( tmpEv );
+		tmpList.append( effEv );
+		itDate = repeat.date().addDays( 1 );
+	    }
+	}
+    }
+
+    qHeapSort( tmpList );
+    return tmpList;
+}
+
+QValueList<EffectiveEvent> DateBookDB::getEffectiveEvents( const QDateTime &dt)
+{
+    QValueList<EffectiveEvent> day = getEffectiveEvents(dt.date(), dt.date());
+    QValueListConstIterator<EffectiveEvent> it;
+    QValueList<EffectiveEvent> tmpList;
+    QDateTime dtTmp;
+
+    for (it = day.begin(); it != day.end(); ++it ) {
+        dtTmp = QDateTime( (*it).date(), (*it).start() );
+	// at the moment we don't have second granularity, be nice about that..
+        if ( QABS(dt.secsTo(dtTmp)) < 60 )
+            tmpList.append( *it );
+    }
+    return tmpList;
+}
+
+
+void DateBookDB::addEvent( const Event &ev, bool doalarm )
+{
+    // write to the journal...
+    saveJournalEntry( ev, ACTION_ADD, -1, false );
+    addJFEvent( ev, doalarm );
+    d->clean = false;
+}
+
+void DateBookDB::addJFEvent( const Event &ev, bool doalarm )
+{
+    if ( doalarm && ev.hasAlarm() )
+	addEventAlarm( ev );
+    if ( ev.hasRepeat() )
+	repeatEvents.append( ev );
+    else
+	eventList.append( ev );
+}
+
+void DateBookDB::editEvent( const Event &old, Event &editedEv )
+{
+    int oldIndex=0;
+    bool oldHadRepeat = old.hasRepeat();
+    Event orig;
+
+    // write to the journal...
+    if ( oldHadRepeat ) {
+	if ( origRepeat( old, orig ) ) // should work always...
+	    oldIndex = repeatEvents.findIndex( orig );
+    } else
+	oldIndex = eventList.findIndex( old );
+    saveJournalEntry( editedEv, ACTION_REPLACE, oldIndex, oldHadRepeat );
+
+    if ( old.hasAlarm() )
+	delEventAlarm( old );
+    if ( oldHadRepeat ) {
+	if ( oldHadRepeat && editedEv.hasRepeat() ) {
+	    // assumption, when someone edits a repeating event, they
+	    // want to change them all, maybe not perfect, but it works
+	    // for the moment...
+	    repeatEvents.remove( orig );
+	} else
+	    removeRepeat( old );
+    } else {
+	QValueList<Event>::Iterator it = eventList.find( old );
+	if ( it != eventList.end() )
+	    eventList.remove( it );
+    }
+    if ( editedEv.hasAlarm() )
+	addEventAlarm( editedEv );
+    if ( editedEv.hasRepeat() )
+	repeatEvents.append( editedEv );
+    else
+	eventList.append( editedEv );
+    d->clean = false;
+}
+
+void DateBookDB::removeEvent( const Event &ev )
+{
+    // write to the journal...
+    saveJournalEntry( ev, ACTION_REMOVE, -1, false );
+    removeJFEvent( ev );
+    d->clean = false;
+}
+
+void DateBookDB::removeJFEvent( const Event&ev )
+{
+    if ( ev.hasAlarm() )
+	delEventAlarm( ev );
+    if ( ev.hasRepeat() ) {
+	removeRepeat( ev );
+    } else {
+	QValueList<Event>::Iterator it = eventList.find( ev );
+	if ( it != eventList.end() )
+	    eventList.remove( it );
+    }
+}
+
+// also handles journaling...
+void DateBookDB::loadFile( const QString &strFile )
+{
+    
+    QFile f( strFile );
+    if ( !f.open( IO_ReadOnly ) )
+	return;
+
+    enum Attribute {
+	FDescription = 0,
+	FLocation,
+	FCategories,
+	FUid,
+	FType,
+	FAlarm,
+	FSound,
+	FRType,
+	FRWeekdays,
+	FRPosition,
+	FRFreq,
+	FRHasEndDate,
+	FREndDate,
+	FRStart,
+	FREnd,
+	FNote,
+	FCreated,
+	FAction,
+	FActionKey,
+	FJournalOrigHadRepeat
+    };
+
+    QAsciiDict<int> dict( 97 );
+    dict.setAutoDelete( TRUE );
+    dict.insert( "description", new int(FDescription) );
+    dict.insert( "location", new int(FLocation) );
+    dict.insert( "categories", new int(FCategories) );
+    dict.insert( "uid", new int(FUid) );
+    dict.insert( "type", new int(FType) );
+    dict.insert( "alarm", new int(FAlarm) );
+    dict.insert( "sound", new int(FSound) );
+    dict.insert( "rtype", new int(FRType) );
+    dict.insert( "rweekdays", new int(FRWeekdays) );
+    dict.insert( "rposition", new int(FRPosition) );
+    dict.insert( "rfreq", new int(FRFreq) );
+    dict.insert( "rhasenddate", new int(FRHasEndDate) );
+    dict.insert( "enddt", new int(FREndDate) );
+    dict.insert( "start", new int(FRStart) );
+    dict.insert( "end", new int(FREnd) );
+    dict.insert( "note", new int(FNote) );
+    dict.insert( "created", new int(FCreated) );
+    dict.insert( "action", new int(FAction) );
+    dict.insert( "actionkey", new int(FActionKey) );
+    dict.insert( "actionorig", new int (FJournalOrigHadRepeat) );
+
+    
+    QByteArray ba = f.readAll();
+    char* dt = ba.data();
+    int len = ba.size();
+    int currentAction,
+	journalKey,
+	origHadRepeat;  // should be bool, but we need tri-state(not being used)
+
+    int i = 0;
+    char *point;
+    while ( ( point = strstr( dt+i, "<event " ) ) != 0 ) {
+	i = point - dt;
+	// if we are reading in events in the general case,
+	// we are just adding them, so let the actions represent that...
+	currentAction = ACTION_ADD;
+	journalKey = -1;
+	origHadRepeat = -1;
+	// some temporary variables for dates and times ...
+	//int startY = 0, startM = 0, startD = 0, starth = 0, startm = 0, starts = 0;
+	//int endY = 0, endM = 0, endD = 0, endh = 0, endm = 0, ends = 0;
+	//int enddtY = 0, enddtM = 0, enddtD = 0;
+
+	// ... for the alarm settings ...
+	int alarmTime = -1; Event::SoundTypeChoice alarmSound = Event::Silent;
+	// ... and for the recurrence
+	Event::RepeatPattern rp;
+	Event e;
+
+	i += 7;
+
+	while( 1 ) {
+	    while ( i < len && (dt[i] == ' ' || dt[i] == '\n' || dt[i] == '\r') )
+		++i;
+	    if ( i >= len-2 || (dt[i] == '/' && dt[i+1] == '>') )
+		break;
+	    // we have another attribute, read it.
+	    int j = i;
+	    while ( j < len && dt[j] != '=' )
+		++j;
+	    char *attr = dt+i;
+	    dt[j] = '\0';
+	    i = ++j; // skip =
+	    while ( i < len && dt[i] != '"' )
+		++i;
+	    j = ++i;
+	    bool haveAmp = FALSE;
+	    bool haveUtf = FALSE;
+	    while ( j < len && dt[j] != '"' ) {
+		if ( dt[j] == '&' )
+		    haveAmp = TRUE;
+		if ( ((unsigned char)dt[j]) > 0x7f )
+		    haveUtf = TRUE;
+		++j;
+	    }
+
+	    if ( i == j ) {
+		// leave out empty attributes
+		i = j + 1;
+		continue;
+	    }
+
+	    QString value = haveUtf ? QString::fromUtf8( dt+i, j-i )
+			    : QString::fromLatin1( dt+i, j-i );
+	    if ( haveAmp )
+		value = Qtopia::plainString( value );
+	    i = j + 1;
+
+	    //qDebug("attr='%s' value='%s'", attr.data(), value.latin1() );
+	    int * find = dict[ attr ];
+#if 1
+	    if ( !find ) {
+		// custom field
+		e.setCustomField(attr, value);
+		continue;
+	    }
+
+	    switch( *find ) {
+	    case FDescription:
+		e.setDescription( value );
+		break;
+	    case FLocation:
+		e.setLocation( value );
+		break;
+	    case FCategories:
+		e.setCategories( Qtopia::Record::idsFromString( value ) );
+		break;
+	    case FUid:
+		e.setUid( value.toInt() );
+		break;
+	    case FType:
+		if ( value == "AllDay" )
+		    e.setType( Event::AllDay );
+		else
+		    e.setType( Event::Normal );
+		break;
+	    case FAlarm:
+		alarmTime = value.toInt();
+		break;
+	    case FSound:
+		alarmSound = value == "loud" ? Event::Loud : Event::Silent;
+		break;
+		// recurrence stuff
+	    case FRType:
+		if ( value == "Daily" )
+		    rp.type = Event::Daily;
+		else if ( value == "Weekly" )
+		    rp.type = Event::Weekly;
+		else if ( value == "MonthlyDay" )
+		    rp.type = Event::MonthlyDay;
+		else if ( value == "MonthlyDate" )
+		    rp.type = Event::MonthlyDate;
+		else if ( value == "Yearly" )
+		    rp.type = Event::Yearly;
+		else
+		    rp.type = Event::NoRepeat;
+		break;
+	    case FRWeekdays:
+		rp.days = value.toInt();
+		break;
+	    case FRPosition:
+		rp.position = value.toInt();
+		break;
+	    case FRFreq:
+		rp.frequency = value.toInt();
+		break;
+	    case FRHasEndDate:
+		rp.hasEndDate = value.toInt();
+		break;
+		case FREndDate: {
+		rp.endDateUTC = (time_t) value.toLong();
+		break;
+		}
+		case FRStart: {
+		e.setStart( (time_t) value.toLong() );
+		break;
+		}
+		case FREnd: {
+		e.setEnd( (time_t) value.toLong() );
+		break;
+		}
+	    case FNote:
+		e.setNotes( value );
+		break;
+	    case FCreated:
+		rp.createTime = value.toInt();
+		break;
+	    case FAction:
+		currentAction = value.toInt();
+		break;
+	    case FActionKey:
+		journalKey = value.toInt();
+		break;
+	    case FJournalOrigHadRepeat:
+		origHadRepeat = value.toInt();
+		break;
+	    default:
+		qDebug( "huh??? missing enum? -- attr.: %s", attr );
+		break;
+	    }
+#endif
+	}
+	// "post processing" (dates, times, alarm, recurrence)
+	// start date/time
+	e.setRepeat( rp.type != Event::NoRepeat, rp );
+
+	if ( alarmTime != -1 )
+	    e.setAlarm( TRUE, alarmTime, alarmSound );
+
+	// now do our action based on the current action...
+	switch ( currentAction ) {
+	case ACTION_ADD:
+	    addJFEvent( e );
+	    break;
+	case ACTION_REMOVE:
+	    removeJFEvent( e );
+	    break;
+	case ACTION_REPLACE:
+	    // be a little bit careful,
+	    // in case of a messed up journal...
+	    if ( journalKey > -1 && origHadRepeat > -1 ) {
+		// get the original from proper list...
+		if ( origHadRepeat )
+		    removeJFEvent( *(repeatEvents.at(journalKey)) );
+		else
+		    removeJFEvent( *(eventList.at(journalKey)) );
+		addJFEvent( e );
+	    }
+	    break;
+	default:
+	    break;
+	}
+    }
+    f.close();
+}
+
+void DateBookDB::init()
+{
+    d = new DateBookDBPrivate;
+    d->clean = false;
+    QString str = dateBookFilename();
+    if ( str.isNull() ) {
+	QMessageBox::warning( 0, QObject::tr("Out of Space"),
+			      QObject::tr("Unable to create start up files\n"
+					  "Please free up some space\n"
+					  "before entering data") );
+    }
+    // continuing along, we call this datebook filename again,
+    // because they may fix it before continuing, though it seems
+    // pretty unlikely...
+    loadFile( dateBookFilename() );
+
+    if ( QFile::exists( dateBookJournalFile() ) ) {
+	// merge the journal
+	loadFile( dateBookJournalFile() );
+	// save in our changes and remove the journal...
+	save();
+    }
+    d->clean = true;
+}
+
+bool DateBookDB::save()
+{
+    if ( d->clean == true )
+	return true;
+    QValueListIterator<Event> it;
+    int total_written;
+    QString strFileNew = dateBookFilename() + ".new";
+
+    QFile f( strFileNew );
+    if ( !f.open( IO_WriteOnly|IO_Raw ) )
+        return FALSE;
+
+    QString buf( "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" );
+    buf += "<!DOCTYPE DATEBOOK><DATEBOOK>\n";
+    buf += "<events>\n";
+    QCString str = buf.utf8();
+    total_written = f.writeBlock( str.data(), str.length() );
+    if ( total_written != int(str.length()) ) {
+	f.close();
+	QFile::remove( strFileNew );
+	return false;
+    }
+
+    for ( it = eventList.begin(); it != eventList.end(); ++it ) {
+	buf = "<event";
+        (*it).save( buf );
+        buf += " />\n";
+	str = buf.utf8();
+        total_written = f.writeBlock( str.data(), str.length() );
+	if ( total_written != int(str.length()) ) {
+	    f.close();
+	    QFile::remove( strFileNew );
+	    return false;
+	}
+    }
+    for ( it = repeatEvents.begin(); it != repeatEvents.end(); ++it ) {
+        buf = "<event";
+        (*it).save( buf );
+        buf += " />\n";
+	str = buf.utf8();
+	total_written = f.writeBlock( str.data(), str.length() );
+	if ( total_written != int(str.length()) ) {
+	    f.close();
+	    QFile::remove( strFileNew );
+	    return false;
+	}
+    }
+    buf = "</events>\n</DATEBOOK>\n";
+    str = buf.utf8();
+    total_written = f.writeBlock( str.data(), str.length() );
+    if ( total_written != int(str.length()) ) {
+	f.close();
+	QFile::remove( strFileNew );
+	return false;
+    }
+    f.close();
+
+    // now rename... I like to use the systemcall
+    if ( ::rename( strFileNew, dateBookFilename() ) < 0 ) {
+	qWarning( "problem renaming file %s to %s errno %d",
+		  strFileNew.latin1(), dateBookFilename().latin1(), errno  );
+	// remove the file, otherwise it will just stick around...
+	QFile::remove( strFileNew );
+    }
+
+    // may as well remove the journal file...
+    QFile::remove( dateBookJournalFile() );
+    d->clean = true;
+    return true;
+}
+
+void DateBookDB::reload()
+{
+    QValueList<Event>::Iterator it = eventList.begin();
+    for ( ; it != eventList.end(); ++it ) {
+	if ( (*it).hasAlarm() )
+	    delEventAlarm( *it );
+	if ( (*it).hasRepeat() )
+	    removeRepeat( *it );
+    }
+    eventList.clear();
+    repeatEvents.clear(); // should be a NOP
+    init();
+}
+
+bool DateBookDB::removeRepeat( const Event &ev )
+{
+    time_t removeMe = ev.repeatPattern().createTime;
+    QValueListIterator<Event> it;
+    for ( it = repeatEvents.begin(); it != repeatEvents.end(); ++it ) {
+	if ( removeMe == (*it).repeatPattern().createTime ) {
+	    repeatEvents.remove( *it );
+	    // best break, or we are going into undefined territory!
+	    return TRUE;
+	}
+    }
+    return FALSE;
+}
+
+bool DateBookDB::origRepeat( const Event &ev, Event &orig ) const
+{
+    time_t removeMe = ev.repeatPattern().createTime;
+    QValueListConstIterator<Event> it;
+    for ( it = repeatEvents.begin(); it != repeatEvents.end(); ++it ) {
+	if ( removeMe == (*it).repeatPattern().createTime ) {
+	    orig = (*it);
+	    return TRUE;
+	}
+    }
+    return FALSE;
+}
+
+void DateBookDB::saveJournalEntry( const Event &ev, journal_action action )
+{
+    saveJournalEntry( ev, action, -1, false );
+}
+
+bool DateBookDB::saveJournalEntry( const Event &evOld, journal_action action,
+				   int key, bool origHadRepeat )
+{
+    bool status = false;
+    Event ev = evOld;
+    // write our log based on the action
+    QFile f( dateBookJournalFile() );
+    if ( !f.open( IO_WriteOnly|IO_Append ) )
+        return false;
+    QString buf = "<event";
+    ev.save( buf );
+    buf += " action=";
+    buf += "\"" + QString::number(action) + "\"";
+    buf += " actionkey=\"" + QString::number(key) + "\"";
+    buf += " actionorig=\"" + QString::number(origHadRepeat) +"\"";
+    buf += " />\n";
+    QString str = buf.utf8();
+    status = ( f.writeBlock( str.data(), str.length() ) == int(str.length()) );
+    f.close();
+    return status;
+}
+
+QValueList<Event> DateBookDB::getRawRepeats() const
+{
+    return repeatEvents;
+}
+
+QValueList<Event> DateBookDB::getNonRepeatingEvents( const QDate &from,
+						     const QDate &to ) const
+{
+    QValueListConstIterator<Event> it;
+    QDateTime dtTmp, dtEnd;
+    QValueList<Event> tmpList;
+    for (it = eventList.begin(); it != eventList.end(); ++it ) {
+        dtTmp = (*it).start(TRUE);
+	dtEnd = (*it).end(TRUE);
+
+        if ( dtTmp.date() >= from && dtTmp.date() <= to ) {
+	    Event e = *it;
+	    if ( dtTmp.date() != dtEnd.date() )
+		e.setEnd( QDateTime(dtTmp.date(), QTime(23, 59, 0)) );
+            tmpList.append( e );
+	}
+	// we must also check for end date information...
+	if ( dtEnd.date() != dtTmp.date() && dtEnd.date() >= from ) {
+	    QDateTime dt = dtTmp.addDays( 1 );
+	    dt.setTime( QTime(0, 0, 0) );
+	    QDateTime dtStop;
+	    if ( dtEnd > to ) {
+		dtStop = to;
+	    } else
+		dtStop = dtEnd;
+	    while ( dt <= dtStop ) {
+		Event ev = *it;
+		if ( dt >= from ) {
+		    ev.setStart( QDateTime(dt.date(), QTime(0, 0, 0)) );
+		    if ( dt.date() == dtEnd.date() )
+			ev.setEnd( QDateTime(dt.date(), dtEnd.time()) );
+		    else
+			ev.setEnd( QDateTime(dt.date(), QTime(23, 59, 0)) );
+		    tmpList.append( ev );
+		}
+		dt = dt.addDays( 1 );
+	    }
+	}
+    }
+    return tmpList;
+}