Added getEvent(uid) and a fix reassigning uids to events whos uids have been cleared

2 files changed, 27 insertions, 1 deletions

diff --git a/library/datebookdb.cpp b/library/datebookdb.cpp
index bf7fd94..da5a797 100644
--- a/library/datebookdb.cpp
+++ b/library/datebookdb.cpp
@@ -336,431 +336,454 @@ bool nextOccurance(const Event &e, const QDate &from, QDateTime &next)
     }
 }
 
 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 ) {
+	if (!(*it).isValidUid()) 
+	    (*it).assignUid(); // FIXME: Hack to restore cleared uids
+
         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 ) {
+	if (!(*it).isValidUid()) 
+	    (*it).assignUid(); // FIXME: Hack to restore cleared uids
 
 	/* 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;
 }
 
+Event DateBookDB::getEvent( int uid ) {
+    QValueList<Event>::ConstIterator it;
+    
+    for (it = eventList.begin(); it != eventList.end(); it++) {
+	if ((*it).uid() == uid) return *it;
+    }
+    for (it = repeatEvents.begin(); it != repeatEvents.end(); it++) {
+	if ((*it).uid() == uid) return *it;
+    }
+
+    qDebug("Event not found: uid=%d\n", uid);
+}
+
 
 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 );
 
+    // Delete old event
     if ( old.hasAlarm() )
 	delEventAlarm( old );
     if ( oldHadRepeat ) {
-	if ( oldHadRepeat && editedEv.hasRepeat() ) {
+	if ( editedEv.hasRepeat() ) { // This mean that origRepeat was run above and 
+ 	                              // orig is initialized
 	    // 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 );
     }
+
+    // Add new event
     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;
diff --git a/library/datebookdb.h b/library/datebookdb.h
index aadb397..e4c251c 100644
--- a/library/datebookdb.h
+++ b/library/datebookdb.h
@@ -1,85 +1,88 @@
 /**********************************************************************
 ** 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.
 **
 **********************************************************************/
 
 #ifndef DATEBOOKDB_H
 #define DATEBOOKDB_H
 
 #include <qdatetime.h>
 #include <qfile.h>
 #include <qvaluelist.h>
 #include <qpe/event.h>
 
 // journal actions...
 enum journal_action { ACTION_ADD, ACTION_REMOVE, ACTION_REPLACE };
 
 class DateBookDBPrivate;
 class DateBookDB
 {
 public:
     DateBookDB();
     ~DateBookDB();
 
     // very depreciated now!!!
     QValueList<Event> getEvents( const QDate &from, const QDate &to );
     QValueList<Event> getEvents( const QDateTime &start );
 
     // USE THESE!!!
     QValueList<EffectiveEvent> getEffectiveEvents( const QDate &from,
 						   const QDate &to );
     QValueList<EffectiveEvent> getEffectiveEvents( const QDateTime &start );
+    Event getEvent( int uid );
 
     QValueList<Event> getRawRepeats() const;
     QValueList<Event> getNonRepeatingEvents( const QDate &from,
 					     const QDate &to ) const;
 
     // Use these when dealing with adding removing events...
     void addEvent( const Event &ev, bool doalarm=TRUE );
     void removeEvent( const Event &ev );
     void editEvent( const Event &old, Event &ev );
     // add/remove event without journaling ( these ended up in public by accident, never
     // use them unless you know what you are doing...),
     // please put them in private if we ever can change the class...
     void addJFEvent( const Event &ev, bool doalarm=TRUE );
     void removeJFEvent( const Event &ev );
 
     bool save();
     void reload();
 private:
     //find the real repeat...
     bool origRepeat( const Event &ev, Event &orig ) const;
     bool removeRepeat( const Event &ev );
     void init();
     void loadFile( const QString &strFile );
     // depreciated...
     void saveJournalEntry( const Event &ev, journal_action action );
     // new version, uncomment the "= -1" when we remove the above
     // function..
     bool saveJournalEntry( const Event &ev, journal_action action,
 			   int key/* = -1*/, bool origHadRepeat = false );
 
     QValueList<Event> eventList; // non-repeating events...
     QValueList<Event> repeatEvents; // the repeating events...
     DateBookDBPrivate *d;
     QFile journalFile;
+
+    int	recordIdMax;  // ADDITION
 };
 
 /* helper functions, also useful to other apps. */
 bool nextOccurance( const Event &e, const QDate &from, QDateTime &next);
 #endif