| -rw-r--r-- | libkcal/calendarlocal.cpp | 655 |
1 files changed, 655 insertions, 0 deletions
diff --git a/libkcal/calendarlocal.cpp b/libkcal/calendarlocal.cpp new file mode 100644 index 0000000..8ff8b14 --- a/dev/null +++ b/libkcal/calendarlocal.cpp @@ -0,0 +1,655 @@ +/* + This file is part of libkcal. + + Copyright (c) 1998 Preston Brown + Copyright (c) 2001,2003 Cornelius Schumacher <schumacher@kde.org> + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. +*/ + +#include <qdatetime.h> +#include <qstring.h> +#include <qptrlist.h> + +#include <kdebug.h> +#include <kconfig.h> +#include <kglobal.h> +#include <klocale.h> + +#include "vcaldrag.h" +#include "vcalformat.h" +#include "icalformat.h" +#include "exceptions.h" +#include "incidence.h" +#include "journal.h" +#include "filestorage.h" +#include "calfilter.h" + +#include "calendarlocal.h" + +// #ifndef DESKTOP_VERSION +// #include <qtopia/alarmserver.h> +// #endif +using namespace KCal; + +CalendarLocal::CalendarLocal() + : Calendar() +{ + init(); +} + +CalendarLocal::CalendarLocal(const QString &timeZoneId) + : Calendar(timeZoneId) +{ + init(); +} + +void CalendarLocal::init() +{ + mNextAlarmIncidence = 0; +} + + +CalendarLocal::~CalendarLocal() +{ + close(); +} + +bool CalendarLocal::load( const QString &fileName ) +{ + FileStorage storage( this, fileName ); + return storage.load(); +} + +bool CalendarLocal::save( const QString &fileName, CalFormat *format ) +{ + FileStorage storage( this, fileName, format ); + return storage.save(); +} + +void CalendarLocal::close() +{ + mEventList.setAutoDelete( true ); + mTodoList.setAutoDelete( true ); + mJournalList.setAutoDelete( false ); + + mEventList.clear(); + mTodoList.clear(); + mJournalList.clear(); + + mEventList.setAutoDelete( false ); + mTodoList.setAutoDelete( false ); + mJournalList.setAutoDelete( false ); + + setModified( false ); +} +bool CalendarLocal::addEventNoDup( Event *event ) +{ + Event * eve; + for ( eve = mEventList.first(); eve ; eve = mEventList.next() ) { + if ( *eve == *event ) { + //qDebug("CalendarLocal::Duplicate event found! Not inserted! "); + return false; + } + } + return addEvent( event ); +} + +bool CalendarLocal::addEvent( Event *event ) +{ + insertEvent( event ); + + event->registerObserver( this ); + + setModified( true ); + + return true; +} + +void CalendarLocal::deleteEvent( Event *event ) +{ + + + if ( mEventList.removeRef( event ) ) { + setModified( true ); + } +} + + +Event *CalendarLocal::event( const QString &uid ) +{ + + Event *event; + + for ( event = mEventList.first(); event; event = mEventList.next() ) { + if ( event->uid() == uid ) { + return event; + } + } + + return 0; +} +bool CalendarLocal::addTodoNoDup( Todo *todo ) +{ + Todo * eve; + for ( eve = mTodoList.first(); eve ; eve = mTodoList.next() ) { + if ( *eve == *todo ) { + //qDebug("duplicate todo found! not inserted! "); + return false; + } + } + return addTodo( todo ); +} +bool CalendarLocal::addTodo( Todo *todo ) +{ + mTodoList.append( todo ); + + todo->registerObserver( this ); + + // Set up subtask relations + setupRelations( todo ); + + setModified( true ); + + return true; +} + +void CalendarLocal::deleteTodo( Todo *todo ) +{ + // Handle orphaned children + removeRelations( todo ); + + if ( mTodoList.removeRef( todo ) ) { + setModified( true ); + } +} + +QPtrList<Todo> CalendarLocal::rawTodos() +{ + return mTodoList; +} +Todo *CalendarLocal::todo( int id ) +{ + Todo *todo; + for ( todo = mTodoList.first(); todo; todo = mTodoList.next() ) { + if ( todo->zaurusId() == id ) return todo; + } + + return 0; +} + +Event *CalendarLocal::event( int id ) +{ + Event *todo; + for ( todo = mEventList.first(); todo; todo = mEventList.next() ) { + if ( todo->zaurusId() == id ) return todo; + } + + return 0; +} +Todo *CalendarLocal::todo( const QString &uid ) +{ + Todo *todo; + for ( todo = mTodoList.first(); todo; todo = mTodoList.next() ) { + if ( todo->uid() == uid ) return todo; + } + + return 0; +} +QString CalendarLocal::nextSummary() const +{ + return mNextSummary; +} +QDateTime CalendarLocal::nextAlarmEventDateTime() const +{ + return mNextAlarmEventDateTime; +} +void CalendarLocal::checkAlarmForIncidence( Incidence * incidence, bool deleted) +{ + //mNextAlarmIncidence + //mNextAlarmDateTime + //return mNextSummary; + //return mNextAlarmEventDateTime; + bool newNextAlarm = false; + bool computeNextAlarm = false; + bool ok; + int offset; + QDateTime nextA; + // QString nextSum; + //QDateTime nextEvent; + if ( mNextAlarmIncidence == 0 || incidence == 0 ) { + computeNextAlarm = true; + } else { + if ( ! deleted ) { + nextA = incidence->getNextAlarmDateTime(& ok, &offset ) ; + if ( ok ) { + if ( nextA < mNextAlarmDateTime ) { + deRegisterAlarm(); + mNextAlarmDateTime = nextA; + mNextSummary = incidence->summary(); + mNextAlarmEventDateTime = nextA.addSecs(offset ) ; + mNextAlarmEventDateTimeString = KGlobal::locale()->formatDateTime(mNextAlarmEventDateTime); + newNextAlarm = true; + mNextAlarmIncidence = incidence; + } else { + if ( incidence == mNextAlarmIncidence ) { + computeNextAlarm = true; + } + } + } else { + if ( mNextAlarmIncidence == incidence ) { + computeNextAlarm = true; + } + } + } else { // deleted + if ( incidence == mNextAlarmIncidence ) { + computeNextAlarm = true; + } + } + } + if ( computeNextAlarm ) { + deRegisterAlarm(); + nextA = nextAlarm( 1000 ); + if (! mNextAlarmIncidence ) { + return; + } + newNextAlarm = true; + } + if ( newNextAlarm ) + registerAlarm(); +} +QString CalendarLocal:: getAlarmNotification() +{ + QString ret; + // this should not happen + if (! mNextAlarmIncidence ) + return "cal_alarm"+ mNextSummary.left( 25 )+"\n"+mNextAlarmEventDateTimeString; + Alarm* alarm = mNextAlarmIncidence->alarms().first(); + if ( alarm->type() == Alarm::Procedure ) { + ret = "proc_alarm" + alarm->programFile()+"+++"; + } else { + ret = "audio_alarm" +alarm->audioFile() +"+++"; + } + ret += "cal_alarm"+ mNextSummary.left( 25 ); + if ( mNextSummary.length() > 25 ) + ret += "\n" + mNextSummary.mid(25, 25 ); + ret+= "\n"+mNextAlarmEventDateTimeString; + return ret; +} + +void CalendarLocal::registerAlarm() +{ + mLastAlarmNotificationString = getAlarmNotification(); + // qDebug("++ register Alarm %s %s",mNextAlarmDateTime.toString().latin1(), mLastAlarmNotificationString.latin1() ); + emit addAlarm ( mNextAlarmDateTime, mLastAlarmNotificationString ); +// #ifndef DESKTOP_VERSION +// AlarmServer::addAlarm ( mNextAlarmDateTime,"koalarm", mLastAlarmNotificationString.latin1() ); +// #endif +} +void CalendarLocal::deRegisterAlarm() +{ + if ( mLastAlarmNotificationString.isNull() ) + return; + //qDebug("-- deregister Alarm %s ", mLastAlarmNotificationString.latin1() ); + + emit removeAlarm ( mNextAlarmDateTime, mLastAlarmNotificationString ); +// #ifndef DESKTOP_VERSION +// AlarmServer::deleteAlarm (mNextAlarmDateTime ,"koalarm" ,mLastAlarmNotificationString.latin1() ); +// #endif +} + +QPtrList<Todo> CalendarLocal::todos( const QDate &date ) +{ + QPtrList<Todo> todos; + + Todo *todo; + for ( todo = mTodoList.first(); todo; todo = mTodoList.next() ) { + if ( todo->hasDueDate() && todo->dtDue().date() == date ) { + todos.append( todo ); + } + } + + filter()->apply( &todos ); + return todos; +} +void CalendarLocal::reInitAlarmSettings() +{ + if ( !mNextAlarmIncidence ) { + nextAlarm( 1000 ); + } + deRegisterAlarm(); + mNextAlarmIncidence = 0; + checkAlarmForIncidence( 0, false ); + +} + + + +QDateTime CalendarLocal::nextAlarm( int daysTo ) +{ + QDateTime nextA = QDateTime::currentDateTime().addDays( daysTo ); + QDateTime start = QDateTime::currentDateTime().addSecs( 30 ); + QDateTime next; + Event *e; + bool ok; + bool found = false; + int offset; + mNextAlarmIncidence = 0; + for( e = mEventList.first(); e; e = mEventList.next() ) { + next = e->getNextAlarmDateTime(& ok, &offset ) ; + if ( ok ) { + if ( next < nextA ) { + nextA = next; + found = true; + mNextSummary = e->summary(); + mNextAlarmEventDateTime = next.addSecs(offset ) ; + mNextAlarmIncidence = (Incidence *) e; + } + } + } + Todo *t; + for( t = mTodoList.first(); t; t = mTodoList.next() ) { + next = t->getNextAlarmDateTime(& ok, &offset ) ; + if ( ok ) { + if ( next < nextA ) { + nextA = next; + found = true; + mNextSummary = t->summary(); + mNextAlarmEventDateTime = next.addSecs(offset ); + mNextAlarmIncidence = (Incidence *) t; + } + } + } + if ( mNextAlarmIncidence ) { + mNextAlarmEventDateTimeString = KGlobal::locale()->formatDateTime(mNextAlarmEventDateTime); + mNextAlarmDateTime = nextA; + } + return nextA; +} +Alarm::List CalendarLocal::alarmsTo( const QDateTime &to ) +{ + return alarms( QDateTime( QDate( 1900, 1, 1 ) ), to ); +} + +Alarm::List CalendarLocal::alarms( const QDateTime &from, const QDateTime &to ) +{ + kdDebug(5800) << "CalendarLocal::alarms(" << from.toString() << " - " + << to.toString() << ")\n"; + + Alarm::List alarms; + + Event *e; + + for( e = mEventList.first(); e; e = mEventList.next() ) { + if ( e->doesRecur() ) appendRecurringAlarms( alarms, e, from, to ); + else appendAlarms( alarms, e, from, to ); + } + + Todo *t; + for( t = mTodoList.first(); t; t = mTodoList.next() ) { + appendAlarms( alarms, t, from, to ); + } + + return alarms; +} + +void CalendarLocal::appendAlarms( Alarm::List &alarms, Incidence *incidence, + const QDateTime &from, const QDateTime &to ) +{ + QPtrList<Alarm> alarmList = incidence->alarms(); + Alarm *alarm; + for( alarm = alarmList.first(); alarm; alarm = alarmList.next() ) { +// kdDebug(5800) << "CalendarLocal::appendAlarms() '" << alarm->text() +// << "': " << alarm->time().toString() << " - " << alarm->enabled() << endl; + if ( alarm->enabled() ) { + if ( alarm->time() >= from && alarm->time() <= to ) { + kdDebug(5800) << "CalendarLocal::appendAlarms() '" << incidence->summary() + << "': " << alarm->time().toString() << endl; + alarms.append( alarm ); + } + } + } +} + +void CalendarLocal::appendRecurringAlarms( Alarm::List &alarms, + Incidence *incidence, + const QDateTime &from, + const QDateTime &to ) +{ + + QPtrList<Alarm> alarmList = incidence->alarms(); + Alarm *alarm; + QDateTime qdt; + for( alarm = alarmList.first(); alarm; alarm = alarmList.next() ) { + if (incidence->recursOn(from.date())) { + qdt.setTime(alarm->time().time()); + qdt.setDate(from.date()); + } + else qdt = alarm->time(); + // qDebug("1 %s %s %s", qdt.toString().latin1(), from.toString().latin1(), to.toString().latin1()); + if ( alarm->enabled() ) { + if ( qdt >= from && qdt <= to ) { + alarms.append( alarm ); + } + } + } +} + + +/****************************** PROTECTED METHODS ****************************/ + +// after changes are made to an event, this should be called. +void CalendarLocal::update( IncidenceBase *incidence ) +{ + incidence->setSyncStatus( Event::SYNCMOD ); + incidence->setLastModified( QDateTime::currentDateTime() ); + // we should probably update the revision number here, + // or internally in the Event itself when certain things change. + // need to verify with ical documentation. + + setModified( true ); +} + +void CalendarLocal::insertEvent( Event *event ) +{ + if ( mEventList.findRef( event ) < 0 ) mEventList.append( event ); +} + + +QPtrList<Event> CalendarLocal::rawEventsForDate( const QDate &qd, bool sorted ) +{ + QPtrList<Event> eventList; + + Event *event; + for( event = mEventList.first(); event; event = mEventList.next() ) { + if ( event->doesRecur() ) { + if ( event->isMultiDay() ) { + int extraDays = event->dtStart().date().daysTo( event->dtEnd().date() ); + int i; + for ( i = 0; i <= extraDays; i++ ) { + if ( event->recursOn( qd.addDays( -i ) ) ) { + eventList.append( event ); + break; + } + } + } else { + if ( event->recursOn( qd ) ) + eventList.append( event ); + } + } else { + if ( event->dtStart().date() <= qd && event->dtEnd().date() >= qd ) { + eventList.append( event ); + } + } + } + + if ( !sorted ) { + return eventList; + } + + // kdDebug(5800) << "Sorting events for date\n" << endl; + // now, we have to sort it based on dtStart.time() + QPtrList<Event> eventListSorted; + Event *sortEvent; + for ( event = eventList.first(); event; event = eventList.next() ) { + sortEvent = eventListSorted.first(); + int i = 0; + while ( sortEvent && event->dtStart().time()>=sortEvent->dtStart().time() ) + { + i++; + sortEvent = eventListSorted.next(); + } + eventListSorted.insert( i, event ); + } + return eventListSorted; +} + + +QPtrList<Event> CalendarLocal::rawEvents( const QDate &start, const QDate &end, + bool inclusive ) +{ + Event *event = 0; + + QPtrList<Event> eventList; + + // Get non-recurring events + for( event = mEventList.first(); event; event = mEventList.next() ) { + if ( event->doesRecur() ) { + QDate rStart = event->dtStart().date(); + bool found = false; + if ( inclusive ) { + if ( rStart >= start && rStart <= end ) { + // Start date of event is in range. Now check for end date. + // if duration is negative, event recurs forever, so do not include it. + if ( event->recurrence()->duration() == 0 ) { // End date set + QDate rEnd = event->recurrence()->endDate(); + if ( rEnd >= start && rEnd <= end ) { // End date within range + found = true; + } + } else if ( event->recurrence()->duration() > 0 ) { // Duration set + // TODO: Calculate end date from duration. Should be done in Event + // For now exclude all events with a duration. + } + } + } else { + bool founOne; + QDate next = event->getNextOccurence( start, &founOne ).date(); + if ( founOne ) { + if ( next <= end ) { + found = true; + } + } + + /* + // crap !!! + if ( rStart <= end ) { // Start date not after range + if ( rStart >= start ) { // Start date within range + found = true; + } else if ( event->recurrence()->duration() == -1 ) { // Recurs forever + found = true; + } else if ( event->recurrence()->duration() == 0 ) { // End date set + QDate rEnd = event->recurrence()->endDate(); + if ( rEnd >= start && rEnd <= end ) { // End date within range + found = true; + } + } else { // Duration set + // TODO: Calculate end date from duration. Should be done in Event + // For now include all events with a duration. + found = true; + } + } + */ + + } + + if ( found ) eventList.append( event ); + } else { + QDate s = event->dtStart().date(); + QDate e = event->dtEnd().date(); + + if ( inclusive ) { + if ( s >= start && e <= end ) { + eventList.append( event ); + } + } else { + if ( ( s >= start && s <= end ) || ( e >= start && e <= end ) ) { + eventList.append( event ); + } + } + } + } + + return eventList; +} + +QPtrList<Event> CalendarLocal::rawEventsForDate( const QDateTime &qdt ) +{ + return rawEventsForDate( qdt.date() ); +} + +QPtrList<Event> CalendarLocal::rawEvents() +{ + return mEventList; +} + +bool CalendarLocal::addJournal(Journal *journal) +{ + if ( journal->dtStart().isValid()) + kdDebug(5800) << "Adding Journal on " << journal->dtStart().toString() << endl; + else + kdDebug(5800) << "Adding Journal without a DTSTART" << endl; + + mJournalList.append(journal); + + journal->registerObserver( this ); + + setModified( true ); + + return true; +} + +void CalendarLocal::deleteJournal( Journal *journal ) +{ + if ( mJournalList.removeRef(journal) ) { + setModified( true ); + } +} + +Journal *CalendarLocal::journal( const QDate &date ) +{ +// kdDebug(5800) << "CalendarLocal::journal() " << date.toString() << endl; + + for ( Journal *it = mJournalList.first(); it; it = mJournalList.next() ) + if ( it->dtStart().date() == date ) + return it; + + return 0; +} + +Journal *CalendarLocal::journal( const QString &uid ) +{ + for ( Journal *it = mJournalList.first(); it; it = mJournalList.next() ) + if ( it->uid() == uid ) + return it; + + return 0; +} + +QPtrList<Journal> CalendarLocal::journals() +{ + return mJournalList; +} + |