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;
+}