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