recurrence.h

/*
  This file is part of the kcalcore library.

  Copyright (c) 1998 Preston Brown <pbrown@kde.org>
  Copyright (c) 2001,2003 Cornelius Schumacher <schumacher@kde.org>
  Copyright (c) 2002,2006 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 KCALCORE_RECURRENCE_H
#define KCALCORE_RECURRENCE_H

#include "kcalcore_export.h"
#include "recurrencerule.h"

class QBitArray;

namespace KCalCore {

class RecurrenceRule;

class KCALCORE_EXPORT Recurrence : public RecurrenceRule::RuleObserver
{
public:
    class RecurrenceObserver
    {
    public:
        virtual ~RecurrenceObserver();
        virtual void recurrenceUpdated(Recurrence *r) = 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 &r);

    ~Recurrence();

    bool operator==(const Recurrence &r) const;

    bool operator!=(const Recurrence &r) const  {
        return !operator==(r);
    }

    Recurrence &operator=(const Recurrence &r);

    KDateTime startDateTime() const;
    QDate startDate() const;
    void setStartDateTime(const KDateTime &start);

    bool allDay() const;
    void setAllDay(bool allDay);

    void setRecurReadOnly(bool readOnly);

    bool recurReadOnly() const;

    bool recurs() const;

    ushort recurrenceType() const;

    static ushort recurrenceType(const RecurrenceRule *rrule);

    bool recursOn(const QDate &date, const KDateTime::Spec &timeSpec) const;

    bool recursAt(const KDateTime &dt) const;

    void unsetRecurs();

    void clear();

    TimeList recurTimesOn(const QDate &date, const KDateTime::Spec &timeSpec) const;

    DateTimeList timesInInterval(const KDateTime &start, const KDateTime &end) const;

    KDateTime getNextDateTime(const KDateTime &preDateTime) const;

    KDateTime getPreviousDateTime(const KDateTime &afterDateTime) const;

    int frequency() const;

    void setFrequency(int freq);

    int duration() const;

    void setDuration(int duration);

    int durationTo(const KDateTime &dt) const;

    int durationTo(const QDate &date) const;

    KDateTime endDateTime() const;

    QDate endDate() const;

    void setEndDate(const QDate &endDate);

    void setEndDateTime(const KDateTime &endDateTime);

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

    void setMinutely(int freq);

    void setHourly(int freq);

    void setDaily(int freq);

    void setWeekly(int freq, int weekStart = 1);
    void setWeekly(int freq, const QBitArray &days, int weekStart = 1);

    void addWeeklyDays(const QBitArray &days);
    int weekStart() const;

    QBitArray days() const; // Emulate the old behavior

    void setMonthly(int freq);

    void addMonthlyPos(short pos, const QBitArray &days);
    void addMonthlyPos(short pos, ushort day);

    void addMonthlyDate(short day);

    QList<RecurrenceRule::WDayPos> monthPositions() const;

    // Emulate old behavior
    QList<int> monthDays() const;

    void setYearly(int freq);

    void addYearlyDay(int day);

    void addYearlyDate(int date);

    void addYearlyMonth(short _rNum);

    void addYearlyPos(short pos, const QBitArray &days);

    QList<int> yearDays() const;

    QList<int> yearDates() const;

    QList<int> yearMonths() const;

    QList<RecurrenceRule::WDayPos> yearPositions() const;

    static const QDate MAX_DATE;

    void dump() const;

    // RRULE
    RecurrenceRule::List rRules() const;
    void addRRule(RecurrenceRule *rrule);

    void removeRRule(RecurrenceRule *rrule);

    void deleteRRule(RecurrenceRule *rrule);

    // EXRULE
    RecurrenceRule::List exRules() const;

    void addExRule(RecurrenceRule *exrule);

    void removeExRule(RecurrenceRule *exrule);

    void deleteExRule(RecurrenceRule *exrule);

    // RDATE
    DateTimeList rDateTimes() const;
    DateList rDates() const;
    void setRDateTimes(const DateTimeList &rdates);
    void setRDates(const DateList &rdates);
    void addRDateTime(const KDateTime &rdate);
    void addRDate(const QDate &rdate);

    // ExDATE
    DateTimeList exDateTimes() const;
    DateList exDates() const;
    void setExDateTimes(const DateTimeList &exdates);
    void setExDates(const DateList &exdates);
    void addExDateTime(const KDateTime &exdate);
    void addExDate(const QDate &exdate);

    RecurrenceRule *defaultRRule(bool create = false) const;
    RecurrenceRule *defaultRRuleConst() const;
    void updated();

    void addObserver(RecurrenceObserver *observer);
    void removeObserver(RecurrenceObserver *observer);

    void recurrenceChanged(RecurrenceRule *);

protected:
    RecurrenceRule *setNewRecurrenceType(RecurrenceRule::PeriodType type, int freq);

private:
    //@cond PRIVATE
    class Private;
    Private *const d;
    //@endcond

    friend KCALCORE_EXPORT QDataStream& operator<<(QDataStream &out, KCalCore::Recurrence *);
    friend KCALCORE_EXPORT QDataStream& operator>>(QDataStream &in, KCalCore::Recurrence *);
};

KCALCORE_EXPORT QDataStream& operator<<(QDataStream &out, KCalCore::Recurrence *);
KCALCORE_EXPORT QDataStream& operator>>(QDataStream &in, KCalCore::Recurrence *);

}

#endif