calendarresources.h

Go to the documentation of this file.

/*
    This file is part of libkcal.
 
    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 <tqintdict.h>
#include <tqmap.h>
 
#include "calendar.h"
#include "resourcecalendar.h"
 
#include "libkcal_export.h"
 
#include <tderesources/manager.h>
 
class TQWidget;

namespace KCal {
 
class CalFormat;

class LIBKCAL_EXPORT CalendarResources :
      public Calendar,
      public KRES::ManagerObserver<ResourceCalendar>
{
  TQ_OBJECT
  
  public:
    class DestinationPolicy
    {
      public:
        DestinationPolicy( CalendarResourceManager *manager,
                              TQWidget *parent = 0  ) :
          mManager( manager ), mParent( parent ) {}
        virtual ~DestinationPolicy() {}
 
        virtual ResourceCalendar *destination( Incidence *incidence ) = 0;
        virtual TQWidget *parent() { return mParent; }
        virtual void setParent( TQWidget *newparent ) { mParent = newparent; }
        bool hasCalendarResources();
      protected:
        CalendarResourceManager *resourceManager()
         { return mManager; }
 
      private:
        CalendarResourceManager *mManager;
        TQWidget *mParent;
    };

    class StandardDestinationPolicy : public DestinationPolicy
    {
      public:
        StandardDestinationPolicy( CalendarResourceManager *manager,
                              TQWidget *parent = 0  ) :
          DestinationPolicy( manager, parent ) {}
        virtual ~StandardDestinationPolicy() {}
 
        ResourceCalendar *destination( Incidence *incidence );
 
      private:
        class Private;
        Private *d;
    };

    class AskDestinationPolicy : public DestinationPolicy
    {
      public:
        AskDestinationPolicy( CalendarResourceManager *manager,
                              TQWidget *parent = 0 ) :
          DestinationPolicy( manager, parent ) {}
        virtual ~AskDestinationPolicy() {}
 
        ResourceCalendar *destination( Incidence *incidence );
 
      private:
        class Private;
        Private *d;
    };

    class Ticket
    {
        friend class CalendarResources;
      public:
        ResourceCalendar *resource() const
          { return mResource; }
 
      private:
        Ticket( ResourceCalendar *r ) : mResource( r ) {}
 
        ResourceCalendar *mResource;
 
        class Private;
        Private *d;
    };

    CalendarResources(
      const TQString &timeZoneId,
      const TQString &family = TQString::fromLatin1( "calendar" ) );

    ~CalendarResources();

    void load();

    bool reload( const TQString &tz );

    void close();

    void closeEvents();

    void closeTodos();

    void closeJournals();

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

    void save();

    bool isSaving();

    CalendarResourceManager *resourceManager() const
      { return mManager; }

    ResourceCalendar *resource( Incidence *incidence );

    void readConfig( TDEConfig *config = 0 );

    void setStandardDestinationPolicy();

    void setAskDestinationPolicy();

    TQWidget *dialogParentWidget();
    void setDialogParentWidget( TQWidget *parent );

    Ticket *requestSaveTicket( ResourceCalendar *resource );

    virtual void releaseSaveTicket( Ticket *ticket );

    void resourceAdded( ResourceCalendar *resource );
 
// Incidence Specific Methods //

    bool addIncidence( Incidence *incidence );

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

    bool addIncidence( Incidence *incidence,
                       ResourceCalendar *resource, const TQString &subresource );

    TDE_DEPRECATED bool beginChange( Incidence *incidence );

    bool beginChange( Incidence *incidence, ResourceCalendar *resource, const TQString &subresource );

    TDE_DEPRECATED bool endChange( Incidence *incidence );

    bool endChange( Incidence *incidence,
                    ResourceCalendar *resource, const TQString &subresource );
 
// Event Specific Methods //

    bool addEvent( Event *event );

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

    bool addEvent( Event *event, ResourceCalendar *resource, const TQString &subresource );

    bool deleteEvent( Event *event );

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

    Event::List rawEventsForDate( const TQDateTime &qdt );

    Event::List rawEvents( const TQDate &start, const TQDate &end,
                           bool inclusive = false );

    Event::List rawEventsForDate(
      const TQDate &date,
      EventSortField sortField = EventSortUnsorted,
      SortDirection sortDirection = SortDirectionAscending );

    Event *event( const TQString &uid );
 
// Todo Specific Methods //

    bool addTodo( Todo *todo );

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

    bool addTodo( Todo *todo, ResourceCalendar *resource, const TQString &subresource );

    bool deleteTodo( Todo *todo );

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

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

    Todo *todo( const TQString &uid );
 
// Journal Specific Methods //

    bool addJournal( Journal *journal );

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

    bool addJournal( Journal *journal, ResourceCalendar *resource, const TQString &subresource );

    bool deleteJournal( Journal *journal );

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

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

    Journal *journal( const TQString &uid );
 
// Alarm Specific Methods //

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

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

    void setTimeZoneIdViewOnly( const TQString& tz );
 
  //issue 2508
    bool hasCalendarResources();
  signals:
    void signalResourceModified( ResourceCalendar *resource );

    void signalResourceAdded( ResourceCalendar *resource );

    void signalResourceDeleted( ResourceCalendar *resource );

    void signalErrorMessage( const TQString &err );
 
  protected:
    void connectResource( ResourceCalendar *resource );
    void resourceModified( ResourceCalendar *resource );
    void resourceDeleted( ResourceCalendar *resource );

    virtual void doSetTimeZoneId( const TQString &timeZoneId );

    int incrementChangeCount( ResourceCalendar *resource );

    int decrementChangeCount( ResourceCalendar *resource );
 
  protected slots:
    void slotLoadError( ResourceCalendar *resource, const TQString &err );
    void slotSaveError( ResourceCalendar *resource, const TQString &err );

    void beginAddingIncidences();

    void endAddingIncidences();
 
  private:

    void init( const TQString &family );
 
    bool mOpen;
 
    KRES::Manager<ResourceCalendar>* mManager;
    TQMap <Incidence*, ResourceCalendar*> mResourceMap;
 
    DestinationPolicy *mDestinationPolicy;
    StandardDestinationPolicy *mStandardPolicy;
    AskDestinationPolicy *mAskPolicy;
    bool mPendingDeleteFromResourceMap;
 
    TQMap<ResourceCalendar *, Ticket *> mTickets;
    TQMap<ResourceCalendar *, int> mChangeCounts;
 
    class Private;
    Private *d;
};
 
}
 
#endif