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