diff options
Diffstat (limited to 'kalarm/karecurrence.cpp')
-rw-r--r-- | kalarm/karecurrence.cpp | 876 |
1 files changed, 876 insertions, 0 deletions
diff --git a/kalarm/karecurrence.cpp b/kalarm/karecurrence.cpp new file mode 100644 index 000000000..9461d71ec --- /dev/null +++ b/kalarm/karecurrence.cpp @@ -0,0 +1,876 @@ +/* + * karecurrence.cpp - recurrence with special yearly February 29th handling + * Program: kalarm + * Copyright © 2005,2006,2008 by David Jarvie <djarvie@kde.org> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#include "kalarm.h" + +#include <qbitarray.h> +#include <kdebug.h> + +#include <libkcal/icalformat.h> + +#include "datetime.h" +#include "functions.h" +#include "karecurrence.h" + +using namespace KCal; + +/*============================================================================= += Class KARecurrence += The purpose of this class is to represent the restricted range of recurrence += types which are handled by KAlarm, and to translate between these and the += libkcal Recurrence class. In particular, it handles yearly recurrences on += 29th February specially: += += KARecurrence allows annual 29th February recurrences to fall on 28th += February or 1st March, or not at all, in non-leap years. It allows such += 29th February recurrences to be combined with the 29th of other months in += a simple way, represented simply as the 29th of multiple months including += February. For storage in the libkcal calendar, the 29th day of the month += recurrence for other months is combined with a last-day-of-February or a += 60th-day-of-the-year recurrence rule, thereby conforming to RFC2445. +=============================================================================*/ + + +KARecurrence::Feb29Type KARecurrence::mDefaultFeb29 = KARecurrence::FEB29_FEB29; + + +/****************************************************************************** +* Set up a KARecurrence from recurrence parameters, using the start date to +* determine the recurrence day/month as appropriate. +* Only a restricted subset of recurrence types is allowed. +* Reply = true if successful. +*/ +bool KARecurrence::set(Type recurType, int freq, int count, int f29, const DateTime& start, const QDateTime& end) +{ + mCachedType = -1; + RecurrenceRule::PeriodType rrtype; + switch (recurType) + { + case MINUTELY: rrtype = RecurrenceRule::rMinutely; break; + case DAILY: rrtype = RecurrenceRule::rDaily; break; + case WEEKLY: rrtype = RecurrenceRule::rWeekly; break; + case MONTHLY_DAY: rrtype = RecurrenceRule::rMonthly; break; + case ANNUAL_DATE: rrtype = RecurrenceRule::rYearly; break; + case NO_RECUR: rrtype = RecurrenceRule::rNone; break; + default: + return false; + } + if (!init(rrtype, freq, count, f29, start, end)) + return false; + switch (recurType) + { + case WEEKLY: + { + QBitArray days(7); + days.setBit(start.date().dayOfWeek() - 1); + addWeeklyDays(days); + break; + } + case MONTHLY_DAY: + addMonthlyDate(start.date().day()); + break; + case ANNUAL_DATE: + addYearlyDate(start.date().day()); + addYearlyMonth(start.date().month()); + break; + default: + break; + } + return true; +} + +/****************************************************************************** +* Initialise a KARecurrence from recurrence parameters. +* Reply = true if successful. +*/ +bool KARecurrence::init(RecurrenceRule::PeriodType recurType, int freq, int count, int f29, const DateTime& start, + const QDateTime& end) +{ + mCachedType = -1; + Feb29Type feb29Type = (f29 == -1) ? mDefaultFeb29 : static_cast<Feb29Type>(f29); + mFeb29Type = FEB29_FEB29; + clear(); + if (count < -1) + return false; + bool dateOnly = start.isDateOnly(); + if (!count && (!dateOnly && !end.isValid() + || dateOnly && !end.date().isValid())) + return false; + switch (recurType) + { + case RecurrenceRule::rMinutely: + case RecurrenceRule::rDaily: + case RecurrenceRule::rWeekly: + case RecurrenceRule::rMonthly: + case RecurrenceRule::rYearly: + break; + case rNone: + return true; + default: + return false; + } + setNewRecurrenceType(recurType, freq); + if (count) + setDuration(count); + else if (dateOnly) + setEndDate(end.date()); + else + setEndDateTime(end); + QDateTime startdt = start.dateTime(); + if (recurType == RecurrenceRule::rYearly + && feb29Type == FEB29_FEB28 || feb29Type == FEB29_MAR1) + { + int year = startdt.date().year(); + if (!QDate::leapYear(year) + && startdt.date().dayOfYear() == (feb29Type == FEB29_MAR1 ? 60 : 59)) + { + /* The event start date is February 28th or March 1st, but it + * is a recurrence on February 29th (recurring on February 28th + * or March 1st in non-leap years). Adjust the start date to + * be on February 29th in the last previous leap year. + * This is necessary because KARecurrence represents all types + * of 29th February recurrences by a simple 29th February. + */ + while (!QDate::leapYear(--year)) ; + startdt.setDate(QDate(year, 2, 29)); + } + mFeb29Type = feb29Type; + } + if (dateOnly) + setStartDate(startdt.date()); + else + setStartDateTime(startdt); + return true; +} + +/****************************************************************************** + * Initialise the recurrence from an iCalendar RRULE string. + */ +bool KARecurrence::set(const QString& icalRRULE) +{ + static QString RRULE = QString::fromLatin1("RRULE:"); + mCachedType = -1; + clear(); + if (icalRRULE.isEmpty()) + return true; + ICalFormat format; + if (!format.fromString(defaultRRule(true), + (icalRRULE.startsWith(RRULE) ? icalRRULE.mid(RRULE.length()) : icalRRULE))) + return false; + fix(); + return true; +} + +/****************************************************************************** +* Must be called after presetting with a KCal::Recurrence, to convert the +* recurrence to KARecurrence types: +* - Convert hourly recurrences to minutely. +* - Remove all but the first day in yearly date recurrences. +* - Check for yearly recurrences falling on February 29th and adjust them as +* necessary. A 29th of the month rule can be combined with either a 60th day +* of the year rule or a last day of February rule. +*/ +void KARecurrence::fix() +{ + mCachedType = -1; + mFeb29Type = FEB29_FEB29; + int convert = 0; + int days[2] = { 0, 0 }; + RecurrenceRule* rrules[2]; + RecurrenceRule::List rrulelist = rRules(); + RecurrenceRule::List::ConstIterator rr = rrulelist.begin(); + for (int i = 0; i < 2 && rr != rrulelist.end(); ++i, ++rr) + { + RecurrenceRule* rrule = *rr; + rrules[i] = rrule; + bool stop = true; + int rtype = recurrenceType(rrule); + switch (rtype) + { + case rHourly: + // Convert an hourly recurrence to a minutely one + rrule->setRecurrenceType(RecurrenceRule::rMinutely); + rrule->setFrequency(rrule->frequency() * 60); + // fall through to rMinutely + case rMinutely: + case rDaily: + case rWeekly: + case rMonthlyDay: + case rMonthlyPos: + case rYearlyPos: + if (!convert) + ++rr; // remove all rules except the first + break; + case rOther: + if (dailyType(rrule)) + { // it's a daily rule with BYDAYS + if (!convert) + ++rr; // remove all rules except the first + } + break; + case rYearlyDay: + { + // Ensure that the yearly day number is 60 (i.e. Feb 29th/Mar 1st) + if (convert) + { + // This is the second rule. + // Ensure that it can be combined with the first one. + if (days[0] != 29 + || rrule->frequency() != rrules[0]->frequency() + || rrule->startDt() != rrules[0]->startDt()) + break; + } + QValueList<int> ds = rrule->byYearDays(); + if (!ds.isEmpty() && ds.first() == 60) + { + ++convert; // this rule needs to be converted + days[i] = 60; + stop = false; + break; + } + break; // not day 60, so remove this rule + } + case rYearlyMonth: + { + QValueList<int> ds = rrule->byMonthDays(); + if (!ds.isEmpty()) + { + int day = ds.first(); + if (convert) + { + // This is the second rule. + // Ensure that it can be combined with the first one. + if (day == days[0] || day == -1 && days[0] == 60 + || rrule->frequency() != rrules[0]->frequency() + || rrule->startDt() != rrules[0]->startDt()) + break; + } + if (ds.count() > 1) + { + ds.clear(); // remove all but the first day + ds.append(day); + rrule->setByMonthDays(ds); + } + if (day == -1) + { + // Last day of the month - only combine if it's February + QValueList<int> months = rrule->byMonths(); + if (months.count() != 1 || months.first() != 2) + day = 0; + } + if (day == 29 || day == -1) + { + ++convert; // this rule may need to be converted + days[i] = day; + stop = false; + break; + } + } + if (!convert) + ++rr; + break; + } + default: + break; + } + if (stop) + break; + } + + // Remove surplus rules + for ( ; rr != rrulelist.end(); ++rr) + { + removeRRule(*rr); + delete *rr; + } + + QDate end; + int count; + QValueList<int> months; + if (convert == 2) + { + // There are two yearly recurrence rules to combine into a February 29th recurrence. + // Combine the two recurrence rules into a single rYearlyMonth rule falling on Feb 29th. + // Find the duration of the two RRULEs combined, using the shorter of the two if they differ. + if (days[0] != 29) + { + // Swap the two rules so that the 29th rule is the first + RecurrenceRule* rr = rrules[0]; + rrules[0] = rrules[1]; // the 29th rule + rrules[1] = rr; + int d = days[0]; + days[0] = days[1]; + days[1] = d; // the non-29th day + } + // If February is included in the 29th rule, remove it to avoid duplication + months = rrules[0]->byMonths(); + if (months.remove(2)) + rrules[0]->setByMonths(months); + + count = combineDurations(rrules[0], rrules[1], end); + mFeb29Type = (days[1] == 60) ? FEB29_MAR1 : FEB29_FEB28; + } + else if (convert == 1 && days[0] == 60) + { + // There is a single 60th day of the year rule. + // Convert it to a February 29th recurrence. + count = duration(); + if (!count) + end = endDate(); + mFeb29Type = FEB29_MAR1; + } + else + return; + + // Create the new February 29th recurrence + setNewRecurrenceType(RecurrenceRule::rYearly, frequency()); + RecurrenceRule* rrule = defaultRRule(); + months.append(2); + rrule->setByMonths(months); + QValueList<int> ds; + ds.append(29); + rrule->setByMonthDays(ds); + if (count) + setDuration(count); + else + setEndDate(end); +} + +/****************************************************************************** +* Get the next time the recurrence occurs, strictly after a specified time. +*/ +QDateTime KARecurrence::getNextDateTime(const QDateTime& preDateTime) const +{ + switch (type()) + { + case ANNUAL_DATE: + case ANNUAL_POS: + { + Recurrence recur; + writeRecurrence(recur); + return recur.getNextDateTime(preDateTime); + } + default: + return Recurrence::getNextDateTime(preDateTime); + } +} + +/****************************************************************************** +* Get the previous time the recurrence occurred, strictly before a specified time. +*/ +QDateTime KARecurrence::getPreviousDateTime(const QDateTime& afterDateTime) const +{ + switch (type()) + { + case ANNUAL_DATE: + case ANNUAL_POS: + { + Recurrence recur; + writeRecurrence(recur); + return recur.getPreviousDateTime(afterDateTime); + } + default: + return Recurrence::getPreviousDateTime(afterDateTime); + } +} + +/****************************************************************************** +* Initialise a KCal::Recurrence to be the same as this instance. +* Additional recurrence rules are created as necessary if it recurs on Feb 29th. +*/ +void KARecurrence::writeRecurrence(KCal::Recurrence& recur) const +{ + recur.clear(); + recur.setStartDateTime(startDateTime()); + recur.setExDates(exDates()); + recur.setExDateTimes(exDateTimes()); + const RecurrenceRule* rrule = defaultRRuleConst(); + if (!rrule) + return; + int freq = frequency(); + int count = duration(); + static_cast<KARecurrence*>(&recur)->setNewRecurrenceType(rrule->recurrenceType(), freq); + if (count) + recur.setDuration(count); + else + recur.setEndDateTime(endDateTime()); + switch (type()) + { + case DAILY: + if (rrule->byDays().isEmpty()) + break; + // fall through to rWeekly + case WEEKLY: + case MONTHLY_POS: + recur.defaultRRule(true)->setByDays(rrule->byDays()); + break; + case MONTHLY_DAY: + recur.defaultRRule(true)->setByMonthDays(rrule->byMonthDays()); + break; + case ANNUAL_POS: + recur.defaultRRule(true)->setByMonths(rrule->byMonths()); + recur.defaultRRule()->setByDays(rrule->byDays()); + break; + case ANNUAL_DATE: + { + QValueList<int> months = rrule->byMonths(); + QValueList<int> days = monthDays(); + bool special = (mFeb29Type != FEB29_FEB29 && !days.isEmpty() + && days.first() == 29 && months.remove(2)); + RecurrenceRule* rrule1 = recur.defaultRRule(); + rrule1->setByMonths(months); + rrule1->setByMonthDays(days); + if (!special) + break; + + // It recurs on the 29th February. + // Create an additional 60th day of the year, or last day of February, rule. + RecurrenceRule* rrule2 = new RecurrenceRule(); + rrule2->setRecurrenceType(RecurrenceRule::rYearly); + rrule2->setFrequency(freq); + rrule2->setStartDt(startDateTime()); + rrule2->setFloats(doesFloat()); + if (!count) + rrule2->setEndDt(endDateTime()); + if (mFeb29Type == FEB29_MAR1) + { + QValueList<int> ds; + ds.append(60); + rrule2->setByYearDays(ds); + } + else + { + QValueList<int> ds; + ds.append(-1); + rrule2->setByMonthDays(ds); + QValueList<int> ms; + ms.append(2); + rrule2->setByMonths(ms); + } + + if (months.isEmpty()) + { + // Only February recurs. + // Replace the RRULE and keep the recurrence count the same. + if (count) + rrule2->setDuration(count); + recur.unsetRecurs(); + } + else + { + // Months other than February also recur on the 29th. + // Remove February from the list and add a separate RRULE for February. + if (count) + { + rrule1->setDuration(-1); + rrule2->setDuration(-1); + if (count > 0) + { + /* Adjust counts in the two rules to keep the correct occurrence total. + * Note that durationTo() always includes the start date. Since for an + * individual RRULE the start date may not actually be included, we need + * to decrement the count if the start date doesn't actually recur in + * this RRULE. + * Note that if the count is small, one of the rules may not recur at + * all. In that case, retain it so that the February 29th characteristic + * is not lost should the user later change the recurrence count. + */ + QDateTime end = endDateTime(); +kdDebug()<<"29th recurrence: count="<<count<<", end date="<<end.toString()<<endl; + int count1 = rrule1->durationTo(end) + - (rrule1->recursOn(startDate()) ? 0 : 1); + if (count1 > 0) + rrule1->setDuration(count1); + else + rrule1->setEndDt(startDateTime()); + int count2 = rrule2->durationTo(end) + - (rrule2->recursOn(startDate()) ? 0 : 1); + if (count2 > 0) + rrule2->setDuration(count2); + else + rrule2->setEndDt(startDateTime()); + } + } + } + recur.addRRule(rrule2); + break; + } + default: + break; + } +} + +/****************************************************************************** +* Return the date/time of the last recurrence. +*/ +QDateTime KARecurrence::endDateTime() const +{ + if (mFeb29Type == FEB29_FEB29 || duration() <= 1) + { + /* Either it doesn't have any special February 29th treatment, + * it's infinite (count = -1), the end date is specified + * (count = 0), or it ends on the start date (count = 1). + * So just use the normal KCal end date calculation. + */ + return Recurrence::endDateTime(); + } + + /* Create a temporary recurrence rule to find the end date. + * In a standard KCal recurrence, the 29th February only occurs once every + * 4 years. So shift the temporary recurrence date to the 28th to ensure + * that it occurs every year, thus giving the correct occurrence count. + */ + RecurrenceRule* rrule = new RecurrenceRule(); + rrule->setRecurrenceType(RecurrenceRule::rYearly); + QDateTime dt = startDateTime(); + QDate d = dt.date(); + switch (d.day()) + { + case 29: + // The start date is definitely a recurrence date, so shift + // start date to the temporary recurrence date of the 28th + d.setYMD(d.year(), d.month(), 28); + break; + case 28: + if (d.month() != 2 || mFeb29Type != FEB29_FEB28 || QDate::leapYear(d.year())) + { + // Start date is not a recurrence date, so shift it to 27th + d.setYMD(d.year(), d.month(), 27); + } + break; + case 1: + if (d.month() == 3 && mFeb29Type == FEB29_MAR1 && !QDate::leapYear(d.year())) + { + // Start date is a March 1st recurrence date, so shift + // start date to the temporary recurrence date of the 28th + d.setYMD(d.year(), 2, 28); + } + break; + default: + break; + } + dt.setDate(d); + rrule->setStartDt(dt); + rrule->setFloats(doesFloat()); + rrule->setFrequency(frequency()); + rrule->setDuration(duration()); + QValueList<int> ds; + ds.append(28); + rrule->setByMonthDays(ds); + rrule->setByMonths(defaultRRuleConst()->byMonths()); + dt = rrule->endDt(); + delete rrule; + + // We've found the end date for a recurrence on the 28th. Unless that date + // is a real February 28th recurrence, adjust to the actual recurrence date. + if (mFeb29Type == FEB29_FEB28 && dt.date().month() == 2 && !QDate::leapYear(dt.date().year())) + return dt; + return dt.addDays(1); +} + +/****************************************************************************** +* Return the date/time of the last recurrence. +*/ +QDate KARecurrence::endDate() const +{ + QDateTime end = endDateTime(); + return end.isValid() ? end.date() : QDate(); +} + +/****************************************************************************** +* Return whether the event will recur on the specified date. +* The start date only returns true if it matches the recurrence rules. +*/ +bool KARecurrence::recursOn(const QDate& dt) const +{ + if (!Recurrence::recursOn(dt)) + return false; + if (dt != startDate()) + return true; + // We know now that it isn't in EXDATES or EXRULES, + // so we just need to check if it's in RDATES or RRULES + if (rDates().contains(dt)) + return true; + RecurrenceRule::List rulelist = rRules(); + for (RecurrenceRule::List::ConstIterator rr = rulelist.begin(); rr != rulelist.end(); ++rr) + if ((*rr)->recursOn(dt)) + return true; + DateTimeList dtlist = rDateTimes(); + for (DateTimeList::ConstIterator rdt = dtlist.begin(); rdt != dtlist.end(); ++rdt) + if ((*rdt).date() == dt) + return true; + return false; +} + +/****************************************************************************** +* Find the duration of two RRULEs combined. +* Use the shorter of the two if they differ. +*/ +int KARecurrence::combineDurations(const RecurrenceRule* rrule1, const RecurrenceRule* rrule2, QDate& end) const +{ + int count1 = rrule1->duration(); + int count2 = rrule2->duration(); + if (count1 == -1 && count2 == -1) + return -1; + + // One of the RRULEs may not recur at all if the recurrence count is small. + // In this case, its end date will have been set to the start date. + if (count1 && !count2 && rrule2->endDt().date() == startDateTime().date()) + return count1; + if (count2 && !count1 && rrule1->endDt().date() == startDateTime().date()) + return count2; + + /* The duration counts will be different even for RRULEs of the same length, + * because the first RRULE only actually occurs every 4 years. So we need to + * compare the end dates. + */ + if (!count1 || !count2) + count1 = count2 = 0; + // Get the two rules sorted by end date. + QDateTime end1 = rrule1->endDt(); + QDateTime end2 = rrule2->endDt(); + if (end1.date() == end2.date()) + { + end = end1.date(); + return count1 + count2; + } + const RecurrenceRule* rr1; // earlier end date + const RecurrenceRule* rr2; // later end date + if (end2.isValid() + && (!end1.isValid() || end1.date() > end2.date())) + { + // Swap the two rules to make rr1 have the earlier end date + rr1 = rrule2; + rr2 = rrule1; + QDateTime e = end1; + end1 = end2; + end2 = e; + } + else + { + rr1 = rrule1; + rr2 = rrule2; + } + + // Get the date of the next occurrence after the end of the earlier ending rule + RecurrenceRule rr(*rr1); + rr.setDuration(-1); + QDateTime next1(rr.getNextDate(end1).date()); + if (!next1.isValid()) + end = end1.date(); + else + { + if (end2.isValid() && next1 > end2) + { + // The next occurrence after the end of the earlier ending rule + // is later than the end of the later ending rule. So simply use + // the end date of the later rule. + end = end2.date(); + return count1 + count2; + } + QDate prev2 = rr2->getPreviousDate(next1).date(); + end = (prev2 > end1.date()) ? prev2 : end1.date(); + } + if (count2) + count2 = rr2->durationTo(end); + return count1 + count2; +} + +/****************************************************************************** + * Return the longest interval (in minutes) between recurrences. + * Reply = 0 if it never recurs. + */ +int KARecurrence::longestInterval() const +{ + int freq = frequency(); + switch (type()) + { + case MINUTELY: + return freq; + + case DAILY: + { + QValueList<RecurrenceRule::WDayPos> days = defaultRRuleConst()->byDays(); + if (days.isEmpty()) + return freq * 1440; + + // It recurs only on certain days of the week, so the maximum interval + // may be greater than the frequency. + bool ds[7] = { false, false, false, false, false, false, false }; + for (QValueList<RecurrenceRule::WDayPos>::ConstIterator it = days.begin(); it != days.end(); ++it) + if ((*it).pos() == 0) + ds[(*it).day() - 1] = true; + if (freq % 7) + { + // It will recur on every day of the week in some week or other + // (except for those days which are excluded). + int first = -1; + int last = -1; + int maxgap = 1; + for (int i = 0; i < freq*7; i += freq) + { + if (ds[i % 7]) + { + if (first < 0) + first = i; + else if (i - last > maxgap) + maxgap = i - last; + last = i; + } + } + int wrap = freq*7 - last + first; + if (wrap > maxgap) + maxgap = wrap; + return maxgap * 1440; + } + else + { + // It will recur on the same day of the week every time. + // Ensure that the day is a day which is not excluded. + return ds[startDate().dayOfWeek() - 1] ? freq * 1440 : 0; + } + } + case WEEKLY: + { + // Find which days of the week it recurs on, and if on more than + // one, reduce the maximum interval accordingly. + QBitArray ds = days(); + int first = -1; + int last = -1; + int maxgap = 1; + for (int i = 0; i < 7; ++i) + { + if (ds.testBit(KAlarm::localeDayInWeek_to_weekDay(i) - 1)) + { + if (first < 0) + first = i; + else if (i - last > maxgap) + maxgap = i - last; + last = i; + } + } + if (first < 0) + break; // no days recur + int span = last - first; + if (freq > 1) + return (freq*7 - span) * 1440; + if (7 - span > maxgap) + return (7 - span) * 1440; + return maxgap * 1440; + } + case MONTHLY_DAY: + case MONTHLY_POS: + return freq * 1440 * 31; + + case ANNUAL_DATE: + case ANNUAL_POS: + { + // Find which months of the year it recurs on, and if on more than + // one, reduce the maximum interval accordingly. + const QValueList<int> months = yearMonths(); // month list is sorted + if (months.isEmpty()) + break; // no months recur + if (months.count() == 1) + return freq * 1440 * 365; + int first = -1; + int last = -1; + int maxgap = 0; + for (QValueListConstIterator<int> it = months.begin(); it != months.end(); ++it) + { + if (first < 0) + first = *it; + else + { + int span = QDate(2001, last, 1).daysTo(QDate(2001, *it, 1)); + if (span > maxgap) + maxgap = span; + } + last = *it; + } + int span = QDate(2001, first, 1).daysTo(QDate(2001, last, 1)); + if (freq > 1) + return (freq*365 - span) * 1440; + if (365 - span > maxgap) + return (365 - span) * 1440; + return maxgap * 1440; + } + default: + break; + } + return 0; +} + +/****************************************************************************** + * Return the recurrence's period type. + */ +KARecurrence::Type KARecurrence::type() const +{ + if (mCachedType == -1) + mCachedType = type(defaultRRuleConst()); + return static_cast<Type>(mCachedType); +} + +KARecurrence::Type KARecurrence::type(const RecurrenceRule* rrule) +{ + switch (recurrenceType(rrule)) + { + case rMinutely: return MINUTELY; + case rDaily: return DAILY; + case rWeekly: return WEEKLY; + case rMonthlyDay: return MONTHLY_DAY; + case rMonthlyPos: return MONTHLY_POS; + case rYearlyMonth: return ANNUAL_DATE; + case rYearlyPos: return ANNUAL_POS; + default: + if (dailyType(rrule)) + return DAILY; + return NO_RECUR; + } +} + +/****************************************************************************** + * Check if the rule is a daily rule with or without BYDAYS specified. + */ +bool KARecurrence::dailyType(const RecurrenceRule* rrule) +{ + if (rrule->recurrenceType() != RecurrenceRule::rDaily + || !rrule->bySeconds().isEmpty() + || !rrule->byMinutes().isEmpty() + || !rrule->byHours().isEmpty() + || !rrule->byWeekNumbers().isEmpty() + || !rrule->byMonthDays().isEmpty() + || !rrule->byMonths().isEmpty() + || !rrule->bySetPos().isEmpty() + || !rrule->byYearDays().isEmpty()) + return false; + QValueList<RecurrenceRule::WDayPos> days = rrule->byDays(); + if (days.isEmpty()) + return true; + // Check that all the positions are zero (i.e. every time) + bool found = false; + for (QValueList<RecurrenceRule::WDayPos>::ConstIterator it = days.begin(); it != days.end(); ++it) + { + if ((*it).pos() != 0) + return false; + found = true; + } + return found; + +} |