resourcecached.h

/*
  This file is part of the kcal library.

  Copyright (c) 2006 David Jarvie <djarvie@kde.org>
  Copyright (c) 2003,2004 Cornelius Schumacher <schumacher@kde.org>

  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_RESOURCECACHED_H
#define KCAL_RESOURCECACHED_H

#include "resourcecalendar.h"
#include "incidence.h"

#include <kdatetime.h>

#include <QtCore/QString>

class KConfigGroup;
namespace KRES { class IdMapper; }

namespace KCal {

class CalendarLocal;

class KCAL_DEPRECATED_EXPORT ResourceCached : public ResourceCalendar,
                                              public KCal::Calendar::CalendarObserver
{
  Q_OBJECT
  public:
    enum {
      ReloadNever,     
      ReloadOnStartup, 
      ReloadInterval   
    };

    enum {
      SaveNever,    
      SaveOnExit,   
      SaveInterval, 
      SaveDelayed,  
      SaveAlways    
    };

    enum CacheAction {
      DefaultCache,
      NoSyncCache, 
      SyncCache    
    };

    ResourceCached();
    explicit ResourceCached( const KConfigGroup &group );
    virtual ~ResourceCached();

    void readConfig( const KConfigGroup &group );
    void writeConfig( KConfigGroup &group );

    void setReloadPolicy( int policy );
    int reloadPolicy() const;

    void setReloadInterval( int minutes );

    int reloadInterval() const;

    bool inhibitDefaultReload( bool inhibit );
    bool defaultReloadInhibited() const;

    bool reloaded() const;

    void setSavePolicy( int policy );
    int savePolicy() const;

    void setSaveInterval( int minutes );

    int saveInterval() const;

    KDateTime lastLoad() const;

    KDateTime lastSave() const;

    bool load( CacheAction action );

    virtual bool load();

    bool save( CacheAction action, Incidence *incidence = 0 );

    virtual bool save( Incidence *incidence = 0 );

    bool addEvent( Event *event );

    bool deleteEvent( Event *event );

    void deleteAllEvents();

    Event *event( const QString &UniqueStr );

    Event::List events();

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

    Event::List rawEventsForDate( const QDate &date,
                                  const KDateTime::Spec &timeSpec = KDateTime::Spec(),
                                  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 );

    bool addTodo( Todo *todo );

    bool deleteTodo( Todo * );

    void deleteAllTodos();

    Todo *todo( const QString &uid );

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

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

    virtual KCAL_DEPRECATED bool addJournal( Journal *journal );

    virtual bool deleteJournal( Journal * );

    virtual void deleteAllJournals();

    virtual Journal *journal( const QString &uid );

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

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

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

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

    void setTimeSpec( const KDateTime::Spec &timeSpec );

    KDateTime::Spec timeSpec() const;

    void setTimeZoneId( const QString &timeZoneId );

    QString timeZoneId() const;

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

    Person owner() const;

    void setOwner( const Person &owner );

    void enableChangeNotification();
    void disableChangeNotification();

    void clearChange( Incidence *incidence );
    void clearChange( const QString &uid );

    void clearChanges();

    bool hasChanges() const;

    Incidence::List allChanges() const;

    Incidence::List addedIncidences() const;
    Incidence::List changedIncidences() const;
    Incidence::List deletedIncidences() const;

    bool loadFromCache();

    void saveToCache();

    void clearCache();

    void cleanUpEventCache( const KCal::Event::List &eventList );
    void cleanUpTodoCache( const KCal::Todo::List &todoList );

    KRES::IdMapper &idMapper();

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

  protected:
    CalendarLocal *calendar() const;

    // From Calendar::CalendarObserver
    void calendarIncidenceAdded( KCal::Incidence *incidence );
    void calendarIncidenceChanged( KCal::Incidence *incidence );
    void calendarIncidenceDeleted( KCal::Incidence *incidence );

    virtual void doClose();

    virtual bool doOpen();

    virtual bool doLoad( bool syncCache ) = 0;

    void setReloaded( bool done );

    virtual bool doSave( bool syncCache ) = 0;

    virtual bool doSave( bool syncCache, Incidence *incidence );

    bool checkForReload();

    bool checkForSave();

    void checkForAutomaticSave();

    void addInfoText( QString & ) const;

    void setupSaveTimer();
    void setupReloadTimer();

    virtual QString cacheFile() const;

    virtual QString changesCacheFile( const QString &type ) const;
    void loadChangesCache( QMap<Incidence *, bool> &map, const QString &type );
    void loadChangesCache();
    void saveChangesCache( const QMap<Incidence *, bool> &map, const QString &type );
    void saveChangesCache();

  protected Q_SLOTS:
    void slotReload();
    void slotSave();

    void setIdMapperIdentifier();

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

}

#endif