resourcecalendar.h

/*
  This file is part of the kcal library.

  Copyright (c) 1998 Preston Brown <pbrown@kde.org>
  Copyright (c) 2001,2003 Cornelius Schumacher <schumacher@kde.org>
  Copyright (c) 2002 Jan-Pascal van Best <janpascal@vanbest.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_RESOURCECALENDAR_H
#define KCAL_RESOURCECALENDAR_H

#include "alarm.h"
#include "todo.h"
#include "event.h"
#include "journal.h"
#include "calendar.h"
#include "exceptions.h"

#include "kresources/resource.h"
#include "kresources/manager.h"
#include "kabc/lock.h"

#include <kdatetime.h>
#include <kconfig.h>

#include <QtCore/QString>

namespace KCal {

class KCAL_DEPRECATED_EXPORT ResourceCalendar : public KRES::Resource
{
  Q_OBJECT
  public:
    ResourceCalendar();
    explicit ResourceCalendar( const KConfigGroup &group );
    virtual ~ResourceCalendar();

    bool isResolveConflictSet() const;
    void setResolveConflict( bool b );

    virtual void writeConfig( KConfigGroup &group );

    virtual QString infoText() const;

    virtual bool load();

    bool save( Incidence *incidence = 0 );

    bool save( QString &err, Incidence *incidence = 0 );

    virtual bool isSaving();

    void setInhibitSave( bool inhibit );

    bool saveInhibited() const;

    virtual KABC::Lock *lock() = 0;

    virtual bool addIncidence( Incidence * );

    virtual bool deleteIncidence( Incidence * );

    Incidence *incidence( const QString &uid );

    virtual bool addEvent( Event *event ) = 0;

    virtual bool deleteEvent( Event * ) = 0;

    virtual void deleteAllEvents() = 0;

    virtual Event *event( const QString &uid ) = 0;

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

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

    virtual Event::List rawEventsForDate( const KDateTime &dt ) = 0;

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

    virtual bool setValue( const QString &key, const QString &value );

  Q_SIGNALS:
    void resourceChanged( ResourceCalendar * );

    void resourceLoaded( ResourceCalendar * );

    void resourceSaved( ResourceCalendar * );

    void resourceLoadError( ResourceCalendar *, const QString &error );

    void resourceSaveError( ResourceCalendar *, const QString &error );

    void signalSubresourceAdded( ResourceCalendar *, const QString &type,
                                 const QString &subresource, const QString &label );

    void signalSubresourceRemoved( ResourceCalendar *, const QString &,
                                   const QString & );

  public:
    virtual bool addTodo( Todo *todo ) = 0;

    virtual bool deleteTodo( Todo * ) = 0;

    virtual void deleteAllTodos() = 0;

    virtual Todo *todo( const QString &uid ) = 0;

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

    virtual Todo::List rawTodosForDate( const QDate &date ) = 0;

    virtual bool addJournal( Journal * ) = 0;

    virtual bool deleteJournal( Journal * ) = 0;

    virtual void deleteAllJournals() = 0;

    virtual Journal *journal( const QString &uid ) = 0;

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

    virtual Journal::List rawJournalsForDate( const QDate &date ) = 0;

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

    virtual Alarm::List alarmsTo( const KDateTime &to ) = 0;

    Incidence::List rawIncidences();

    virtual void setTimeSpec( const KDateTime::Spec &timeSpec ) = 0;

    virtual KDateTime::Spec timeSpec() const = 0;

    virtual void setTimeZoneId( const QString &timeZoneId ) = 0;

    virtual QString timeZoneId() const = 0;

    virtual void shiftTimes( const KDateTime::Spec &oldSpec,
                             const KDateTime::Spec &newSpec ) = 0;

    virtual QStringList subresources() const;

    virtual bool canHaveSubresources() const;

    virtual bool subresourceActive( const QString &resource ) const;

    virtual QString labelForSubresource( const QString &resource ) const;

    virtual QString subresourceIdentifier( Incidence *incidence );

  public Q_SLOTS:
    virtual void setSubresourceActive( const QString &resource, bool active );

    virtual bool removeSubresource( const QString &resource );

    virtual bool addSubresource( const QString &resource, const QString &parent );

    virtual QString subresourceType( const QString &resource );

  protected:
    virtual bool doLoad( bool syncCache ) = 0;

    virtual bool doSave( bool syncCache ) = 0;

    virtual bool doSave( bool syncCache, Incidence * );

    virtual void addInfoText( QString & ) const {}

    void loadError( const QString &errorMessage = QString() );

    void saveError( const QString &errorMessage = QString() );

    bool receivedLoadError() const;
    void setReceivedLoadError( bool b );
    bool receivedSaveError() const;
    void setReceivedSaveError( bool b );

    void setNoReadOnlyOnLoad( bool noReadOnly );

    bool noReadOnlyOnLoad() const;

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

  private:
    //@cond PRIVATE
    Q_DISABLE_COPY( ResourceCalendar )

    class Private;
    Private *const d;
    //@endcond
};

typedef KRES::Manager<ResourceCalendar> CalendarResourceManager;

}

#endif