| -rw-r--r-- | libkcal/calendar.cpp | 426 |
1 files changed, 426 insertions, 0 deletions
diff --git a/libkcal/calendar.cpp b/libkcal/calendar.cpp new file mode 100644 index 0000000..dc198bd --- a/dev/null +++ b/libkcal/calendar.cpp @@ -0,0 +1,426 @@ +/* + This file is part of libkcal. + Copyright (c) 1998 Preston Brown + Copyright (c) 2000,2001 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 <stdlib.h> +#include <time.h> + +#include <kdebug.h> +#include <kglobal.h> +#include <klocale.h> + +#include "exceptions.h" +#include "calfilter.h" + +#include "calendar.h" + +using namespace KCal; + +Calendar::Calendar() +{ + + init(); + setTimeZoneId( i18n (" 00:00 Europe/London(UTC)") ); +} + +Calendar::Calendar( const QString &timeZoneId ) +{ + + init(); + setTimeZoneId(timeZoneId); +} + +void Calendar::init() +{ + mObserver = 0; + mNewObserver = false; + + mModified = false; + + // Setup default filter, which does nothing + mDefaultFilter = new CalFilter; + mFilter = mDefaultFilter; + mFilter->setEnabled(false); + + // initialize random numbers. This is a hack, and not + // even that good of one at that. +// srandom(time(0)); + + // user information... + setOwner(i18n("Unknown Name")); + setEmail(i18n("unknown@nowhere")); + +#if 0 + tmpStr = KOPrefs::instance()->mTimeZone; +// kdDebug(5800) << "Calendar::Calendar(): TimeZone: " << tmpStr << endl; + int dstSetting = KOPrefs::instance()->mDaylightSavings; + extern long int timezone; + struct tm *now; + time_t curtime; + curtime = time(0); + now = localtime(&curtime); + int hourOff = - ((timezone / 60) / 60); + if (now->tm_isdst) + hourOff += 1; + QString tzStr; + tzStr.sprintf("%.2d%.2d", + hourOff, + abs((timezone / 60) % 60)); + + // if no time zone was in the config file, write what we just discovered. + if (tmpStr.isEmpty()) { +// KOPrefs::instance()->mTimeZone = tzStr; + } else { + tzStr = tmpStr; + } + + // if daylight savings has changed since last load time, we need + // to rewrite these settings to the config file. + if ((now->tm_isdst && !dstSetting) || + (!now->tm_isdst && dstSetting)) { + KOPrefs::instance()->mTimeZone = tzStr; + KOPrefs::instance()->mDaylightSavings = now->tm_isdst; + } + + setTimeZone(tzStr); +#endif + +// KOPrefs::instance()->writeConfig(); +} + +Calendar::~Calendar() +{ + delete mDefaultFilter; +} + +const QString &Calendar::getOwner() const +{ + return mOwner; +} + +void Calendar::setOwner(const QString &os) +{ + int i; + mOwner = os; + i = mOwner.find(','); + if (i != -1) + mOwner = mOwner.left(i); + + setModified( true ); +} + +void Calendar::setTimeZone(const QString & tz) +{ + bool neg = FALSE; + int hours, minutes; + QString tmpStr(tz); + + if (tmpStr.left(1) == "-") + neg = TRUE; + if (tmpStr.left(1) == "-" || tmpStr.left(1) == "+") + tmpStr.remove(0, 1); + hours = tmpStr.left(2).toInt(); + if (tmpStr.length() > 2) + minutes = tmpStr.right(2).toInt(); + else + minutes = 0; + mTimeZone = (60*hours+minutes); + if (neg) + mTimeZone = -mTimeZone; + mLocalTime = false; + + setModified( true ); +} + +QString Calendar::getTimeZoneStr() const +{ + if (mLocalTime) + return ""; + QString tmpStr; + int hours = abs(mTimeZone / 60); + int minutes = abs(mTimeZone % 60); + bool neg = mTimeZone < 0; + + tmpStr.sprintf("%c%.2d%.2d", + (neg ? '-' : '+'), + hours, minutes); + return tmpStr; +} + +void Calendar::setTimeZone(int tz) +{ + mTimeZone = tz; + mLocalTime = false; + + setModified( true ); +} + +int Calendar::getTimeZone() const +{ + return mTimeZone; +} + +void Calendar::setTimeZoneId(const QString &id) +{ + mTimeZoneId = id; + mLocalTime = false; + mTimeZone = KGlobal::locale()->timezoneOffset(mTimeZoneId); + if ( mTimeZone > 1000) + setLocalTime(); + //qDebug("Calendar::setTimeZoneOffset %s %d ",mTimeZoneId.latin1(), mTimeZone); + setModified( true ); +} + +QString Calendar::timeZoneId() const +{ + return mTimeZoneId; +} + +void Calendar::setLocalTime() +{ + //qDebug("Calendar::setLocalTime() "); + mLocalTime = true; + mTimeZone = 0; + mTimeZoneId = ""; + + setModified( true ); +} + +bool Calendar::isLocalTime() const +{ + return mLocalTime; +} + +const QString &Calendar::getEmail() +{ + return mOwnerEmail; +} + +void Calendar::setEmail(const QString &e) +{ + mOwnerEmail = e; + + setModified( true ); +} + +void Calendar::setFilter(CalFilter *filter) +{ + mFilter = filter; +} + +CalFilter *Calendar::filter() +{ + return mFilter; +} + +QPtrList<Incidence> Calendar::incidences() +{ + QPtrList<Incidence> incidences; + + Incidence *i; + + QPtrList<Event> e = events(); + for( i = e.first(); i; i = e.next() ) incidences.append( i ); + + QPtrList<Todo> t = todos(); + for( i = t.first(); i; i = t.next() ) incidences.append( i ); + + QPtrList<Journal> j = journals(); + for( i = j.first(); i; i = j.next() ) incidences.append( i ); + + return incidences; +} + +QPtrList<Incidence> Calendar::rawIncidences() +{ + QPtrList<Incidence> incidences; + + Incidence *i; + + QPtrList<Event> e = rawEvents(); + for( i = e.first(); i; i = e.next() ) incidences.append( i ); + + QPtrList<Todo> t = rawTodos(); + for( i = t.first(); i; i = t.next() ) incidences.append( i ); + + QPtrList<Journal> j = journals(); + for( i = j.first(); i; i = j.next() ) incidences.append( i ); + + return incidences; +} + +QPtrList<Event> Calendar::events( const QDate &date, bool sorted ) +{ + QPtrList<Event> el = rawEventsForDate(date,sorted); + mFilter->apply(&el); + return el; +} + +QPtrList<Event> Calendar::events( const QDateTime &qdt ) +{ + QPtrList<Event> el = rawEventsForDate(qdt); + mFilter->apply(&el); + return el; +} + +QPtrList<Event> Calendar::events( const QDate &start, const QDate &end, + bool inclusive) +{ + QPtrList<Event> el = rawEvents(start,end,inclusive); + mFilter->apply(&el); + return el; +} + +QPtrList<Event> Calendar::events() +{ + QPtrList<Event> el = rawEvents(); + mFilter->apply(&el); + return el; +} + + +bool Calendar::addIncidence(Incidence *i) +{ + Incidence::AddVisitor<Calendar> v(this); + + return i->accept(v); +} +void Calendar::deleteIncidence(Incidence *in) +{ + if ( in->type() == "Event" ) + deleteEvent( (Event*) in ); + else if ( in->type() =="Todo" ) + deleteTodo( (Todo*) in); + else if ( in->type() =="Journal" ) + deleteJournal( (Journal*) in ); +} + +Incidence* Calendar::incidence( const QString& uid ) +{ + Incidence* i; + + if( (i = todo( uid )) != 0 ) + return i; + if( (i = event( uid )) != 0 ) + return i; + if( (i = journal( uid )) != 0 ) + return i; + + return 0; +} + +QPtrList<Todo> Calendar::todos() +{ + QPtrList<Todo> tl = rawTodos(); + mFilter->apply( &tl ); + return tl; +} + +// When this is called, the todo have already been added to the calendar. +// This method is only about linking related todos +void Calendar::setupRelations( Incidence *incidence ) +{ + QString uid = incidence->uid(); + //qDebug("Calendar::setupRelations "); + // First, go over the list of orphans and see if this is their parent + while( Incidence* i = mOrphans[ uid ] ) { + mOrphans.remove( uid ); + i->setRelatedTo( incidence ); + incidence->addRelation( i ); + mOrphanUids.remove( i->uid() ); + } + + // Now see about this incidences parent + if( !incidence->relatedTo() && !incidence->relatedToUid().isEmpty() ) { + // This incidence has a uid it is related to, but is not registered to it yet + // Try to find it + Incidence* parent = this->incidence( incidence->relatedToUid() ); + if( parent ) { + // Found it + incidence->setRelatedTo( parent ); + parent->addRelation( incidence ); + } else { + // Not found, put this in the mOrphans list + mOrphans.insert( incidence->relatedToUid(), incidence ); + mOrphanUids.insert( incidence->uid(), incidence ); + } + } +} + +// If a task with subtasks is deleted, move it's subtasks to the orphans list +void Calendar::removeRelations( Incidence *incidence ) +{ + // qDebug("Calendar::removeRelations "); + QString uid = incidence->uid(); + + QPtrList<Incidence> relations = incidence->relations(); + for( Incidence* i = relations.first(); i; i = relations.next() ) + if( !mOrphanUids.find( i->uid() ) ) { + mOrphans.insert( uid, i ); + mOrphanUids.insert( i->uid(), i ); + i->setRelatedTo( 0 ); + i->setRelatedToUid( uid ); + } + + // If this incidence is related to something else, tell that about it + if( incidence->relatedTo() ) + incidence->relatedTo()->removeRelation( incidence ); + + // Remove this one from the orphans list + if( mOrphanUids.remove( uid ) ) + // This incidence is located in the orphans list - it should be removed + if( !( incidence->relatedTo() != 0 && mOrphans.remove( incidence->relatedTo()->uid() ) ) ) { + // Removing wasn't that easy + for( QDictIterator<Incidence> it( mOrphans ); it.current(); ++it ) { + if( it.current()->uid() == uid ) { + mOrphans.remove( it.currentKey() ); + break; + } + } + } +} + +void Calendar::registerObserver( Observer *observer ) +{ + mObserver = observer; + mNewObserver = true; +} + +void Calendar::setModified( bool modified ) +{ + if ( mObserver ) mObserver->calendarModified( modified, this ); + if ( modified != mModified || mNewObserver ) { + mNewObserver = false; + // if ( mObserver ) mObserver->calendarModified( modified, this ); + mModified = modified; + } +} + +void Calendar::setLoadedProductId( const QString &id ) +{ + mLoadedProductId = id; +} + +QString Calendar::loadedProductId() +{ + return mLoadedProductId; +} + +#include "calendar.moc" |