calendar.h

Go to the documentation of this file.

/*
    This file is part of libkcal.
 
    Copyright (c) 1998 Preston Brown <pbrown@kde.org>
    Copyright (c) 2001,2003,2004 Cornelius Schumacher <schumacher@kde.org>
    Copyright (C) 2003-2004 Reinhold Kainhofer <reinhold@kainhofer.com>
 
    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., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
*/
#ifndef KCAL_CALENDAR_H
#define KCAL_CALENDAR_H
 
#include "exceptions.h"
#include "customproperties.h"
#include "event.h"
#include "todo.h"
#include "journal.h"
#include "kcalversion.h"
#include "person.h"
 
#include <tdemacros.h>
 
#include <tqobject.h>
#include <tqstring.h>
#include <tqdatetime.h>
#include <tqptrlist.h>
#include <tqdict.h>
 
namespace KCal {
 
class CalFilter;
 
enum SortDirection
{
  SortDirectionAscending,
  SortDirectionDescending
};
 
enum EventSortField
{
  EventSortUnsorted,
  EventSortStartDate,
  EventSortEndDate,
  EventSortSummary
};
 
enum TodoSortField
{
  TodoSortUnsorted,
  TodoSortStartDate,
  TodoSortDueDate,
  TodoSortPriority,
  TodoSortPercentComplete,
  TodoSortSummary
};
 
enum JournalSortField
{
  JournalSortUnsorted,
  JournalSortDate,
  JournalSortSummary
};
 
class LIBKCAL_EXPORT Calendar : public TQObject, public CustomProperties,
                                public IncidenceBase::Observer
{
    TQ_OBJECT
  
 
  public:
 
    Calendar( const TQString &timeZoneId );
 
    virtual ~Calendar();
 
    void setProductId( const TQString &productId );
 
    TQString productId();
 
    void clearException();
 
    ErrorFormat *exception() const;
 
    void setOwner( const Person &owner );
 
    const Person &getOwner() const;
 
    void setTimeZoneId( const TQString &timeZoneId );
 
    virtual void setTimeZoneIdViewOnly( const TQString &timeZoneId ) = 0;
 
    TQString timeZoneId() const;
 
    void setLocalTime();
 
    bool isLocalTime() const;
 
    void setModified( bool modified );
 
    bool isModified() const { return mModified; }
 
    virtual void close() = 0;
 
    virtual void closeEvents() = 0;
 
    virtual void closeTodos() = 0;
 
    virtual void closeJournals() = 0;
 
    virtual void save() = 0;
 
    virtual bool reload( const TQString &tz ) = 0;
 
    virtual bool isSaving() { return false; }
 
    TQStringList categories();
 
// Incidence Specific Methods //
 
    virtual bool addIncidence( Incidence *incidence );
 
    virtual bool deleteIncidence( Incidence *incidence );
 
    virtual Incidence::List incidences();
 
    virtual Incidence::List incidences( const TQDate &date );
 
    virtual Incidence::List rawIncidences();
 
    Incidence *incidence( const TQString &uid );
 
    Incidence *incidenceFromSchedulingID( const TQString &sid );
 
    Incidence::List incidencesFromSchedulingID( const TQString &UID );
 
    static Incidence::List mergeIncidenceList( const Event::List &events,
                                               const Todo::List &todos,
                                               const Journal::List &journals );
 
    virtual bool beginChange( Incidence *incidence );
 
    virtual bool endChange( Incidence *incidence );
 
    Incidence *dissociateOccurrence( Incidence *incidence, TQDate date,
                                     bool single = true );
 
// Event Specific Methods //
 
    virtual bool addEvent( Event *event ) = 0;
 
    virtual bool deleteEvent( Event *event ) = 0;
 
    static Event::List sortEvents( Event::List *eventList,
                                   EventSortField sortField,
                                   SortDirection sortDirection );
 
    static Event::List sortEventsForDate( Event::List *eventList,
                                          const TQDate &date,
                                          EventSortField sortField,
                                          SortDirection sortDirection );
 
    virtual Event::List events(
      EventSortField sortField = EventSortUnsorted,
      SortDirection sortDirection = SortDirectionAscending );
 
    Event::List events( const TQDateTime &qdt );
 
    Event::List events( const TQDate &start, const TQDate &end,
                        bool inclusive = false);
 
    Event::List events(
      const TQDate &date,
      EventSortField sortField = EventSortUnsorted,
      SortDirection sortDirection = SortDirectionAscending );
 
    virtual Event::List rawEvents(
      EventSortField sortField = EventSortUnsorted,
      SortDirection sortDirection = SortDirectionAscending ) = 0;
 
    virtual Event::List rawEventsForDate( const TQDateTime &qdt ) = 0;
 
    virtual Event::List rawEvents( const TQDate &start, const TQDate &end,
                                   bool inclusive = false ) = 0;
 
    virtual Event::List rawEventsForDate(
      const TQDate &date,
      EventSortField sortField = EventSortUnsorted,
      SortDirection sortDirection = SortDirectionAscending ) = 0;
 
    virtual Event *event( const TQString &uid ) = 0;
 
// Todo Specific Methods //
 
    virtual bool addTodo( Todo *todo ) = 0;
 
    virtual bool deleteTodo( Todo *todo ) = 0;
 
    static Todo::List sortTodos( Todo::List *todoList,
                                 TodoSortField sortField,
                                 SortDirection sortDirection );
 
    virtual Todo::List todos(
      TodoSortField sortField = TodoSortUnsorted,
      SortDirection sortDirection = SortDirectionAscending );
 
    virtual Todo::List todos( const TQDate &date );
 
    virtual Todo::List rawTodos(
      TodoSortField sortField = TodoSortUnsorted,
      SortDirection sortDirection = SortDirectionAscending ) = 0;
 
    virtual Todo::List rawTodosForDate( const TQDate &date ) = 0;
 
    virtual Todo *todo( const TQString &uid ) = 0;
 
// Journal Specific Methods //
 
    virtual bool addJournal( Journal *journal ) = 0;
 
    virtual bool deleteJournal( Journal *journal ) = 0;
 
    static Journal::List sortJournals( Journal::List *journalList,
                                       JournalSortField sortField,
                                       SortDirection sortDirection );
    virtual Journal::List journals(
      JournalSortField sortField = JournalSortUnsorted,
      SortDirection sortDirection = SortDirectionAscending );
 
    virtual Journal::List journals( const TQDate &date );
 
    virtual Journal::List rawJournals(
      JournalSortField sortField = JournalSortUnsorted,
      SortDirection sortDirection = SortDirectionAscending ) = 0;
 
    virtual Journal::List rawJournalsForDate( const TQDate &date ) = 0;
 
    virtual Journal *journal( const TQString &uid ) = 0;
 
    void beginBatchAdding();
 
    void endBatchAdding();
 
// Relations Specific Methods //
 
    virtual void setupRelations( Incidence *incidence );
 
    virtual void removeRelations( Incidence *incidence );
 
// Filter Specific Methods //
 
    void setFilter( CalFilter *filter );
 
    CalFilter *filter();
 
// Alarm Specific Methods //
 
    virtual Alarm::List alarms( const TQDateTime &from,
                                const TQDateTime &to ) = 0;
 
// Observer Specific Methods //
 
    class Observer
    {
      public:
        virtual ~Observer() {}
        virtual void calendarModified( bool /*modified*/,
                                       Calendar * /*calendar*/ ) {};
 
        virtual void calendarIncidenceAdded( Incidence * /*incidence*/ ) {}
 
        virtual void calendarIncidenceChanged( Incidence * /*incidence*/ ) {}
 
          virtual void calendarIncidenceDeleted( Incidence * /*incidence*/ ) {}
    };
 
    void registerObserver( Observer *observer );
 
    void unregisterObserver( Observer *observer );
 
  signals:
    void calendarChanged();
 
    void calendarSaved();
 
    void calendarLoaded();
 
    void batchAddingBegins();
 
    void batchAddingEnds();
 
  protected:
    void setException( ErrorFormat *e );
 
    void incidenceUpdated( IncidenceBase *incidenceBase );
 
    virtual void doSetTimeZoneId( const TQString &/*timeZoneId*/ ) {}
 
    void notifyIncidenceAdded( Incidence *incidence );
 
    void notifyIncidenceChanged( Incidence *incidence );
 
    void notifyIncidenceDeleted( Incidence *incidence );
 
    virtual void customPropertyUpdated();
 
    void setObserversEnabled( bool enabled );
 
    //TODO: Move appendAlarms() and appendRecurringAlarms() from
    //      calendarlocal here, as protected static methods
    //      returning static Alarm::List
 
  private:
 
    void init();
 
    TQString mProductId;
    Person mOwner;
    TQString mTimeZoneId;
    bool mLocalTime;
 
    bool mModified;
 
    CalFilter *mFilter;
    CalFilter *mDefaultFilter;
 
    TQPtrList<Observer> mObservers;
    bool mNewObserver;
    bool mObserversEnabled;
 
    // This list is used to put together related Todos
    TQDict<Incidence> mOrphans;
    TQDict<Incidence> mOrphanUids;
 
    ErrorFormat *mException;
    class Private;
    Private *d;
  };
 
}
 
#endif