recurrence.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 David Jarvie <software@astrojar.org.uk>
    Copyright (C) 2005 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_RECURRENCE_H
#define KCAL_RECURRENCE_H
 
#include <tqstring.h>
#include <tqbitarray.h>
#include <tqptrlist.h>
 
#include "libkcal_export.h"
#include "recurrencerule.h"
 
namespace KCal {
 
class RecurrenceRule;
 
class LIBKCAL_EXPORT Recurrence : public RecurrenceRule::Observer
{
  public:
    class Observer {
      public:
        virtual ~Observer() {}
        virtual void recurrenceUpdated( Recurrence * ) = 0;
    };
 
    enum { rNone = 0, rMinutely = 0x001, rHourly = 0x0002, rDaily = 0x0003,
           rWeekly = 0x0004, rMonthlyPos = 0x0005, rMonthlyDay = 0x0006,
           rYearlyMonth = 0x0007, rYearlyDay = 0x0008, rYearlyPos = 0x0009,
           rOther = 0x000A, rMax=0x00FF };
 
    Recurrence();
    Recurrence( const Recurrence& );
    virtual ~Recurrence();
 
    bool operator==( const Recurrence& ) const;
    bool operator!=( const Recurrence& r ) const  { return !operator==(r); }
 
    TQDateTime startDateTime() const;
    TQDate startDate() const   { return mStartDateTime.date(); }
    void setStartDateTime( const TQDateTime &start );
    void setStartDate( const TQDate &start );
 
    bool doesFloat() const { return mFloating; }
    void setFloats( bool floats );
 
    void setRecurReadOnly(bool readOnly) { mRecurReadOnly = readOnly; }
    bool recurReadOnly() const  { return mRecurReadOnly; }
 
    bool doesRecur() const;
    ushort recurrenceType() const;
    static ushort recurrenceType( const RecurrenceRule *rrule );
    bool recursOn( const TQDate &qd ) const;
    bool recursAt( const TQDateTime & ) const;
    void unsetRecurs();
    void clear();
 
    TQValueList<TQTime> recurTimesOn(const TQDate &date) const;
 
    DateTimeList timesInInterval( const TQDateTime &start, const TQDateTime &end ) const;
 
 
    TQDateTime getNextDateTime( const TQDateTime& preDateTime ) const;
    TQDateTime getPreviousDateTime( const TQDateTime& afterDateTime ) const;
 
    int frequency() const;
    void setFrequency(int freq);
 
    int duration() const;
    void setDuration(int duration);
    int durationTo(const TQDateTime &) const;
    int durationTo( const TQDate &date ) const { return durationTo( TQDateTime( date, TQTime( 23, 59, 59 ) ) ); }
 
    TQDateTime endDateTime() const;
    TQDate endDate() const;
    void setEndDate( const TQDate &endDate );
    void setEndDateTime( const TQDateTime &endDateTime );
 
 
 
    void setMinutely( int freq );
 
    void setHourly( int freq );
 
    void setDaily( int freq );
 
    void setWeekly( int freq, int weekStart = 1 );
    void setWeekly( int freq, const TQBitArray &days, int weekStart = 1 );
    void addWeeklyDays( const TQBitArray &days );
    int weekStart() const;
    TQBitArray days() const; // Emulate the old behavior
 
    void setMonthly( int freq );
    void addMonthlyPos( short pos, const TQBitArray &days );
    void addMonthlyPos( short pos, ushort day );
    void addMonthlyDate( short day );
    TQValueList<RecurrenceRule::WDayPos> monthPositions() const;
    // Emulate old behavior
    TQValueList<int> monthDays() const;
 
    void setYearly( int freq );
    void addYearlyDay( int day );
    void addYearlyDate( int date );
    void addYearlyMonth( short _rNum );
    void addYearlyPos( short pos, const TQBitArray &days );
 
    TQValueList<int> yearDays() const;
    TQValueList<int> yearDates() const;
    TQValueList<int> yearMonths() const;
    TQValueList<RecurrenceRule::WDayPos> yearPositions() const;
 
    static const TQDate MAX_DATE;
 
    void dump() const;
 
 
    // RRULE
    RecurrenceRule::List rRules() const;
    void addRRule( RecurrenceRule *rrule );
    void removeRRule( RecurrenceRule *rrule );
    // EXRULE
    RecurrenceRule::List exRules() const;
    void addExRule( RecurrenceRule *exrule );
    void removeExRule( RecurrenceRule *exrule );
 
    // RDATE
    DateTimeList rDateTimes() const;
    DateList rDates() const;
    void setRDateTimes( const DateTimeList &rdates);
    void setRDates( const DateList &rdates);
    void addRDateTime( const TQDateTime &rdate );
    void addRDate( const TQDate &rdate );
 
    // ExDATE
    DateTimeList exDateTimes() const;
    DateList exDates() const;
    void setExDateTimes( const DateTimeList &exdates);
    void setExDates( const DateList &exdates);
    void addExDateTime( const TQDateTime &exdate );
    void addExDate( const TQDate &exdate );
 
    RecurrenceRule *defaultRRule( bool create = false ) const;
    RecurrenceRule *defaultRRuleConst() const;
    void updated();
 
    void addObserver( Observer *observer );
    void removeObserver( Observer *observer );
 
    void recurrenceChanged( RecurrenceRule * );
 
  protected:
    RecurrenceRule *setNewRecurrenceType( RecurrenceRule::PeriodType type, int freq );
 
  private:
    RecurrenceRule::List mExRules;
    RecurrenceRule::List mRRules;
    TQValueList<TQDateTime>mRDateTimes;
    TQValueList<TQDate> mRDates;
    TQValueList<TQDateTime> mExDateTimes;
    TQValueList<TQDate> mExDates;
 
    TQDateTime mStartDateTime;            // date/time of first recurrence
    bool mFloating;                      // the recurrence has no time, just a date
    bool mRecurReadOnly;
 
    // Cache the type of the recurrence with the old system (e.g. MonthlyPos)
    mutable ushort mCachedType;
 
    TQValueList<Observer*> mObservers;
 
    class Private;
    Private *d;
};
 
}
 
#endif