diff -r f5050f1da672 -r 04becd199f91 javaextensions/pim/agnadapter/src.s60/pimrepeatruleconverter.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/javaextensions/pim/agnadapter/src.s60/pimrepeatruleconverter.cpp	Tue Apr 27 16:30:29 2010 +0300
@@ -0,0 +1,1325 @@
+/*
+* Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:  PIM item repeat rule converter class.
+ *
+*/
+
+
+// INCLUDE FILES
+#include    "pimrepeatruleconverter.h"
+#include "logger.h"
+
+// CONSTANTS
+const TInt KPIMRepeatDatesArrayGranularity = 8;
+
+// ============================ MEMBER FUNCTIONS ==============================
+
+// ----------------------------------------------------------------------------
+// PIMRepeatRuleConverter::Dates
+// Calculates which dates occur on given date subset.
+// Returns: the dates without exception dates.
+// ----------------------------------------------------------------------------
+//
+CArrayFixFlat<TPIMDate>* PIMRepeatRuleConverter::DatesL(
+    const MPIMRepeatRuleData& aRepeatRuleData, const TPIMDate& aStartDate,
+    const TPIMDate& aSubsetBeginning, const TPIMDate& aSubsetEnding,
+    CArrayFixFlat<TPIMDate>& aExceptionDates,
+    const TPIMDate& aRepeatRuleEndDate, const TPIMField& aRepeatRuleCount)
+{
+    JELOG2(EPim);
+    CArrayFixFlat<TPIMDate> * repeatDates =
+        new(ELeave) CArrayFixFlat<TPIMDate> (KPIMRepeatDatesArrayGranularity);
+    CleanupStack::PushL(repeatDates);
+
+    CArrayFix<TPIMField>* fields = aRepeatRuleData.GetFieldsL();
+    CleanupStack::PushL(fields);
+
+    // Make sure that only date part of the TTime is included, not the time part
+    TDateTime startDateTime = aStartDate.DateTime();
+    TTime newStartDate(startDateTime);
+
+    TDateTime subsetBeginningDateTime = aSubsetBeginning.DateTime();
+    TTime newSubsetBeginning(subsetBeginningDateTime);
+
+    TDateTime subsetEndingDateTime = aSubsetEnding.DateTime();
+    TTime newSubsetEnding(subsetEndingDateTime);
+
+    TTime date = newStartDate;
+    TInt countIndex = 0;
+    TInt newInterval;
+    if (IsRepeatFieldPresentL(EPIMRepeatRuleInterval, *fields))
+    {
+        newInterval = aRepeatRuleData.GetIntL(EPIMRepeatRuleInterval);
+    }
+    else
+    {
+        newInterval = 1;
+    }
+
+    TInt frequency = EPIMRepeatRuleDaily; // default if not present
+
+    if (IsRepeatFieldPresentL(EPIMRepeatRuleFrequency, *fields))
+    {
+        frequency = aRepeatRuleData.GetIntL(EPIMRepeatRuleFrequency);
+    }
+
+    switch (frequency)
+    {
+    case(EPIMRepeatRuleDaily):
+    {
+        // Calculate the first repeat after the subset beginning date
+        if (newSubsetBeginning > date)
+        {
+            while (date < newSubsetBeginning)
+            {
+                date = date + TTimeIntervalDays(newInterval);
+                countIndex++;
+            }
+        }
+
+        // First fill the array with all repeat dates
+        for (; date < newSubsetEnding + TTimeIntervalDays(1); date = date
+                + TTimeIntervalDays(newInterval))
+        {
+            if (!AddRepeatDateL(*fields, date, newSubsetBeginning,
+                                newSubsetEnding, aRepeatRuleEndDate, aRepeatRuleCount,
+                                &repeatDates, &countIndex))
+            {
+                break;
+            }
+        }
+        break;
+    }
+
+    case(EPIMRepeatRuleWeekly):
+    {
+        // Calculate the first repeat after the subset beginning date
+        if (newSubsetBeginning > date)
+        {
+            while (date < newSubsetBeginning)
+            {
+                date = date + TTimeIntervalDays(7 * newInterval);
+                countIndex++;
+            }
+        }
+        // First fill the array with all repeat dates
+        for (; date < newSubsetEnding + TTimeIntervalDays(1); date = date
+                + TTimeIntervalDays(7 * newInterval))
+        {
+            if (IsRepeatFieldPresentL(EPIMRepeatRuleDayInWeek, *fields))
+            {
+                if (!CheckDaysInWeekL(*fields, date, newSubsetBeginning,
+                                      newSubsetEnding, aRepeatRuleEndDate, aRepeatRuleCount,
+                                      aRepeatRuleData.GetIntL(EPIMRepeatRuleDayInWeek),
+                                      &repeatDates, &countIndex))
+                {
+                    break;
+                }
+            }
+            else
+            {
+                if (!AddRepeatDateL(*fields, date, newSubsetBeginning,
+                                    newSubsetEnding, aRepeatRuleEndDate, aRepeatRuleCount,
+                                    &repeatDates, &countIndex))
+                {
+                    break;
+                }
+            }
+        }
+        break;
+    }
+
+    case(EPIMRepeatRuleMonthly):
+    {
+        // If DAY_IN_MONTH is present, shift the start date into it
+        if (IsRepeatFieldPresentL(EPIMRepeatRuleDayInMonth, *fields))
+        {
+            TInt repeatRuleDayInMonth = aRepeatRuleData.GetIntL(
+                                            EPIMRepeatRuleDayInMonth);
+
+            if (repeatRuleDayInMonth >= (newStartDate.DayNoInMonth() + 1))
+            {
+                // The following check puts the DAY_IN_MONTH field to
+                // correct place when handling different lenght months
+                if (repeatRuleDayInMonth > (newStartDate.DaysInMonth() + 1))
+                {
+                    date = newStartDate + TTimeIntervalDays(
+                               newStartDate.DaysInMonth()
+                               - (newStartDate.DayNoInMonth() + 1));
+                }
+                else
+                {
+                    date = newStartDate + TTimeIntervalDays(
+                               repeatRuleDayInMonth
+                               - (newStartDate.DayNoInMonth() + 1));
+                }
+            }
+            else
+            {
+                date = newStartDate - TTimeIntervalDays(
+                           (newStartDate.DayNoInMonth() + 1) - repeatRuleDayInMonth);
+            }
+        }
+        // Calculate the first repeat after the subset beginning date
+        if (newSubsetBeginning > date)
+        {
+            while (date < newSubsetBeginning)
+            {
+                date = date + TTimeIntervalMonths(newInterval);
+                countIndex++;
+            }
+        }
+        // First fill the array with all repeat dates
+        for (; date < newSubsetEnding + TTimeIntervalDays(1); date = date
+                + TTimeIntervalMonths(newInterval))
+        {
+            if (IsRepeatFieldPresentL(EPIMRepeatRuleWeekInMonth, *fields)
+                    && IsRepeatFieldPresentL(EPIMRepeatRuleDayInWeek, *fields))
+            {
+                if (!CheckWeeksInMonthL(*fields, date, newSubsetBeginning,
+                                        newSubsetEnding, aRepeatRuleEndDate, aRepeatRuleCount,
+                                        aRepeatRuleData.GetIntL(EPIMRepeatRuleWeekInMonth),
+                                        aRepeatRuleData.GetIntL(EPIMRepeatRuleDayInWeek),
+                                        &repeatDates, &countIndex))
+                {
+                    break;
+                }
+            }
+            else
+            {
+                // The following check puts the DAY_IN_MONTH field to
+                // correct place when handling different lenght months
+                if (IsRepeatFieldPresentL(EPIMRepeatRuleDayInMonth, *fields))
+                {
+                    TInt repeatRuleDayInMonth = aRepeatRuleData.GetIntL(
+                                                    EPIMRepeatRuleDayInMonth);
+
+                    if (repeatRuleDayInMonth > (date.DayNoInMonth() + 1))
+                    {
+                        if (repeatRuleDayInMonth < (date.DaysInMonth() + 1))
+                        {
+                            date = date + TTimeIntervalDays(
+                                       repeatRuleDayInMonth
+                                       - (date.DayNoInMonth() + 1));
+                        }
+                        else
+                        {
+                            date = date + TTimeIntervalDays(date.DaysInMonth()
+                                                            - (date.DayNoInMonth() + 1));
+                        }
+                    }
+                }
+                if (!AddRepeatDateL(*fields, date, newSubsetBeginning,
+                                    newSubsetEnding, aRepeatRuleEndDate, aRepeatRuleCount,
+                                    &repeatDates, &countIndex))
+                {
+                    break;
+                }
+            }
+        }
+        break;
+    }
+
+    case(EPIMRepeatRuleYearly):
+    {
+        // If DAY_IN_YEAR is present, shift the start date into it
+        if (IsRepeatFieldPresentL(EPIMRepeatRuleDayInYear, *fields))
+        {
+            TInt repeatRuleDayInYear = aRepeatRuleData.GetIntL(
+                                           EPIMRepeatRuleDayInYear);
+
+            if (repeatRuleDayInYear >= newStartDate.DayNoInYear())
+            {
+                date = newStartDate + TTimeIntervalDays(repeatRuleDayInYear
+                                                        - newStartDate.DayNoInYear());
+
+                // If DAY_IN_YEAR was set to 366 and this is not a leap year
+                // substract one day from the calculated value
+                if (repeatRuleDayInYear == 366 && !Time::IsLeapYear(
+                            newStartDate.DateTime().Year()))
+                {
+                    date = date - TTimeIntervalDays(1);
+                }
+            }
+            else
+            {
+                date = newStartDate - TTimeIntervalDays(
+                           newStartDate.DayNoInYear() - repeatRuleDayInYear);
+            }
+        }
+        // Calculate the first repeat after the subset beginning date
+        if (newSubsetBeginning > date)
+        {
+            while (date < newSubsetBeginning)
+            {
+                date = date + TTimeIntervalYears(newInterval);
+                countIndex++;
+            }
+        }
+        // First fill the array with all repeat dates
+        for (; date < newSubsetEnding + TTimeIntervalDays(1); date = date
+                + TTimeIntervalYears(newInterval))
+        {
+            TInt repeatRuleWeekInMonth = 0;
+            TInt repeatRuleDayInWeek = 0;
+            TInt repeatRuleMonthInYear = 0;
+            TInt repeatRuleDayInMonth = 0;
+
+            if (IsRepeatFieldPresentL(EPIMRepeatRuleMonthInYear, *fields))
+            {
+                repeatRuleMonthInYear = aRepeatRuleData.GetIntL(
+                                            EPIMRepeatRuleMonthInYear);
+            }
+
+            if (IsRepeatFieldPresentL(EPIMRepeatRuleWeekInMonth, *fields))
+            {
+                repeatRuleWeekInMonth = aRepeatRuleData.GetIntL(
+                                            EPIMRepeatRuleWeekInMonth);
+            }
+
+            if (IsRepeatFieldPresentL(EPIMRepeatRuleDayInWeek, *fields))
+            {
+                repeatRuleDayInWeek = aRepeatRuleData.GetIntL(
+                                          EPIMRepeatRuleDayInWeek);
+            }
+
+            if (IsRepeatFieldPresentL(EPIMRepeatRuleDayInMonth, *fields))
+            {
+                repeatRuleDayInMonth = aRepeatRuleData.GetIntL(
+                                           EPIMRepeatRuleDayInMonth);
+            }
+
+            if (IsRepeatFieldPresentL(EPIMRepeatRuleMonthInYear, *fields))
+            {
+                if (!CheckMonthsInYearL(*fields, date, newSubsetBeginning,
+                                        newSubsetEnding, aRepeatRuleEndDate, aRepeatRuleCount,
+                                        repeatRuleWeekInMonth, repeatRuleDayInWeek,
+                                        repeatRuleMonthInYear, repeatRuleDayInMonth, &repeatDates,
+                                        &countIndex))
+                {
+                    break;
+                }
+            }
+            else
+            {
+                // The following check moves the DAY_IN_YEAR field from 365
+                // to 366 if DAY_IN_YEAR is set 366 and this is a leap year
+                if (IsRepeatFieldPresentL(EPIMRepeatRuleDayInYear, *fields))
+                {
+                    if (aRepeatRuleData.GetIntL(EPIMRepeatRuleDayInYear)
+                            > date.DayNoInYear())
+                    {
+                        if (Time::IsLeapYear(date.DateTime().Year()))
+                        {
+                            date = date + TTimeIntervalDays(1);
+                        }
+                    }
+                }
+                if (!AddRepeatDateL(*fields, date, newSubsetBeginning,
+                                    newSubsetEnding, aRepeatRuleEndDate, aRepeatRuleCount,
+                                    &repeatDates, &countIndex))
+                {
+                    break;
+                }
+            }
+        }
+        break;
+    }
+
+    } // switch( iRepeatRuleFrequency )
+
+    // Finally remove any possible exception dates from the repeat dates array
+    TInt exceptionDateFinder;
+    TInt fetchIndex = 0;
+    TKeyArrayFix key(0, ECmpTInt64);
+    for (TInt index = 0; index < aExceptionDates.Count(); index++)
+    {
+        const TPIMDate& exceptDate = aExceptionDates.At(index);
+        exceptionDateFinder = repeatDates->Find(exceptDate, key, fetchIndex);
+        if (exceptionDateFinder == 0) // 0 means that the element was found
+        {
+            repeatDates->Delete(fetchIndex);
+            // Deleting elements from the array does not cause the
+            // array buffer to be automatically compressed.
+            // Compress() method returns excess space to the heap.
+            repeatDates->Compress();
+        }
+    }
+
+    CleanupStack::PopAndDestroy(fields);
+    CleanupStack::Pop(repeatDates);
+    return repeatDates;
+}
+
+// -----------------------------------------------------------------------------
+// PIMRepeatRuleConverter::IsValidAgendaDate
+// Tells whether given date is ok for Agenda
+// (between 1st January 1980 and 31st December 2100).
+// -----------------------------------------------------------------------------
+//
+TBool PIMRepeatRuleConverter::IsValidAgendaDate(const TPIMDate& aDate)
+{
+    JELOG2(EPim);
+    return ((aDate >= TCalTime::MinTime()) && (aDate <= TCalTime::MaxTime()));
+}
+
+// -----------------------------------------------------------------------------
+// PIMRepeatRuleConverter::ConvertRepeatToAgnL
+// Converts a PIM repeat rule to Agenda Model repeat definition.
+// Frequency is resolved first, as it affects rule formation.
+// Then frequency-dependent parts are resolved by frequencty.
+// Finally common parts are resolved.
+// -----------------------------------------------------------------------------
+//
+TCalRRule PIMRepeatRuleConverter::ConvertSupportedRepeatToAgnL(
+    const MPIMRepeatRuleData& aSrcPimRRule, TPIMDate aStartDate)
+{
+    JELOG2(EPim);
+    TCalTime calStartDate;
+    calStartDate.SetTimeUtcL(aStartDate);
+
+    TCalRRule dstAgnRRule;
+
+    if (IsRepeatFieldPresentL(EPIMRepeatRuleFrequency, aSrcPimRRule))
+    {
+        const TInt pimFrequency = aSrcPimRRule.GetIntL(EPIMRepeatRuleFrequency);
+
+        if (pimFrequency == EPIMRepeatRuleDaily)
+        {
+            dstAgnRRule.SetType(TCalRRule::EDaily);
+        }
+        else if (pimFrequency == EPIMRepeatRuleWeekly)
+        {
+            dstAgnRRule.SetType(TCalRRule::EWeekly);
+            RArray<TDay> weekDays; // put in current weekday
+            CleanupClosePushL(weekDays);
+            User::LeaveIfError(weekDays.Append(aStartDate.DayNoInWeek()));
+            dstAgnRRule.SetByDay(weekDays);
+            CleanupStack::PopAndDestroy(&weekDays);
+        }
+        else if (pimFrequency == EPIMRepeatRuleMonthly)
+        {
+            dstAgnRRule.SetType(TCalRRule::EMonthly);
+            RArray<TInt> monthDays; // put in current month day number
+            CleanupClosePushL(monthDays);
+            User::LeaveIfError(monthDays.Append(aStartDate.DayNoInMonth()));
+            dstAgnRRule.SetByMonthDay(monthDays);
+            CleanupStack::PopAndDestroy(&monthDays);
+        }
+        else if (pimFrequency == EPIMRepeatRuleYearly)
+        {
+            dstAgnRRule.SetType(TCalRRule::EYearly);
+        }
+        else
+        {
+            User::Leave(KErrCorrupt); // invalid frequency
+        }
+    }
+    else // frequency not present
+    {
+        User::Leave(KErrAbort);
+    }
+
+    AddCommonRulesToAgnL(aSrcPimRRule, aStartDate, dstAgnRRule);
+    return dstAgnRRule;
+}
+
+// -----------------------------------------------------------------------------
+// PIMRepeatRuleConverter::ConvertRepeatToPIM
+// Converts an Agenda Model repeat definition to PIM repeat rule
+// -----------------------------------------------------------------------------
+//
+void PIMRepeatRuleConverter::ConvertSupportedRepeatToPIML(
+    MPIMRepeatRuleData& aDstPimRRule, TCalRRule& aSrcAgnRRule)
+{
+    JELOG2(EPim);
+    aDstPimRRule.clear();
+
+    // Frequency
+    if (aSrcAgnRRule.Type() == TCalRRule::EDaily)
+    {
+        aDstPimRRule.SetIntL(EPIMRepeatRuleFrequency, EPIMRepeatRuleDaily);
+    }
+    else if (aSrcAgnRRule.Type() == TCalRRule::EWeekly)
+    {
+        aDstPimRRule.SetIntL(EPIMRepeatRuleFrequency, EPIMRepeatRuleWeekly);
+    }
+    else if (aSrcAgnRRule.Type() == TCalRRule::EMonthly)
+    {
+        aDstPimRRule.SetIntL(EPIMRepeatRuleFrequency, EPIMRepeatRuleMonthly);
+    }
+    else if (aSrcAgnRRule.Type() == TCalRRule::EYearly)
+    {
+        aDstPimRRule.SetIntL(EPIMRepeatRuleFrequency, EPIMRepeatRuleYearly);
+    }
+    else
+    {
+        User::Leave(KErrCorrupt); // repeatrule without frequency
+    }
+
+    // Interval
+    aDstPimRRule.SetIntL(EPIMRepeatRuleInterval, aSrcAgnRRule.Interval());
+
+    // End time
+    TCalTime calEndDate = aSrcAgnRRule.Until();
+    TTime pimEndDate(calEndDate.TimeUtcL());
+    aDstPimRRule.SetDateL(EPIMRepeatRuleEnd, pimEndDate);
+}
+
+// -----------------------------------------------------------------------------
+// PIMRepeatRuleConverter::IsRepeatFieldPresentL
+// Checks if a field is present in the repeat rule.
+// Use the other overload instead if you are checking multiple fields.
+// -----------------------------------------------------------------------------
+//
+TBool PIMRepeatRuleConverter::IsRepeatFieldPresentL(TPIMField aRepeatRuleField,
+        const MPIMRepeatRuleData& aRepeat)
+{
+    JELOG2(EPim);
+    CArrayFix<TPIMField>* repeatFields = aRepeat.GetFieldsL();
+    CleanupStack::PushL(repeatFields);
+    TBool retVal = IsRepeatFieldPresentL(aRepeatRuleField, *repeatFields);
+    CleanupStack::PopAndDestroy(repeatFields);
+    return retVal;
+}
+
+// -----------------------------------------------------------------------------
+// PIMRepeatRuleConverter::IsRepeatFieldPresentL
+// Checks if a field is present in the array of repeat fields.
+// Optimizes speed if called repeatedly instead of the overload
+// which takes a MPIMRepeatRuleData.
+// -----------------------------------------------------------------------------
+//
+TBool PIMRepeatRuleConverter::IsRepeatFieldPresentL(TPIMField aRepeatRuleField,
+        const CArrayFix<TPIMField>& aRepeatFields)
+{
+    JELOG2(EPim);
+    TInt fetchIndex = 0;
+    TKeyArrayFix key(0, ECmpTInt);
+    TInt found = aRepeatFields.Find(aRepeatRuleField, key, fetchIndex);
+    return (found == KErrNone);
+}
+
+// -----------------------------------------------------------------------------
+// PIMRepeatRuleConverter::AddRepeatDateL
+// Checks if a single date is qualified as a repeat date, and adds it to array.
+// -----------------------------------------------------------------------------
+//
+TBool PIMRepeatRuleConverter::AddRepeatDateL(
+    const CArrayFix<TPIMField>& /*aFields*/, TTime aDate,
+    TTime aSubsetBeginning, TTime aSubsetEnding,
+    const TTime& aRepeatRuleEndDate, const TInt aRepeatRuleCount,
+    CArrayFixFlat<TPIMDate>** aRepeatDates, TInt* aCountIndex)
+{
+    JELOG2(EPim);
+    if (aDate < aSubsetBeginning)
+    {
+        return ETrue; // Here it is possible to still continue (no date added)
+    }
+    if (aDate > aSubsetEnding)
+    {
+        return EFalse; // Not possible to continue (subset end reached)
+    }
+    if ((aRepeatRuleEndDate != Time::NullTTime()) && (aDate
+            > aRepeatRuleEndDate))
+    {
+        return EFalse; // Not possible to continue (repeat rule end reached)
+    }
+
+    (*aCountIndex)++;
+    if (aRepeatRuleCount > 0 && (*aCountIndex) > aRepeatRuleCount)
+    {
+        return EFalse; // Not possible to continue (repeat rule count full)
+    }
+
+    (*aRepeatDates)->AppendL(aDate);
+    return ETrue;
+}
+
+// -----------------------------------------------------------------------------
+// PIMRepeatRuleConverter::AddCommonRulesToAgnL
+// Adds common parts of supported repeat rules to Agenda repeat.
+// -----------------------------------------------------------------------------
+//
+void PIMRepeatRuleConverter::AddCommonRulesToAgnL(
+    const MPIMRepeatRuleData& aSrcPimRRule, const TTime& aSrcStartDate,
+    TCalRRule& aDstAgnRRule)
+{
+    JELOG2(EPim);
+    // Interval
+    TInt interval = 1;
+    if (IsRepeatFieldPresentL(EPIMRepeatRuleInterval, aSrcPimRRule))
+    {
+        interval = aSrcPimRRule.GetIntL(EPIMRepeatRuleInterval);
+    }
+    aDstAgnRRule.SetInterval(interval);
+
+    // Start date
+    TCalTime calStartDate;
+    calStartDate.SetTimeUtcL(aSrcStartDate);
+    aDstAgnRRule.SetDtStart(calStartDate);
+
+    // End date
+    if (IsRepeatFieldPresentL(EPIMRepeatRuleEnd, aSrcPimRRule))
+    {
+        TTime pimEndDate = aSrcPimRRule.GetDateL(EPIMRepeatRuleEnd);
+        TCalTime calEndDate;
+        calEndDate.SetTimeUtcL(pimEndDate);
+        aDstAgnRRule.SetUntil(calEndDate);
+    }
+}
+
+// -----------------------------------------------------------------------------
+// PIMRepeatRuleConverter::CheckDaysInWeekL
+// Checks if any week days are qualified as repeat dates, and adds them to array
+// DAY_IN_WEEK requires that one or more weekdays are set,
+// otherwise cannot process
+// -----------------------------------------------------------------------------
+//
+TBool PIMRepeatRuleConverter::CheckDaysInWeekL(
+    const CArrayFix<TPIMField>& aFields, TTime aDate, TTime aSubsetBeginning,
+    TTime aSubsetEnding, TTime aRepeatRuleEndDate, TInt aRepeatRuleCount,
+    const TInt aRepeatRuleDayInWeek, CArrayFixFlat<TPIMDate>** aRepeatDates,
+    TInt* aCountIndex)
+{
+    JELOG2(EPim);
+    if (!IsRepeatFieldPresentL(EPIMRepeatRuleDayInWeek, aFields))
+    {
+        return EFalse;
+    }
+
+    TTime checkDay;
+    TLocale locale;
+
+    // Set the day to the 1st day of the week.
+    if (locale.StartOfWeek() == EMonday)
+    {
+        checkDay = aDate - TTimeIntervalDays(aDate.DayNoInWeek());
+    }
+    else // In case the start of week is set to sunday, substract one day more
+    {
+        if (aDate.DayNoInWeek() == ESunday)
+        {
+            checkDay = aDate; // The day was already sunday, do not substract
+        }
+        else
+        {
+            checkDay = aDate - TTimeIntervalDays(aDate.DayNoInWeek() + 1);
+        }
+    }
+
+    // If the start of the week is set to sunday, start from here
+    if (locale.StartOfWeek() == ESunday)
+    {
+        if (aRepeatRuleDayInWeek & EPIMRepeatRuleSunday)
+        {
+            if (!AddRepeatDateL(aFields, checkDay, aSubsetBeginning,
+                                aSubsetEnding, aRepeatRuleEndDate, aRepeatRuleCount,
+                                aRepeatDates, aCountIndex))
+            {
+                return EFalse;
+            }
+        }
+        checkDay = checkDay + TTimeIntervalDays(1);
+    }
+
+    // If the start of the week is set to monday, start from here
+    if (aRepeatRuleDayInWeek & EPIMRepeatRuleMonday)
+    {
+        if (!AddRepeatDateL(aFields, checkDay, aSubsetBeginning, aSubsetEnding,
+                            aRepeatRuleEndDate, aRepeatRuleCount, aRepeatDates, aCountIndex))
+        {
+            return EFalse;
+        }
+    }
+    checkDay = checkDay + TTimeIntervalDays(1);
+    if (aRepeatRuleDayInWeek & EPIMRepeatRuleTuesday)
+    {
+        if (!AddRepeatDateL(aFields, checkDay, aSubsetBeginning, aSubsetEnding,
+                            aRepeatRuleEndDate, aRepeatRuleCount, aRepeatDates, aCountIndex))
+        {
+            return EFalse;
+        }
+    }
+    checkDay = checkDay + TTimeIntervalDays(1);
+    if (aRepeatRuleDayInWeek & EPIMRepeatRuleWednesday)
+    {
+        if (!AddRepeatDateL(aFields, checkDay, aSubsetBeginning, aSubsetEnding,
+                            aRepeatRuleEndDate, aRepeatRuleCount, aRepeatDates, aCountIndex))
+        {
+            return EFalse;
+        }
+    }
+    checkDay = checkDay + TTimeIntervalDays(1);
+    if (aRepeatRuleDayInWeek & EPIMRepeatRuleThursday)
+    {
+        if (!AddRepeatDateL(aFields, checkDay, aSubsetBeginning, aSubsetEnding,
+                            aRepeatRuleEndDate, aRepeatRuleCount, aRepeatDates, aCountIndex))
+        {
+            return EFalse;
+        }
+    }
+    checkDay = checkDay + TTimeIntervalDays(1);
+    if (aRepeatRuleDayInWeek & EPIMRepeatRuleFriday)
+    {
+        if (!AddRepeatDateL(aFields, checkDay, aSubsetBeginning, aSubsetEnding,
+                            aRepeatRuleEndDate, aRepeatRuleCount, aRepeatDates, aCountIndex))
+        {
+            return EFalse;
+        }
+    }
+    checkDay = checkDay + TTimeIntervalDays(1);
+    if (aRepeatRuleDayInWeek & EPIMRepeatRuleSaturday)
+    {
+        if (!AddRepeatDateL(aFields, checkDay, aSubsetBeginning, aSubsetEnding,
+                            aRepeatRuleEndDate, aRepeatRuleCount, aRepeatDates, aCountIndex))
+        {
+            return EFalse;
+        }
+    }
+
+    // If the start of the week is set to monday, sunday is the last day of week
+    if (locale.StartOfWeek() == EMonday)
+    {
+        checkDay = checkDay + TTimeIntervalDays(1);
+        if (aRepeatRuleDayInWeek & EPIMRepeatRuleSunday)
+        {
+            if (!AddRepeatDateL(aFields, checkDay, aSubsetBeginning,
+                                aSubsetEnding, aRepeatRuleEndDate, aRepeatRuleCount,
+                                aRepeatDates, aCountIndex))
+            {
+                return EFalse;
+            }
+        }
+    }
+
+    return ETrue;
+}
+
+// -----------------------------------------------------------------------------
+// PIMRepeatRuleConverter::CheckDaysInWeekNoMonthChangeL
+// Checks if any week days are qualified as repeat dates, and adds them to array
+// If the month changes to a different month during the week (the week is either
+// in the beginning of the month or at the end of the month), only those days
+// that belong to this month are checked and the rest are discarded.
+// DAY_IN_WEEK requires that one or more weekdays are set,
+// otherwise cannot process
+// -----------------------------------------------------------------------------
+//
+TBool PIMRepeatRuleConverter::CheckDaysInWeekNoMonthChangeL(const CArrayFix<
+        TPIMField>& aFields, TTime aDate, TTime aSubsetBeginning,
+        TTime aSubsetEnding, TTime aRepeatRuleEndDate, TInt aRepeatRuleCount,
+        const TInt aRepeatRuleDayInWeek, CArrayFixFlat<TPIMDate>** aRepeatDates,
+        TInt* aCountIndex)
+{
+    JELOG2(EPim);
+    if (!IsRepeatFieldPresentL(EPIMRepeatRuleDayInWeek, aFields))
+    {
+        return EFalse;
+    }
+
+    TTime checkDay = aDate;
+
+    // First it is needed to check are there accepted dates before the given
+    // date value on the same week (and on the same month)
+    while (checkDay.WeekNoInYear() == aDate.WeekNoInYear()
+            && checkDay.DateTime().Month() == aDate.DateTime().Month())
+    {
+        checkDay = checkDay - TTimeIntervalDays(1);
+    }
+
+    // In the loop the day went to previous month or previous week, add one day
+    checkDay = checkDay + TTimeIntervalDays(1);
+
+    // Store the first accepted day for further comparison.
+    TTime firstAcceptedDay = checkDay;
+
+    // Calculate how many accepted dates in this week there are in total
+    TInt acceptedDaysThisWeek = 0;
+    while (checkDay.WeekNoInYear() == aDate.WeekNoInYear()
+            && checkDay.DateTime().Month() == aDate.DateTime().Month())
+    {
+        acceptedDaysThisWeek++;
+        checkDay = checkDay + TTimeIntervalDays(1);
+    }
+
+    // Finally go through all the accepted days this week
+    for (checkDay = firstAcceptedDay; checkDay < firstAcceptedDay
+            + TTimeIntervalDays(acceptedDaysThisWeek); checkDay = checkDay
+                    + TTimeIntervalDays(1))
+    {
+        switch (checkDay.DayNoInWeek())
+        {
+        case EMonday:
+        {
+            if (aRepeatRuleDayInWeek & EPIMRepeatRuleMonday)
+            {
+                if (!AddRepeatDateL(aFields, checkDay, aSubsetBeginning,
+                                    aSubsetEnding, aRepeatRuleEndDate, aRepeatRuleCount,
+                                    aRepeatDates, aCountIndex))
+                {
+                    return EFalse;
+                }
+            }
+            break;
+        }
+        case ETuesday:
+        {
+            if (aRepeatRuleDayInWeek & EPIMRepeatRuleTuesday)
+            {
+                if (!AddRepeatDateL(aFields, checkDay, aSubsetBeginning,
+                                    aSubsetEnding, aRepeatRuleEndDate, aRepeatRuleCount,
+                                    aRepeatDates, aCountIndex))
+                {
+                    return EFalse;
+                }
+            }
+            break;
+        }
+        case EWednesday:
+        {
+            if (aRepeatRuleDayInWeek & EPIMRepeatRuleWednesday)
+            {
+                if (!AddRepeatDateL(aFields, checkDay, aSubsetBeginning,
+                                    aSubsetEnding, aRepeatRuleEndDate, aRepeatRuleCount,
+                                    aRepeatDates, aCountIndex))
+                {
+                    return EFalse;
+                }
+            }
+            break;
+        }
+        case EThursday:
+        {
+            if (aRepeatRuleDayInWeek & EPIMRepeatRuleThursday)
+            {
+                if (!AddRepeatDateL(aFields, checkDay, aSubsetBeginning,
+                                    aSubsetEnding, aRepeatRuleEndDate, aRepeatRuleCount,
+                                    aRepeatDates, aCountIndex))
+                {
+                    return EFalse;
+                }
+            }
+            break;
+        }
+        case EFriday:
+        {
+            if (aRepeatRuleDayInWeek & EPIMRepeatRuleFriday)
+            {
+                if (!AddRepeatDateL(aFields, checkDay, aSubsetBeginning,
+                                    aSubsetEnding, aRepeatRuleEndDate, aRepeatRuleCount,
+                                    aRepeatDates, aCountIndex))
+                {
+                    return EFalse;
+                }
+            }
+            break;
+        }
+        case ESaturday:
+        {
+            if (aRepeatRuleDayInWeek & EPIMRepeatRuleSaturday)
+            {
+                if (!AddRepeatDateL(aFields, checkDay, aSubsetBeginning,
+                                    aSubsetEnding, aRepeatRuleEndDate, aRepeatRuleCount,
+                                    aRepeatDates, aCountIndex))
+                {
+                    return EFalse;
+                }
+            }
+            break;
+        }
+        case ESunday:
+        {
+            if (aRepeatRuleDayInWeek & EPIMRepeatRuleSunday)
+            {
+                if (!AddRepeatDateL(aFields, checkDay, aSubsetBeginning,
+                                    aSubsetEnding, aRepeatRuleEndDate, aRepeatRuleCount,
+                                    aRepeatDates, aCountIndex))
+                {
+                    return EFalse;
+                }
+            }
+            break;
+        }
+        default:
+        {
+            return EFalse;
+        }
+        } //switch
+    } // for
+
+    return ETrue;
+}
+
+// -----------------------------------------------------------------------------
+// PIMRepeatRuleConverter::CheckWeeksInMonthL
+// Checks if any weeks in month are set to contain repeat dates
+// WEEK_IN_MONTH requires that DAY_IN_WEEK is set, otherwise cannot process
+// -----------------------------------------------------------------------------
+//
+TBool PIMRepeatRuleConverter::CheckWeeksInMonthL(
+    const CArrayFix<TPIMField>& aFields, TTime aDate, TTime aSubsetBeginning,
+    TTime aSubsetEnding, TTime aRepeatRuleEndDate, TInt aRepeatRuleCount,
+    const TInt aRepeatRuleWeekInMonth, const TInt aRepeatRuleDayInWeek,
+    CArrayFixFlat<TPIMDate>** aRepeatDates, TInt* aCountIndex)
+{
+    JELOG2(EPim);
+    TTime checkDay;
+
+    // Make sure the date is set to the 1st day of this month.
+    if (aDate.DayNoInMonth() > 0)
+    {
+        checkDay = aDate - TTimeIntervalDays(aDate.DayNoInMonth());
+    }
+
+    TInt firstWeekNumber = checkDay.WeekNoInYear();
+    TInt lastWeekNumber = (checkDay + TTimeIntervalDays(checkDay.DaysInMonth()
+                           - 1)).WeekNoInYear();
+    TInt weeksInMonth = lastWeekNumber - firstWeekNumber + 1;
+
+    // If there are only 4 weeks in month: This can happen when all weeks are
+    // full weeks (7 days in each) and there are only 28 days in this month.
+    if (weeksInMonth == 4)
+    {
+        if (aRepeatRuleWeekInMonth & EPIMRepeatRuleFirst
+                || aRepeatRuleWeekInMonth & EPIMRepeatRuleFourthLast)
+        {
+            if (!CheckDaysInWeekL(aFields, checkDay, aSubsetBeginning,
+                                  aSubsetEnding, aRepeatRuleEndDate, aRepeatRuleCount,
+                                  aRepeatRuleDayInWeek, aRepeatDates, aCountIndex))
+            {
+                return EFalse;
+            }
+        }
+        checkDay = checkDay + TTimeIntervalDays(7); // Move one week forward
+
+        if (aRepeatRuleWeekInMonth & EPIMRepeatRuleSecond
+                || aRepeatRuleWeekInMonth & EPIMRepeatRuleThirdLast)
+        {
+            if (!CheckDaysInWeekL(aFields, checkDay, aSubsetBeginning,
+                                  aSubsetEnding, aRepeatRuleEndDate, aRepeatRuleCount,
+                                  aRepeatRuleDayInWeek, aRepeatDates, aCountIndex))
+            {
+                return EFalse;
+            }
+        }
+        checkDay = checkDay + TTimeIntervalDays(7); // Move one week forward
+
+        if (aRepeatRuleWeekInMonth & EPIMRepeatRuleThird
+                || aRepeatRuleWeekInMonth & EPIMRepeatRuleSecondLast)
+        {
+            if (!CheckDaysInWeekL(aFields, checkDay, aSubsetBeginning,
+                                  aSubsetEnding, aRepeatRuleEndDate, aRepeatRuleCount,
+                                  aRepeatRuleDayInWeek, aRepeatDates, aCountIndex))
+            {
+                return EFalse;
+            }
+        }
+        checkDay = checkDay + TTimeIntervalDays(7); // Move one week forward
+
+        if (aRepeatRuleWeekInMonth & EPIMRepeatRuleFourth
+                || aRepeatRuleWeekInMonth & EPIMRepeatRuleLast)
+        {
+            if (!CheckDaysInWeekL(aFields, checkDay, aSubsetBeginning,
+                                  aSubsetEnding, aRepeatRuleEndDate, aRepeatRuleCount,
+                                  aRepeatRuleDayInWeek, aRepeatDates, aCountIndex))
+            {
+                return EFalse;
+            }
+        }
+    }
+
+    // If there are 5 weeks in month: This is the most common situation.
+    // The first week and the last week can be incomplete (and so they have
+    // to be handled with the different method), but the three weeks in the
+    // middle are guaranteed to be full weeks with 7 days each.
+    if (weeksInMonth == 5)
+    {
+        if (aRepeatRuleWeekInMonth & EPIMRepeatRuleFirst
+                || aRepeatRuleWeekInMonth & EPIMRepeatRuleFifthLast)
+        {
+            if (!CheckDaysInWeekNoMonthChangeL(aFields, checkDay,
+                                               aSubsetBeginning, aSubsetEnding, aRepeatRuleEndDate,
+                                               aRepeatRuleCount, aRepeatRuleDayInWeek, aRepeatDates,
+                                               aCountIndex))
+            {
+                return EFalse;
+            }
+        }
+        checkDay = checkDay + TTimeIntervalDays(7); // Move one week forward
+
+        if (aRepeatRuleWeekInMonth & EPIMRepeatRuleSecond
+                || aRepeatRuleWeekInMonth & EPIMRepeatRuleFourthLast)
+        {
+            if (!CheckDaysInWeekL(aFields, checkDay, aSubsetBeginning,
+                                  aSubsetEnding, aRepeatRuleEndDate, aRepeatRuleCount,
+                                  aRepeatRuleDayInWeek, aRepeatDates, aCountIndex))
+            {
+                return EFalse;
+            }
+        }
+        checkDay = checkDay + TTimeIntervalDays(7); // Move one week forward
+
+        if (aRepeatRuleWeekInMonth & EPIMRepeatRuleThird
+                || aRepeatRuleWeekInMonth & EPIMRepeatRuleThirdLast)
+        {
+            if (!CheckDaysInWeekL(aFields, checkDay, aSubsetBeginning,
+                                  aSubsetEnding, aRepeatRuleEndDate, aRepeatRuleCount,
+                                  aRepeatRuleDayInWeek, aRepeatDates, aCountIndex))
+            {
+                return EFalse;
+            }
+        }
+        checkDay = checkDay + TTimeIntervalDays(7); // Move one week forward
+
+        if (aRepeatRuleWeekInMonth & EPIMRepeatRuleFourth
+                || aRepeatRuleWeekInMonth & EPIMRepeatRuleSecondLast)
+        {
+            if (!CheckDaysInWeekL(aFields, checkDay, aSubsetBeginning,
+                                  aSubsetEnding, aRepeatRuleEndDate, aRepeatRuleCount,
+                                  aRepeatRuleDayInWeek, aRepeatDates, aCountIndex))
+            {
+                return EFalse;
+            }
+        }
+
+        if (aRepeatRuleWeekInMonth & EPIMRepeatRuleFifth
+                || aRepeatRuleWeekInMonth & EPIMRepeatRuleLast)
+        {
+            // Here we need to go exactly to the 1st day of next week
+            TTime fourthWeek = checkDay;
+            while (checkDay.WeekNoInYear() == fourthWeek.WeekNoInYear())
+            {
+                checkDay = checkDay + TTimeIntervalDays(1);
+            }
+            if (!CheckDaysInWeekNoMonthChangeL(aFields, checkDay,
+                                               aSubsetBeginning, aSubsetEnding, aRepeatRuleEndDate,
+                                               aRepeatRuleCount, aRepeatRuleDayInWeek, aRepeatDates,
+                                               aCountIndex))
+            {
+                return EFalse;
+            }
+        }
+    }
+
+    // If there are 6 weeks in month: This happens only a few times a year.
+    // The first week and the last week can be incomplete (and so they have
+    // to be handled with the different method), but the four weeks in the
+    // middle are guaranteed to be full weeks with 7 days each.
+    if (weeksInMonth == 6)
+    {
+        if (aRepeatRuleWeekInMonth & EPIMRepeatRuleFirst)
+        {
+            if (!CheckDaysInWeekNoMonthChangeL(aFields, checkDay,
+                                               aSubsetBeginning, aSubsetEnding, aRepeatRuleEndDate,
+                                               aRepeatRuleCount, aRepeatRuleDayInWeek, aRepeatDates,
+                                               aCountIndex))
+            {
+                return EFalse;
+            }
+        }
+        checkDay = checkDay + TTimeIntervalDays(7); // Move one week forward
+
+        if (aRepeatRuleWeekInMonth & EPIMRepeatRuleSecond
+                || aRepeatRuleWeekInMonth & EPIMRepeatRuleFifthLast)
+        {
+            if (!CheckDaysInWeekL(aFields, checkDay, aSubsetBeginning,
+                                  aSubsetEnding, aRepeatRuleEndDate, aRepeatRuleCount,
+                                  aRepeatRuleDayInWeek, aRepeatDates, aCountIndex))
+            {
+                return EFalse;
+            }
+        }
+        checkDay = checkDay + TTimeIntervalDays(7); // Move one week forward
+
+        if (aRepeatRuleWeekInMonth & EPIMRepeatRuleThird
+                || aRepeatRuleWeekInMonth & EPIMRepeatRuleFourthLast)
+        {
+            if (!CheckDaysInWeekL(aFields, checkDay, aSubsetBeginning,
+                                  aSubsetEnding, aRepeatRuleEndDate, aRepeatRuleCount,
+                                  aRepeatRuleDayInWeek, aRepeatDates, aCountIndex))
+            {
+                return EFalse;
+            }
+        }
+        checkDay = checkDay + TTimeIntervalDays(7); // Move one week forward
+
+        if (aRepeatRuleWeekInMonth & EPIMRepeatRuleFourth
+                || aRepeatRuleWeekInMonth & EPIMRepeatRuleThirdLast)
+        {
+            if (!CheckDaysInWeekL(aFields, checkDay, aSubsetBeginning,
+                                  aSubsetEnding, aRepeatRuleEndDate, aRepeatRuleCount,
+                                  aRepeatRuleDayInWeek, aRepeatDates, aCountIndex))
+            {
+                return EFalse;
+            }
+        }
+        checkDay = checkDay + TTimeIntervalDays(7); // Move one week forward
+
+        if (aRepeatRuleWeekInMonth & EPIMRepeatRuleFifth
+                || aRepeatRuleWeekInMonth & EPIMRepeatRuleSecondLast)
+        {
+            if (!CheckDaysInWeekL(aFields, checkDay, aSubsetBeginning,
+                                  aSubsetEnding, aRepeatRuleEndDate, aRepeatRuleCount,
+                                  aRepeatRuleDayInWeek, aRepeatDates, aCountIndex))
+            {
+                return EFalse;
+            }
+        }
+
+        if (aRepeatRuleWeekInMonth & EPIMRepeatRuleLast)
+        {
+            // Here we need to go exactly to the 1st day of next week
+            TTime fifthWeek = checkDay;
+            while (checkDay.WeekNoInYear() == fifthWeek.WeekNoInYear())
+            {
+                checkDay = checkDay + TTimeIntervalDays(1);
+            }
+            if (!CheckDaysInWeekNoMonthChangeL(aFields, checkDay,
+                                               aSubsetBeginning, aSubsetEnding, aRepeatRuleEndDate,
+                                               aRepeatRuleCount, aRepeatRuleDayInWeek, aRepeatDates,
+                                               aCountIndex))
+            {
+                return EFalse;
+            }
+        }
+    }
+
+    return ETrue;
+}
+
+// -----------------------------------------------------------------------------
+// PIMRepeatRuleConverter::CheckMonthsInYearL
+// Checks if any months in year are set to contain repeat dates
+// MONTH_IN_YEAR requires that either DAY_IN_MONTH is set, or
+// both WEEK_IN_MONTH and DAY_IN_WEEK are set: otherwise cannot process
+// -----------------------------------------------------------------------------
+//
+TBool PIMRepeatRuleConverter::CheckMonthsInYearL(
+    const CArrayFix<TPIMField>& aFields, TTime aDate, TTime aSubsetBeginning,
+    TTime aSubsetEnding, TTime aRepeatRuleEndDate, TInt aRepeatRuleCount,
+    TInt aRepeatRuleWeekInMonth, TInt aRepeatRuleDayInWeek,
+    TInt aRepeatRuleMonthInYear, TInt aRepeatRuleDayInMonth, CArrayFixFlat<
+    TPIMDate>** aRepeatDates, TInt* aCountIndex)
+{
+    JELOG2(EPim);
+    // Set the day to the 1st day of the 1st month.
+    TTime checkDay = aDate - TTimeIntervalDays(aDate.DayNoInYear() - 1);
+
+    if (aRepeatRuleMonthInYear & EPIMRepeatRuleJanuary)
+    {
+        if (!CheckMonthL(aFields, checkDay, aSubsetBeginning, aSubsetEnding,
+                         aRepeatRuleEndDate, aRepeatRuleCount, aRepeatRuleWeekInMonth,
+                         aRepeatRuleDayInWeek, aRepeatRuleDayInMonth, aRepeatDates,
+                         aCountIndex))
+        {
+            return EFalse;
+        }
+    }
+    checkDay = checkDay + TTimeIntervalMonths(1);
+
+    if (aRepeatRuleMonthInYear & EPIMRepeatRuleFebruary)
+    {
+        if (!CheckMonthL(aFields, checkDay, aSubsetBeginning, aSubsetEnding,
+                         aRepeatRuleEndDate, aRepeatRuleCount, aRepeatRuleWeekInMonth,
+                         aRepeatRuleDayInWeek, aRepeatRuleDayInMonth, aRepeatDates,
+                         aCountIndex))
+        {
+            return EFalse;
+        }
+    }
+    checkDay = checkDay + TTimeIntervalMonths(1);
+
+    if (aRepeatRuleMonthInYear & EPIMRepeatRuleMarch)
+    {
+        if (!CheckMonthL(aFields, checkDay, aSubsetBeginning, aSubsetEnding,
+                         aRepeatRuleEndDate, aRepeatRuleCount, aRepeatRuleWeekInMonth,
+                         aRepeatRuleDayInWeek, aRepeatRuleDayInMonth, aRepeatDates,
+                         aCountIndex))
+        {
+            return EFalse;
+        }
+    }
+    checkDay = checkDay + TTimeIntervalMonths(1);
+
+    if (aRepeatRuleMonthInYear & EPIMRepeatRuleApril)
+    {
+        if (!CheckMonthL(aFields, checkDay, aSubsetBeginning, aSubsetEnding,
+                         aRepeatRuleEndDate, aRepeatRuleCount, aRepeatRuleWeekInMonth,
+                         aRepeatRuleDayInWeek, aRepeatRuleDayInMonth, aRepeatDates,
+                         aCountIndex))
+        {
+            return EFalse;
+        }
+    }
+    checkDay = checkDay + TTimeIntervalMonths(1);
+
+    if (aRepeatRuleMonthInYear & EPIMRepeatRuleMay)
+    {
+        if (!CheckMonthL(aFields, checkDay, aSubsetBeginning, aSubsetEnding,
+                         aRepeatRuleEndDate, aRepeatRuleCount, aRepeatRuleWeekInMonth,
+                         aRepeatRuleDayInWeek, aRepeatRuleDayInMonth, aRepeatDates,
+                         aCountIndex))
+        {
+            return EFalse;
+        }
+    }
+    checkDay = checkDay + TTimeIntervalMonths(1);
+
+    if (aRepeatRuleMonthInYear & EPIMRepeatRuleJune)
+    {
+        if (!CheckMonthL(aFields, checkDay, aSubsetBeginning, aSubsetEnding,
+                         aRepeatRuleEndDate, aRepeatRuleCount, aRepeatRuleWeekInMonth,
+                         aRepeatRuleDayInWeek, aRepeatRuleDayInMonth, aRepeatDates,
+                         aCountIndex))
+        {
+            return EFalse;
+        }
+    }
+    checkDay = checkDay + TTimeIntervalMonths(1);
+
+    if (aRepeatRuleMonthInYear & EPIMRepeatRuleJuly)
+    {
+        if (!CheckMonthL(aFields, checkDay, aSubsetBeginning, aSubsetEnding,
+                         aRepeatRuleEndDate, aRepeatRuleCount, aRepeatRuleWeekInMonth,
+                         aRepeatRuleDayInWeek, aRepeatRuleDayInMonth, aRepeatDates,
+                         aCountIndex))
+        {
+            return EFalse;
+        }
+    }
+    checkDay = checkDay + TTimeIntervalMonths(1);
+
+    if (aRepeatRuleMonthInYear & EPIMRepeatRuleAugust)
+    {
+        if (!CheckMonthL(aFields, checkDay, aSubsetBeginning, aSubsetEnding,
+                         aRepeatRuleEndDate, aRepeatRuleCount, aRepeatRuleWeekInMonth,
+                         aRepeatRuleDayInWeek, aRepeatRuleDayInMonth, aRepeatDates,
+                         aCountIndex))
+        {
+            return EFalse;
+        }
+    }
+    checkDay = checkDay + TTimeIntervalMonths(1);
+
+    if (aRepeatRuleMonthInYear & EPIMRepeatRuleSeptember)
+    {
+        if (!CheckMonthL(aFields, checkDay, aSubsetBeginning, aSubsetEnding,
+                         aRepeatRuleEndDate, aRepeatRuleCount, aRepeatRuleWeekInMonth,
+                         aRepeatRuleDayInWeek, aRepeatRuleDayInMonth, aRepeatDates,
+                         aCountIndex))
+        {
+            return EFalse;
+        }
+    }
+    checkDay = checkDay + TTimeIntervalMonths(1);
+
+    if (aRepeatRuleMonthInYear & EPIMRepeatRuleOctober)
+    {
+        if (!CheckMonthL(aFields, checkDay, aSubsetBeginning, aSubsetEnding,
+                         aRepeatRuleEndDate, aRepeatRuleCount, aRepeatRuleWeekInMonth,
+                         aRepeatRuleDayInWeek, aRepeatRuleDayInMonth, aRepeatDates,
+                         aCountIndex))
+        {
+            return EFalse;
+        }
+    }
+    checkDay = checkDay + TTimeIntervalMonths(1);
+
+    if (aRepeatRuleMonthInYear & EPIMRepeatRuleNovember)
+    {
+        if (!CheckMonthL(aFields, checkDay, aSubsetBeginning, aSubsetEnding,
+                         aRepeatRuleEndDate, aRepeatRuleCount, aRepeatRuleWeekInMonth,
+                         aRepeatRuleDayInWeek, aRepeatRuleDayInMonth, aRepeatDates,
+                         aCountIndex))
+        {
+            return EFalse;
+        }
+    }
+    checkDay = checkDay + TTimeIntervalMonths(1);
+
+    if (aRepeatRuleMonthInYear & EPIMRepeatRuleDecember)
+    {
+        if (!CheckMonthL(aFields, checkDay, aSubsetBeginning, aSubsetEnding,
+                         aRepeatRuleEndDate, aRepeatRuleCount, aRepeatRuleWeekInMonth,
+                         aRepeatRuleDayInWeek, aRepeatRuleDayInMonth, aRepeatDates,
+                         aCountIndex))
+        {
+            return EFalse;
+        }
+    }
+
+    return ETrue;
+}
+
+// -----------------------------------------------------------------------------
+// PIMRepeatRuleConverter::CheckMonthL
+// Checks if this month has set to contain repeat dates
+// MONTH_IN_YEAR requires that either DAY_IN_MONTH is set, or
+// both WEEK_IN_MONTH and DAY_IN_WEEK are set: otherwise cannot process
+// -----------------------------------------------------------------------------
+//
+TBool PIMRepeatRuleConverter::CheckMonthL(const CArrayFix<TPIMField>& aFields,
+        TTime aDate, TTime aSubsetBeginning, TTime aSubsetEnding,
+        TTime aRepeatRuleEndDate, TInt aRepeatRuleCount,
+        TInt aRepeatRuleWeekInMonth, TInt aRepeatRuleDayInWeek,
+        TInt aRepeatRuleDayInMonth, CArrayFixFlat<TPIMDate>** aRepeatDates,
+        TInt* aCountIndex)
+{
+    JELOG2(EPim);
+    // Make sure the date is set to the 1st day of this month.
+    if (aDate.DayNoInMonth() > 0)
+    {
+        aDate = aDate - TTimeIntervalDays(aDate.DayNoInMonth());
+    }
+
+    if (IsRepeatFieldPresentL(EPIMRepeatRuleWeekInMonth, aFields))
+    {
+        if (!CheckWeeksInMonthL(aFields, aDate, aSubsetBeginning,
+                                aSubsetEnding, aRepeatRuleEndDate, aRepeatRuleCount,
+                                aRepeatRuleWeekInMonth, aRepeatRuleDayInWeek, aRepeatDates,
+                                aCountIndex))
+        {
+            return EFalse;
+        }
+    }
+    else if (IsRepeatFieldPresentL(EPIMRepeatRuleDayInMonth, aFields))
+    {
+        // Shift the date to the correct place. If the day is bigger than
+        // there are days in this month, use the last day of the month instead.
+        if (aRepeatRuleDayInMonth < (aDate.DaysInMonth() + 1))
+        {
+            aDate = aDate + TTimeIntervalDays(aRepeatRuleDayInMonth - 1);
+        }
+        else
+        {
+            aDate = aDate + TTimeIntervalDays(aDate.DaysInMonth() - 1);
+        }
+
+        if (!AddRepeatDateL(aFields, aDate, aSubsetBeginning, aSubsetEnding,
+                            aRepeatRuleEndDate, aRepeatRuleCount, aRepeatDates, aCountIndex))
+        {
+            return EFalse;
+        }
+    }
+    else
+    {
+        // WEEK_IN_MONTH or DAY_IN_MONTH has to be present if MONTH_IN_YEAR used
+        return EFalse;
+    }
+
+    return ETrue;
+}
+
+//  End of File