resourcecalendar.h

/*
    This file is part of libkcal.
 
    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 <tqstring.h>
#include <tqdatetime.h>
#include <tqptrlist.h>
 
#include <tdeconfig.h>
 
#include "alarm.h"
#include "todo.h"
#include "event.h"
#include "journal.h"
#include "calendar.h"
#include "exceptions.h"
 
#include <tderesources/resource.h>
#include <tderesources/manager.h>
#include <tdeabc/lock.h>
#include <tdemacros.h>
 
namespace KCal {
 
class CalFormat;
 
class LIBKCAL_EXPORT ResourceCalendar : public KRES::Resource
{
  TQ_OBJECT
  
  public:
    ResourceCalendar( const TDEConfig * );
    virtual ~ResourceCalendar();
 
    void clearException();
 
    void setException( ErrorFormat *error );
 
    ErrorFormat *exception();
 
    void setResolveConflict( bool b);
 
    virtual void writeConfig( TDEConfig* config );
 
    virtual TQString infoText() const;
 
    bool load();
 
    bool save( Incidence *incidence = 0 );
 
    virtual bool isSaving() { return false; }
 
    virtual TDEABC::Lock *lock() = 0;
 
    virtual TDE_DEPRECATED bool addIncidence( Incidence * );
 
    virtual bool addIncidence( Incidence *, const TQString &subresource );
 
    virtual bool deleteIncidence( Incidence * );
 
    Incidence *incidence( const TQString &uid );
 
    virtual TDE_DEPRECATED bool addEvent( Event *event ) = 0;
    virtual bool addEvent( Event *event, const TQString &subresource ) = 0;
 
    virtual bool deleteEvent( Event * ) = 0;
 
    virtual Event *event( const TQString &uid ) = 0;
 
    virtual Event::List rawEvents( EventSortField sortField = EventSortUnsorted, SortDirection sortDirection = SortDirectionAscending ) = 0;
 
    virtual Event::List rawEventsForDate( const TQDate &date, 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 bool setValue( const TQString &key, const TQString &value );
 
  signals:
    void resourceChanged( ResourceCalendar * );
 
    void resourceLoaded( ResourceCalendar * );
    void resourceSaved( ResourceCalendar * );
 
    void resourceLoadError( ResourceCalendar *, const TQString &error );
    void resourceSaveError( ResourceCalendar *, const TQString &error );
 
    void signalSubresourceAdded( ResourceCalendar *, const TQString& type,
                                 const TQString& subresource, const TQString& label );
 
    void signalSubresourceRemoved( ResourceCalendar *, const TQString &,
                                   const TQString & );
 
  public:
    virtual TDE_DEPRECATED bool addTodo( Todo *todo ) = 0;
    virtual bool addTodo( Todo *todo,  const TQString &subresource ) = 0;
 
    virtual bool deleteTodo( Todo * ) = 0;
    virtual Todo *todo( const TQString &uid ) = 0;
    virtual Todo::List rawTodos( TodoSortField sortField = TodoSortUnsorted, SortDirection sortDirection = SortDirectionAscending ) = 0;
    virtual Todo::List rawTodosForDate( const TQDate &date ) = 0;
 
 
    virtual TDE_DEPRECATED bool addJournal( Journal * ) = 0;
    virtual bool addJournal( Journal *journal, const TQString &subresource ) = 0;
 
    virtual bool deleteJournal( Journal * ) = 0;
 
    virtual Journal *journal( const TQString &uid ) = 0;
    virtual Journal::List rawJournals( JournalSortField sortField = JournalSortUnsorted, SortDirection sortDirection = SortDirectionAscending ) = 0;
    virtual Journal::List rawJournalsForDate( const TQDate &date ) = 0;
 
    virtual Alarm::List alarms( const TQDateTime &from,
                                const TQDateTime &to ) = 0;
 
    virtual Alarm::List alarmsTo( const TQDateTime &to ) = 0;
 
 
    Incidence::List rawIncidences();
 
    virtual void setTimeZoneId( const TQString &timeZoneId ) = 0;
 
    virtual TQStringList subresources() const { return TQStringList(); }
 
    virtual bool canHaveSubresources() const { return false; }
 
    virtual bool subresourceActive( const TQString& ) const { return true; }
 
    virtual bool subresourceWritable( const TQString& ) const;
 
    virtual const TQString labelForSubresource( const TQString& resource ) const
    {
       // the resource identifier is a sane fallback
       return resource;
    };
 
    virtual TQString subresourceIdentifier( Incidence *incidence )
    { Q_UNUSED( incidence ); return TQString(); }
 
 
 
    virtual bool removeSubresource( const TQString& resource );
 
    virtual bool addSubresource( const TQString& resource, const TQString& parent );
 
    virtual TQString subresourceType( const TQString &resource );
 
    virtual void beginAddingIncidences();
 
    virtual void endAddingIncidences();
 
  public slots:
    virtual void setSubresourceActive( const TQString &, bool active );
 
  protected:
 
    bool mResolveConflict;
    virtual bool doLoad() = 0;
    virtual bool doSave() = 0;
 
    virtual bool doSave( Incidence * );
 
    virtual void addInfoText( TQString & ) const {};
 
    void loadError( const TQString &errorMessage = TQString() );
    void saveError( const TQString &errorMessage = TQString() );
 
  private:
    bool mReceivedLoadError;
    bool mReceivedSaveError;
 
    ErrorFormat *mException;
 
    class Private;
    Private *d;
};
 
typedef KRES::Manager<ResourceCalendar> CalendarResourceManager;
 
}
 
#endif