Initial revision

1 files changed, 594 insertions, 0 deletions

diff --git a/libkcal/incidence.cpp b/libkcal/incidence.cpp
new file mode 100644
index 0000000..d9bda64
--- a/dev/null
+++ b/libkcal/incidence.cpp
@@ -0,0 +1,594 @@
+/*
+    This file is part of libkcal.
+    Copyright (c) 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 <kglobal.h>
+#include <klocale.h>
+#include <kdebug.h>
+
+#include "calformat.h"
+
+#include "incidence.h"
+#include "todo.h"
+
+using namespace KCal;
+
+Incidence::Incidence() :
+  IncidenceBase(),
+  mRelatedTo(0), mSecrecy(SecrecyPublic), mPriority(3)
+{
+  mRecurrence = new Recurrence(this);
+  mCancelled = false;
+  recreate();
+  mHasStartDate = true;
+  mAlarms.setAutoDelete(true);
+  mAttachments.setAutoDelete(true);
+}
+
+Incidence::Incidence( const Incidence &i ) : IncidenceBase( i )
+{
+// TODO: reenable attributes currently commented out.
+  mRevision = i.mRevision;
+  mCreated = i.mCreated;
+  mDescription = i.mDescription;
+  mSummary = i.mSummary;
+  mCategories = i.mCategories;
+//  Incidence *mRelatedTo;          Incidence *mRelatedTo;
+  mRelatedTo = 0;
+  mRelatedToUid = i.mRelatedToUid;
+//  QPtrList<Incidence> mRelations;    QPtrList<Incidence> mRelations;
+  mExDates = i.mExDates;
+  mAttachments = i.mAttachments;
+  mResources = i.mResources;
+  mSecrecy = i.mSecrecy;
+  mPriority = i.mPriority;
+  mLocation = i.mLocation;
+  mCancelled = i.mCancelled;
+  mHasStartDate = i.mHasStartDate;
+  QPtrListIterator<Alarm> it( i.mAlarms );
+  const Alarm *a;
+  while( (a = it.current()) ) {
+    Alarm *b = new Alarm( *a );
+    b->setParent( this );
+    mAlarms.append( b );
+
+    ++it;
+  }
+  mAlarms.setAutoDelete(true);
+
+  mRecurrence = new Recurrence( *(i.mRecurrence), this );
+}
+
+Incidence::~Incidence()
+{
+   
+  Incidence *ev;
+   QPtrList<Incidence> Relations = relations();
+  for (ev=Relations.first();ev;ev=Relations.next()) {
+    if (ev->relatedTo() == this) ev->setRelatedTo(0);
+  } 
+  if (relatedTo()) relatedTo()->removeRelation(this);
+  delete mRecurrence; 
+ 
+}
+
+bool Incidence::cancelled() const
+{
+    return mCancelled;
+}
+void Incidence::setCancelled( bool b )
+{
+    mCancelled = b;
+    updated();
+}
+bool Incidence::hasStartDate() const
+{
+  return mHasStartDate;
+}
+
+void Incidence::setHasStartDate(bool f)
+{
+  if (mReadOnly) return;
+  mHasStartDate = f;
+  updated();
+}
+
+// A string comparison that considers that null and empty are the same
+static bool stringCompare( const QString& s1, const QString& s2 )
+{
+    if ( s1.isEmpty() && s2.isEmpty() )
+        return true;
+    return s1 == s2;
+}
+
+bool KCal::operator==( const Incidence& i1, const Incidence& i2 )
+{
+  
+    if( i1.alarms().count() != i2.alarms().count() ) {
+        return false; // no need to check further
+    }
+    if ( i1.alarms().count() > 0 ) {
+        if ( !( *(i1.alarms().first()) == *(i2.alarms().first())) ) 
+            {
+            qDebug("alarm not equal ");
+            return false;
+        }
+    }
+#if 0
+    QPtrListIterator<Alarm> a1( i1.alarms() );
+    QPtrListIterator<Alarm> a2( i2.alarms() );
+    for( ; a1.current() && a2.current(); ++a1, ++a2 ) {
+        if( *a1.current() == *a2.current() ) {
+            continue;
+        }
+        else {
+            return false;
+        }
+    }
+#endif
+  
+    if ( ! operator==( (const IncidenceBase&)i1, (const IncidenceBase&)i2 ) )
+        return false;
+    if ( i1.hasStartDate() == i2.hasStartDate() ) {
+        if ( i1.hasStartDate() ) {
+            if ( i1.dtStart() != i2.dtStart() )
+                return false;
+        }
+    } else {
+        return false;
+    }
+    if (!( *i1.recurrence() == *i2.recurrence()) ) {
+        qDebug("recurrence is NOT equal ");
+        return false;
+    }
+    return
+        //  i1.created() == i2.created() &&
+        stringCompare( i1.description(), i2.description() ) &&
+        stringCompare( i1.summary(), i2.summary() ) &&
+        i1.categories() == i2.categories() &&
+        // no need to compare mRelatedTo
+        stringCompare( i1.relatedToUid(), i2.relatedToUid() ) &&
+        //      i1.relations() == i2.relations() &&
+        i1.exDates() == i2.exDates() &&
+        i1.attachments() == i2.attachments() &&
+        i1.resources() == i2.resources() &&
+        i1.secrecy() == i2.secrecy() &&
+        i1.priority() == i2.priority() &&
+        stringCompare( i1.location(), i2.location() );
+}
+
+
+void Incidence::recreate()
+{
+  setCreated(QDateTime::currentDateTime());
+
+  setUid(CalFormat::createUniqueId());
+
+  setRevision(0);
+
+  setLastModified(QDateTime::currentDateTime());
+}
+
+void Incidence::setReadOnly( bool readOnly )
+{
+  IncidenceBase::setReadOnly( readOnly );
+  recurrence()->setRecurReadOnly( readOnly);
+}
+
+void Incidence::setCreated(QDateTime created)
+{
+  if (mReadOnly) return;
+  mCreated = getEvenTime(created);
+}
+
+QDateTime Incidence::created() const
+{
+  return mCreated;
+}
+
+void Incidence::setRevision(int rev)
+{
+  if (mReadOnly) return;
+  mRevision = rev;
+
+  updated();
+}
+
+int Incidence::revision() const
+{
+  return mRevision;
+}
+
+void Incidence::setDtStart(const QDateTime &dtStart)
+{
+
+  QDateTime  dt = getEvenTime(dtStart);
+  recurrence()->setRecurStart( dt);
+  IncidenceBase::setDtStart( dt );
+}
+
+void Incidence::setDescription(const QString &description)
+{
+  if (mReadOnly) return;
+  mDescription = description;
+  updated();
+}
+
+QString Incidence::description() const
+{
+  return mDescription;
+}
+
+
+void Incidence::setSummary(const QString &summary)
+{
+  if (mReadOnly) return;
+  mSummary = summary;
+  updated();
+}
+
+QString Incidence::summary() const
+{
+  return mSummary;
+}
+
+void Incidence::setCategories(const QStringList &categories)
+{
+  if (mReadOnly) return;
+  mCategories = categories;
+  updated();
+}
+
+// TODO: remove setCategories(QString) function
+void Incidence::setCategories(const QString &catStr)
+{
+  if (mReadOnly) return;
+  mCategories.clear();
+
+  if (catStr.isEmpty()) return;
+
+  mCategories = QStringList::split(",",catStr);
+
+  QStringList::Iterator it;
+  for(it = mCategories.begin();it != mCategories.end(); ++it) {
+    *it = (*it).stripWhiteSpace();
+  }
+
+  updated();
+}
+
+QStringList Incidence::categories() const
+{
+  return mCategories;
+}
+
+QString Incidence::categoriesStr()
+{
+  return mCategories.join(",");
+}
+
+void Incidence::setRelatedToUid(const QString &relatedToUid)
+{
+  if (mReadOnly) return;
+  mRelatedToUid = relatedToUid;
+}
+
+QString Incidence::relatedToUid() const
+{
+  return mRelatedToUid;
+}
+
+void Incidence::setRelatedTo(Incidence *relatedTo)
+{
+    //qDebug("Incidence::setRelatedTo %d ", relatedTo);
+    //qDebug("setRelatedTo(Incidence *relatedTo) %s %s", summary().latin1(), relatedTo->summary().latin1() );
+  if (mReadOnly || mRelatedTo == relatedTo) return;
+  if(mRelatedTo) {
+      // updated();
+    mRelatedTo->removeRelation(this);
+  }
+  mRelatedTo = relatedTo;
+  if (mRelatedTo) mRelatedTo->addRelation(this);
+}
+
+Incidence *Incidence::relatedTo() const
+{
+  return mRelatedTo;
+}
+
+QPtrList<Incidence> Incidence::relations() const
+{
+  return mRelations;
+}
+
+void Incidence::addRelation(Incidence *event)
+{
+  if( mRelations.findRef( event ) == -1 ) {
+    mRelations.append(event);
+    //updated();
+  }
+}
+
+void Incidence::removeRelation(Incidence *event)
+{
+  
+  mRelations.removeRef(event); 
+ 
+//  if (event->getRelatedTo() == this) event->setRelatedTo(0);
+}
+
+bool Incidence::recursOn(const QDate &qd) const
+{
+  if (recurrence()->recursOnPure(qd) && !isException(qd)) return true;
+  else return false;
+}
+
+void Incidence::setExDates(const DateList &exDates)
+{
+  if (mReadOnly) return;
+  mExDates = exDates;
+
+  recurrence()->setRecurExDatesCount(mExDates.count());
+
+  updated();
+}
+
+void Incidence::addExDate(const QDate &date)
+{
+  if (mReadOnly) return;
+  mExDates.append(date);
+
+  recurrence()->setRecurExDatesCount(mExDates.count());
+
+  updated();
+}
+
+DateList Incidence::exDates() const
+{
+  return mExDates;
+}
+
+bool Incidence::isException(const QDate &date) const
+{
+  DateList::ConstIterator it;
+  for( it = mExDates.begin(); it != mExDates.end(); ++it ) {
+    if ( (*it) == date ) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+void Incidence::addAttachment(Attachment *attachment)
+{
+  if (mReadOnly || !attachment) return;
+  mAttachments.append(attachment);
+  updated();
+}
+
+void Incidence::deleteAttachment(Attachment *attachment)
+{
+  mAttachments.removeRef(attachment);
+}
+
+void Incidence::deleteAttachments(const QString& mime)
+{
+  Attachment *at = mAttachments.first();
+  while (at) {
+    if (at->mimeType() == mime)
+      mAttachments.remove();
+    else
+      at = mAttachments.next();
+  }
+}
+
+QPtrList<Attachment> Incidence::attachments() const
+{
+  return mAttachments;
+}
+
+QPtrList<Attachment> Incidence::attachments(const QString& mime) const
+{
+  QPtrList<Attachment> attachments;
+  QPtrListIterator<Attachment> it( mAttachments );
+  Attachment *at;
+  while ( (at = it.current()) ) {
+    if (at->mimeType() == mime)
+      attachments.append(at);
+    ++it;
+  }
+
+  return attachments;
+}
+
+void Incidence::setResources(const QStringList &resources)
+{
+  if (mReadOnly) return;
+  mResources = resources;
+  updated();
+}
+
+QStringList Incidence::resources() const
+{
+  return mResources;
+}
+
+
+void Incidence::setPriority(int priority)
+{
+  if (mReadOnly) return;
+  mPriority = priority;
+  updated();
+}
+
+int Incidence::priority() const
+{
+  return mPriority;
+}
+
+void Incidence::setSecrecy(int sec)
+{
+  if (mReadOnly) return;
+  mSecrecy = sec;
+  updated();
+}
+
+int Incidence::secrecy() const
+{
+  return mSecrecy;
+}
+
+QString Incidence::secrecyStr() const
+{
+  return secrecyName(mSecrecy);
+}
+
+QString Incidence::secrecyName(int secrecy)
+{
+  switch (secrecy) {
+    case SecrecyPublic:
+      return i18n("Public");
+      break;
+    case SecrecyPrivate:
+      return i18n("Private");
+      break;
+    case SecrecyConfidential:
+      return i18n("Confidential");
+      break;
+    default:
+      return i18n("Undefined");
+      break;
+  }
+}
+
+QStringList Incidence::secrecyList()
+{
+  QStringList list;
+  list << secrecyName(SecrecyPublic);
+  list << secrecyName(SecrecyPrivate);
+  list << secrecyName(SecrecyConfidential);
+
+  return list;
+}
+
+
+QPtrList<Alarm> Incidence::alarms() const
+{
+  return mAlarms;
+}
+
+Alarm* Incidence::newAlarm()
+{
+  Alarm* alarm = new Alarm(this);
+  mAlarms.append(alarm);
+//  updated();
+  return alarm;
+}
+
+void Incidence::addAlarm(Alarm *alarm)
+{
+  mAlarms.append(alarm);
+  updated();
+}
+
+void Incidence::removeAlarm(Alarm *alarm)
+{
+  mAlarms.removeRef(alarm);
+  updated();
+}
+
+void Incidence::clearAlarms()
+{
+  mAlarms.clear();
+  updated();
+}
+
+bool Incidence::isAlarmEnabled() const
+{
+  Alarm* alarm;
+  for (QPtrListIterator<Alarm> it(mAlarms); (alarm = it.current()) != 0; ++it) {
+    if (alarm->enabled())
+      return true;
+  }
+  return false;
+}
+
+Recurrence *Incidence::recurrence() const
+{
+  return mRecurrence;
+}
+
+void Incidence::setLocation(const QString &location)
+{
+  if (mReadOnly) return;
+  mLocation = location;
+  updated();
+}
+
+QString Incidence::location() const
+{
+  return mLocation;
+}
+
+ushort Incidence::doesRecur() const
+{
+  if ( mRecurrence ) return mRecurrence->doesRecur();
+  else return Recurrence::rNone;
+}
+
+QDateTime Incidence::getNextOccurence( const QDateTime& dt, bool* ok ) const
+{
+    QDateTime incidenceStart = dt;
+    *ok = false;
+    if ( doesRecur() ) {
+        bool last;
+         recurrence()->getPreviousDateTime( incidenceStart , &last );
+         int count = 0;
+         if ( !last ) {
+             while ( !last ) {
+                 ++count;
+                 incidenceStart = recurrence()->getNextDateTime( incidenceStart, &last );
+                 if ( recursOn( incidenceStart.date() ) ) {
+                     last = true; // exit while llop
+                 } else {
+                     if ( last ) { // no alarm on last recurrence
+                         return QDateTime ();
+                     }
+                     int year = incidenceStart.date().year();
+                     // workaround for bug in recurrence
+                     if ( count == 100 || year < 1980 || year > 5000 ) {
+                         return QDateTime ();
+                     }
+                     incidenceStart = incidenceStart.addSecs( 1 );
+                 }
+             }
+         } else {
+             return QDateTime ();
+         }
+    } else {
+        if ( hasStartDate () ) {
+            incidenceStart = dtStart(); 
+            
+        } 
+    }
+    if ( incidenceStart > dt )
+        *ok = true;
+    return incidenceStart;
+}