Initial revision

1 files changed, 298 insertions, 0 deletions

diff --git a/libkcal/incidence.h b/libkcal/incidence.h
new file mode 100644
index 0000000..d1972cb
--- a/dev/null
+++ b/libkcal/incidence.h
@@ -0,0 +1,298 @@
+/*
+    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.
+*/
+#ifndef INCIDENCE_H
+#define INCIDENCE_H
+//
+// Incidence - base class of calendaring components
+//
+
+#include <qdatetime.h>
+#include <qstringlist.h>
+#include <qvaluelist.h>
+
+#include "recurrence.h"
+#include "alarm.h"
+#include "attachment.h"
+#include "listbase.h"
+#include "incidencebase.h"
+
+namespace KCal {
+
+class Event;
+class Todo;
+class Journal;
+
+/**
+  This class provides the base class common to all calendar components.
+*/
+class Incidence : public IncidenceBase
+{
+  public:
+    /**
+      This class provides the interface for a visitor of calendar components. It
+      serves as base class for concrete visitors, which implement certain actions on
+      calendar components. It allows to add functions, which operate on the concrete
+      types of calendar components, without changing the calendar component classes.
+    */
+    class Visitor
+    {
+      public:
+        /** Destruct Incidence::Visitor */
+        virtual ~Visitor() {}
+
+        /**
+          Reimplement this function in your concrete subclass of IncidenceVisitor to perform actions
+          on an Event object.
+        */
+        virtual bool visit(Event *) { return false; }
+        /**
+          Reimplement this function in your concrete subclass of IncidenceVisitor to perform actions
+          on an Todo object.
+        */
+        virtual bool visit(Todo *) { return false; }
+        /**
+          Reimplement this function in your concrete subclass of IncidenceVisitor to perform actions
+          on an Journal object.
+        */
+        virtual bool visit(Journal *) { return false; }
+
+      protected:
+        /** Constructor is protected to prevent direct creation of visitor base class. */
+        Visitor() {}
+    };
+
+    /**
+      This class implements a visitor for adding an Incidence to a resource
+      supporting addEvent(), addTodo() and addJournal() calls.
+    */
+    template<class T>
+    class AddVisitor : public Visitor
+    {
+      public:
+        AddVisitor( T *r ) : mResource( r ) {}
+        bool visit( Event *e ) { return mResource->addEvent( e ); }
+        bool visit( Todo *t ) { return mResource->addTodo( t ); }
+        bool visit( Journal *j ) { return mResource->addJournal( j ); }
+
+      private:
+        T *mResource;
+    };
+
+    /** enumeration for describing an event's secrecy. */
+    enum { SecrecyPublic = 0, SecrecyPrivate = 1, SecrecyConfidential = 2 };
+    typedef ListBase<Incidence> List;
+    Incidence();
+    Incidence(const Incidence &);
+    ~Incidence();
+
+    /**
+      Accept IncidenceVisitor. A class taking part in the visitor mechanism has to
+      provide this implementation:
+      <pre>
+        bool accept(Visitor &v) { return v.visit(this); }
+      </pre>
+    */
+    virtual bool accept(Visitor &) { return false; }
+
+    virtual Incidence *clone() = 0;
+
+    virtual QDateTime getNextAlarmDateTime( bool * ok, int * offset ) const = 0;
+    void setReadOnly( bool );
+
+    /**
+      Recreate event. The event is made a new unique event, but already stored
+      event information is preserved. Sets uniquie id, creation date, last
+      modification date and revision number.
+    */
+    void recreate();
+
+    /** set creation date */
+    void setCreated(QDateTime);
+    /** return time and date of creation. */
+    QDateTime created() const;
+
+    /** set the number of revisions this event has seen */
+    void setRevision(int rev);
+    /** return the number of revisions this event has seen */
+    int revision() const;
+
+    /** Set starting date/time. */
+    virtual void setDtStart(const QDateTime &dtStart);
+    /** Return the incidence's ending date/time as a QDateTime. */
+    virtual QDateTime dtEnd() const  { return QDateTime(); }
+
+    /** sets the event's lengthy description. */
+    void setDescription(const QString &description);
+    /** returns a reference to the event's description. */
+    QString description() const;
+
+    /** sets the event's short summary. */
+    void setSummary(const QString &summary);
+    /** returns a reference to the event's summary. */
+    QString summary() const;
+
+    /** set event's applicable categories */
+    void setCategories(const QStringList &categories);
+    /** set event's categories based on a comma delimited string */
+    void setCategories(const QString &catStr);
+    /** return categories in a list */
+    QStringList categories() const;
+    /** return categories as a comma separated string */
+    QString categoriesStr();
+
+    /** point at some other event to which the event relates. This function should
+     *  only be used when constructing a calendar before the related Event
+     *  exists. */
+    void setRelatedToUid(const QString &);
+    /** what event does this one relate to? This function should
+     *  only be used when constructing a calendar before the related Event
+     *  exists. */
+    QString relatedToUid() const;
+    /** point at some other event to which the event relates */
+    void setRelatedTo(Incidence *relatedTo);
+    /** what event does this one relate to? */
+    Incidence *relatedTo() const;
+    /** All events that are related to this event */
+    QPtrList<Incidence> relations() const;
+    /** Add an event which is related to this event */
+    void addRelation(Incidence *);
+    /** Remove event that is related to this event */
+    void removeRelation(Incidence *);
+
+    /** returns the list of dates which are exceptions to the recurrence rule */
+    DateList exDates() const;
+    /** sets the list of dates which are exceptions to the recurrence rule */
+    void setExDates(const DateList &_exDates);
+    void setExDates(const char *dates);
+    /** Add a date to the list of exceptions of the recurrence rule. */
+    void addExDate(const QDate &date);
+
+    /** returns true if there is an exception for this date in the recurrence
+     rule set, or false otherwise. */
+    bool isException(const QDate &qd) const;
+
+    /** add attachment to this event */
+    void addAttachment(Attachment *attachment);
+    /** remove and delete a specific attachment */
+    void deleteAttachment(Attachment *attachment);
+    /** remove and delete all attachments with this mime type */
+    void deleteAttachments(const QString& mime);
+    /** return list of all associated attachments */
+    QPtrList<Attachment> attachments() const;
+    /** find a list of attachments with this mime type */
+    QPtrList<Attachment> attachments(const QString& mime) const;
+
+    /** sets the event's status the value specified.  See the enumeration
+     * above for possible values. */
+    void setSecrecy(int);
+    /** return the event's secrecy. */
+    int secrecy() const;
+    /** return the event's secrecy in string format. */
+    QString secrecyStr() const;
+    /** return list of all availbale secrecy classes */
+    static QStringList secrecyList();
+    /** return human-readable name of secrecy class */
+    static QString secrecyName(int);
+
+    /** returns TRUE if the date specified is one on which the event will
+     * recur. */
+    bool recursOn(const QDate &qd) const;
+
+    // VEVENT and VTODO, but not VJOURNAL (move to EventBase class?):
+
+    /** set resources used, such as Office, Car, etc. */
+    void setResources(const QStringList &resources);
+    /** return list of current resources */
+    QStringList resources() const;
+
+    /** set the event's priority, 0 is undefined, 1 highest (decreasing order) */
+    void setPriority(int priority);
+    /** get the event's priority */
+    int priority() const;
+
+    /** All alarms that are associated with this incidence */
+    QPtrList<Alarm> alarms() const;
+    /** Create a new alarm which is associated with this incidence */
+    Alarm* newAlarm();
+    /** Add an alarm which is associated with this incidence */
+    void addAlarm(Alarm*);
+    /** Remove an alarm that is associated with this incidence */
+    void removeAlarm(Alarm*);
+    /** Remove all alarms that are associated with this incidence */
+    void clearAlarms();
+    /** return whether any alarm associated with this incidence is enabled */
+    bool isAlarmEnabled() const;
+
+    /**
+      Return the recurrence rule associated with this incidence. If there is
+      none, returns an appropriate (non-0) object.
+    */
+    Recurrence *recurrence() const;
+
+    /**
+      Forward to Recurrence::doesRecur().
+    */
+    ushort doesRecur() const;
+
+    /** set the event's/todo's location. Do _not_ use it with journal */
+    void setLocation(const QString &location);
+    /** return the event's/todo's location. Do _not_ use it with journal */
+    QString location() const;  
+   /** returns TRUE or FALSE depending on whether the todo has a start date */
+    bool hasStartDate() const;
+    /** sets the event's hasStartDate value. */
+    void setHasStartDate(bool f);
+    QDateTime getNextOccurence( const QDateTime& dt, bool* yes ) const;
+    bool cancelled() const;
+    void setCancelled( bool b );
+
+protected:
+    QPtrList<Alarm> mAlarms;
+  private:
+    int mRevision;
+    bool mCancelled;
+
+    // base components of jounal, event and todo
+    QDateTime mCreated;
+    QString mDescription;
+    QString mSummary;
+    QStringList mCategories;
+    Incidence *mRelatedTo;
+    QString mRelatedToUid;
+    QPtrList<Incidence> mRelations;
+    DateList mExDates;
+    QPtrList<Attachment> mAttachments;
+    QStringList mResources;
+    bool mHasStartDate;                  // if todo has associated start date
+
+    int mSecrecy;
+    int mPriority;                        // 1 = highest, 2 = less, etc.
+
+    //QPtrList<Alarm> mAlarms;
+    Recurrence *mRecurrence;
+    
+    QString mLocation;
+};
+
+bool operator==( const Incidence&, const Incidence& );
+
+}
+
+#endif