calendarresources.h

Go to the documentation of this file.

/*
  This file is part of the kcal library.

  Copyright (c) 2003 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_CALENDARRESOURCES_H
#define KCAL_CALENDARRESOURCES_H

#include <QtCore/QMap>

#include "calendar.h"
#include "exceptions.h"
#include "resourcecalendar.h"

#include "kcal_export.h"

class QWidget;

namespace KCal {

class KCAL_DEPRECATED_EXPORT CalendarResources
  : public Calendar, public KRES::ManagerObserver<ResourceCalendar>
{
  Q_OBJECT
  public:
    class DestinationPolicy
    {
      public:
        explicit DestinationPolicy( CalendarResourceManager *manager, QWidget *parent = 0 );

        virtual ~DestinationPolicy();

        virtual QWidget *parent();

        virtual void setParent( QWidget *parent );

        virtual ResourceCalendar *destination( Incidence *incidence ) = 0;

        bool hasCalendarResources();
      protected:
        CalendarResourceManager *resourceManager();

      private:
        //@cond PRIVATE
        Q_DISABLE_COPY( DestinationPolicy )
        class Private;
        Private *d;
        //@endcond
    };

    class StandardDestinationPolicy : public DestinationPolicy
    {
      public:
        explicit StandardDestinationPolicy( CalendarResourceManager *manager, QWidget *parent = 0 );

        virtual ~StandardDestinationPolicy();

        ResourceCalendar *destination( Incidence *incidence );

      private:
        //@cond PRIVATE
        Q_DISABLE_COPY( StandardDestinationPolicy )
        class Private;
        Private *d;
        //@endcond
    };

    class AskDestinationPolicy : public DestinationPolicy
    {
      public:
        explicit AskDestinationPolicy( CalendarResourceManager *manager, QWidget *parent = 0 );

        virtual ~AskDestinationPolicy();

        ResourceCalendar *destination( Incidence *incidence );
      private:
        //@cond PRIVATE
        Q_DISABLE_COPY( AskDestinationPolicy )
        class Private;
        Private *d;
        //@endcond
    };

    class Ticket
    {
      friend class CalendarResources;

      public:
        ResourceCalendar *resource() const;

        ~Ticket();

      private:
        Ticket( ResourceCalendar *resource );

        //@cond PRIVATE
        Q_DISABLE_COPY( Ticket )
        class Private;
        Private *d;
        //@endcond
    };

    CalendarResources(
      const KDateTime::Spec &timeSpec,
      const QString &family = QLatin1String( "calendar" ) );

    CalendarResources(
      const QString &timeZoneId,
      const QString &family = QLatin1String( "calendar" ) );

    ~CalendarResources();

    void clearException();

    ErrorFormat *exception();

    void load();

    bool reload();

    void close();

    virtual bool save( Ticket *ticket, Incidence *incidence = 0 );

    bool save();

    bool isSaving();

    CalendarResourceManager *resourceManager() const;

    ResourceCalendar *resource( Incidence *incidence );

    void readConfig( KConfig *config = 0 );

    void setStandardDestinationPolicy();

    void setAskDestinationPolicy();

    bool hasCalendarResources();

    QWidget *dialogParentWidget();

    void setDialogParentWidget( QWidget *parent );

    Ticket *requestSaveTicket( ResourceCalendar *resource );

    virtual void releaseSaveTicket( Ticket *ticket );

    void resourceAdded( ResourceCalendar *resource );

  // Incidence Specific Methods //

    bool addIncidence( Incidence *incidence );

    bool addIncidence( Incidence *incidence, ResourceCalendar *resource );

    bool beginChange( Incidence *incidence );

    bool endChange( Incidence *incidence );

  // Event Specific Methods //

    bool addEvent( Event *event );

    bool addEvent( Event *event, ResourceCalendar *resource );

    bool deleteEvent( Event *event );

    void deleteAllEvents();

    Event::List rawEvents(
      EventSortField sortField = EventSortUnsorted,
      SortDirection sortDirection = SortDirectionAscending );

    Event::List rawEventsForDate( const KDateTime &dt );

    Event::List rawEvents( const QDate &start, const QDate &end,
                           const KDateTime::Spec &timeSpec = KDateTime::Spec(),
                           bool inclusive = false );

    Event::List rawEventsForDate( const QDate &date,
                                  const KDateTime::Spec &timeSpec = KDateTime::Spec(),
                                  EventSortField sortField = EventSortUnsorted,
                                  SortDirection sortDirection = SortDirectionAscending );

    Event *event( const QString &uid );

  // Todo Specific Methods //

    bool addTodo( Todo *todo );

    bool addTodo( Todo *todo, ResourceCalendar *resource );

    bool deleteTodo( Todo *todo );

    void deleteAllTodos();

    Todo::List rawTodos( TodoSortField sortField = TodoSortUnsorted,
                         SortDirection sortDirection = SortDirectionAscending );

    Todo::List rawTodosForDate( const QDate &date );

    Todo *todo( const QString &uid );

  // Journal Specific Methods //

    bool addJournal( Journal *journal );

    bool addJournal( Journal *journal, ResourceCalendar *resource );

    bool deleteJournal( Journal *journal );

    void deleteAllJournals();

    Journal::List rawJournals(
      JournalSortField sortField = JournalSortUnsorted,
      SortDirection sortDirection = SortDirectionAscending );

    Journal::List rawJournalsForDate( const QDate &date );

    Journal *journal( const QString &uid );

  // Alarm Specific Methods //

    Alarm::List alarms( const KDateTime &from, const KDateTime &to );

    Alarm::List alarmsTo( const KDateTime &to );

    using QObject::event;   // prevent warning about hidden virtual method

  Q_SIGNALS:
    void signalResourceModified( ResourceCalendar *resource );

    void signalResourceAdded( ResourceCalendar *resource );

    void signalResourceDeleted( ResourceCalendar *resource );

    void signalErrorMessage( const QString &err );

  protected:
    void connectResource( ResourceCalendar *resource );

    void resourceModified( ResourceCalendar *resource );

    void resourceDeleted( ResourceCalendar *resource );

    virtual void doSetTimeSpec( const KDateTime::Spec &timeSpec );

    int incrementChangeCount( ResourceCalendar *resource );

    int decrementChangeCount( ResourceCalendar *resource );

  protected Q_SLOTS:
    void slotLoadError( ResourceCalendar *resource, const QString &err );

    void slotSaveError( ResourceCalendar *resource, const QString &err );

    void beginAddingIncidences();

    void endAddingIncidences();

  private:
    //@cond PRIVATE
    Q_DISABLE_COPY( CalendarResources )
    class Private;
    Private *d;
    //@endcond
};

}

#endif