--- a/calendarui/commonutils/src/calenagendautils.cpp Tue Aug 31 15:13:43 2010 +0300
+++ b/calendarui/commonutils/src/calenagendautils.cpp Wed Sep 01 12:32:31 2010 +0100
@@ -11,38 +11,195 @@
*
* Contributors:
*
-* Description: Static utility functions.
+* Description: Static utility functions.
* - date utils to help comparisions and calculations with
* dates and times.
*
*/
-//INCLUDE FILES
-#include <QList>
-#include <QDateTime>
+#include <calinstance.h>
+#include <calinstanceview.h>
+#include <calrrule.h>
+#include <calenagendautils.h>
+#include <calendateutils.h>
+
+//debug
#include "calendarui_debug.h"
-#include "calenagendautils.h"
-#include "calendateutils.h"
+#include "vstaticutils.h"
// ============================ MEMBER FUNCTIONS ==============================
// ============================ CalenAgendaUtils ==============================
// -----------------------------------------------------------------------------
-// CalenAgendaUtils::EndsAtStartOfDay
+// CalenAgendaUtils::FindEventsForDayRangeL
+// ?implementation_description
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CalenAgendaUtils::FindEventsForDayRangeL( CCalInstanceView* aInstanceView,
+ RPointerArray<CCalInstance>& aList,
+ const CalCommon::TCalViewFilter& aFilter,
+ const TTime& aStartDay,
+ const TTime& aEndDay )
+ {
+ TRACE_ENTRY_POINT;
+
+ TCalTime dummy;
+ CalCommon::TCalTimeRange dayRange( dummy, dummy );
+
+ CalenDateUtils::GetDayRangeL( aStartDay, aEndDay, dayRange );
+
+ if(CalenDateUtils::IsValidDay(aStartDay))
+ {
+ aInstanceView->FindInstanceL( aList, aFilter, dayRange );
+ }
+
+ TRACE_EXIT_POINT;
+ }
+
+// -----------------------------------------------------------------------------
+// CalenAgendaUtils::FindTodosForDayRangeL
// ?implementation_description
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
- bool CalenAgendaUtils::endsAtStartOfDay( AgendaEntry& entry,
- const QDateTime& day )
+EXPORT_C void CalenAgendaUtils::FindTodosForDayRangeL( CCalInstanceView* aInstanceView,
+ RPointerArray<CCalInstance>& aList,
+ const TTime& aStartDay,
+ const TTime& aEndDay )
{
TRACE_ENTRY_POINT;
- const QDateTime dayStart = CalenDateUtils::beginningOfDay( day );
- const QDateTime startTime( entry.startTime() );
- const QDateTime endTime( entry.endTime() );
+ const TCalTime dummy;
+ CalCommon::TCalTimeRange dayRange( dummy, dummy );
+ CalenDateUtils::GetDayRangeL( aStartDay, aEndDay, dayRange );
+
+ TTime today; today.HomeTime();
+ const TTime tomorrow( today + TTimeIntervalDays(1) );
+
+ const TTime rangeStart( dayRange.StartTime().TimeLocalL() ); // at 00:00.00
+ const TTime rangeEnd( dayRange.EndTime().TimeLocalL() ); // at 23:59.59
+
+ // fetch past uncompleted to-dos for today if today is included in the range
+ if( rangeStart <= today && today <= rangeEnd )
+ {
+ // today includes today's to-dos + all past incompleted todos
+ CalenDateUtils::GetDayRangeL( TCalTime::MinTime(), today, dayRange );
+
+ if(CalenDateUtils::IsValidDay(aStartDay))
+ {
+ aInstanceView->FindInstanceL( aList,
+ CalCommon::EIncludeIncompletedTodos |
+ // only fetch the first instance for repeating to-dos!
+ CalCommon::EIncludeRptsNextInstanceOnly,
+ dayRange );
+ }
+ // reset the time range for the remaining days
+ CalenDateUtils::GetDayRangeL( tomorrow, aEndDay, dayRange );
+ }
+
+ // today already fetched, fetch the remaining range if any...
+ // (including all the instances of repeating to-dos)
+ if( rangeEnd > tomorrow )
+ {
+ aInstanceView->FindInstanceL( aList,
+ CalCommon::EIncludeIncompletedTodos,
+ dayRange );
+ }
+
+ TRACE_EXIT_POINT;
+ }
+
+// -----------------------------------------------------------------------------
+// CalenAgendaUtils::RemoveEntriesStartingAtMidnight
+// ?implementation_description
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CalenAgendaUtils::RemoveEntriesEndingAtMidnightL( RPointerArray<CCalInstance>& aList,
+ const TTime& aDay )
+ {
+ TRACE_ENTRY_POINT;
+
+ // Remove events starting before aDay and ending at midnight
+ TInt i( 0 );
+
+ while( i < aList.Count() )
+ {
+ CCalInstance* item = aList[i];
+
+ if( EndsAtStartOfDayL( item, aDay ) )
+ {
+ aList.Remove( i );
+ delete item; // remember to delete before we lose the pointer
+ }
+ else
+ {
+ ++i;
+ }
+ }
+
+ TRACE_EXIT_POINT;
+ }
+
+// -----------------------------------------------------------------------------
+// CalenAgendaUtils::CreateEntryIdListForDayL
+// ?implementation_description
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CalenAgendaUtils::CreateEntryIdListForDayL( RPointerArray<CCalInstance>& aList,
+ CCalInstanceView* aInstanceView,
+ const TTime& aDay,
+ const TBool aSortForPopup,
+ const TBool aIncludeToDos )
+ {
+ TRACE_ENTRY_POINT;
+
+ const CalCommon::TCalViewFilter filter = CalCommon::EIncludeAppts |
+ CalCommon::EIncludeReminder |
+ CalCommon::EIncludeEvents |
+ CalCommon::EIncludeAnnivs;
+
+ CalenAgendaUtils::FindEventsForDayRangeL( aInstanceView, aList, filter, aDay, aDay );
+
+ CalenAgendaUtils::RemoveEntriesEndingAtMidnightL( aList, aDay );
+
+ if( aIncludeToDos )
+ {
+ CalenAgendaUtils::FindTodosForDayRangeL( aInstanceView, aList, aDay, aDay );
+ }
+
+ if( aSortForPopup )
+ {
+ CalenAgendaUtils::SortPopupInstanceList( aList );
+ }
+ else
+ {
+ CalenAgendaUtils::SortInstanceList( aList );
+ }
+
+ TRACE_EXIT_POINT;
+ }
+
+// -----------------------------------------------------------------------------
+// CalenAgendaUtils::EndsAtStartOfDayL
+// ?implementation_description
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TBool CalenAgendaUtils::EndsAtStartOfDayL( CCalInstance* aInstance,
+ const TTime& aDay )
+ {
+ TRACE_ENTRY_POINT;
+
+ const TTime dayStart = CalenDateUtils::BeginningOfDay( aDay );
+ const TTime startTime( aInstance->Time().TimeLocalL() );
+ TTimeIntervalMinutes duration;
+ aInstance->Entry().EndTimeL().TimeLocalL().MinutesFrom( aInstance->Entry().StartTimeL().TimeLocalL(), duration );
+ const TTime endTime( startTime +duration );
const TBool result( endTime > startTime && endTime == dayStart );
@@ -50,38 +207,605 @@
return result;
}
- // ---------------------------------------------------------------------------
- // CalenAgendaUtils::IsAllDayEvent
- // Allday event is an event with a duration of n*24h.
- // ---------------------------------------------------------------------------
- //
- bool CalenAgendaUtils::isAlldayEvent( const AgendaEntry& entry )
+// -----------------------------------------------------------------------------
+// CalenAgendaUtils::SortInstanceList
+// ?implementation_description
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CalenAgendaUtils::SortInstanceList( RPointerArray<CCalInstance>& aInstanceList )
+ {
+ TRACE_ENTRY_POINT;
+
+ TLinearOrder<CCalInstance> instanceListOrder( CalenAgendaUtils::EntryCompare );
+ aInstanceList.Sort( instanceListOrder );
+
+ TRACE_EXIT_POINT;
+ }
+
+// -----------------------------------------------------------------------------
+// CalenAgendaUtils::SortInstanceList
+// ?implementation_description
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CalenAgendaUtils::SortPopupInstanceList( RPointerArray<CCalInstance>& aInstanceList )
+ {
+ TRACE_ENTRY_POINT;
+
+ TLinearOrder<CCalInstance> instanceListOrder( CalenAgendaUtils::PopupEntryCompare );
+ aInstanceList.Sort( instanceListOrder );
+
+ TRACE_EXIT_POINT;
+ }
+
+TInt CalenAgendaUtils::EntryCompare(const CCalInstance& aInstance1, const CCalInstance& aInstance2)
+ {
+ TRACE_ENTRY_POINT;
+
+ TInt res = KErrArgument;
+ TRAP_IGNORE( ( res = DoEntryCompareL( aInstance1, aInstance2 ) ) );
+
+ TRACE_EXIT_POINT;
+ return res;
+ }
+// -----------------------------------------------------------------------------
+// CalenAgendaUtils::DoEntryCompareL
+// Common compare for all calendar entries. Order as follows:
+// 1. ETodo
+// 2. EEvent
+// 3. EAnniv
+// 4. EAppt, EReminder
+// -----------------------------------------------------------------------------
+//
+TInt CalenAgendaUtils::DoEntryCompareL( const CCalInstance& aInstance1,
+ const CCalInstance& aInstance2 )
+ {
+ TRACE_ENTRY_POINT;
+
+ TInt ret( EEqual );
+
+ const CCalEntry& entry1 = aInstance1.Entry();
+ const CCalEntry& entry2 = aInstance2.Entry();
+ const CCalEntry::TType type1 = entry1.EntryTypeL();
+ const CCalEntry::TType type2 = entry2.EntryTypeL();
+
+ // types are equal (reminders are handled as meetings)
+ if( type1 == type2 ||
+ ((type1 == CCalEntry::EAppt && type2 == CCalEntry::EReminder) ||
+ (type2 == CCalEntry::EAppt && type1 == CCalEntry::EReminder)) )
+ {
+ switch( type1 )
+ {
+ case CCalEntry::ETodo:
+ ret = CalenAgendaUtils::CompareToDosL( entry1, entry2 );
+ break;
+
+ case CCalEntry::EAnniv:
+ case CCalEntry::EEvent:
+ ret = CalenAgendaUtils::CompareNonTimedNotesL( aInstance1, aInstance2 );
+ break;
+
+ case CCalEntry::EReminder:
+ case CCalEntry::EAppt:
+ ret = CalenAgendaUtils::CompareTimedNotesL( aInstance1, aInstance2 );
+ break;
+
+ default:
+ ASSERT(EFalse);
+ }
+ }
+ else // types are different
+ {
+#ifdef RD_CALENDAR_PREVIEW
+ switch( type1 )
+ {
+ case CCalEntry::ETodo:
+ // to-dos come always first...
+ ret = ELessThan;
+ break;
+
+ case CCalEntry::EAnniv:
+ // ...and then anniversaries...
+ if( type2 == CCalEntry::ETodo )
+ {
+ ret = EGreaterThan;
+ }
+ else
+ {
+ ret = ELessThan;
+ }
+ break;
+
+ case CCalEntry::EEvent:
+ // ...then day notes...
+ if( (type2 == CCalEntry::ETodo) || (type2 == CCalEntry::EAnniv))
+ {
+ ret = EGreaterThan;
+ }
+ else
+ {
+ ret = ELessThan;
+ }
+ break;
+
+ case CCalEntry::EReminder:
+ case CCalEntry::EAppt:
+ // ...and finally timed notes...
+ ret = EGreaterThan;
+ break;
+ default:
+ ASSERT(EFalse);
+ }
+#else // !RD_CALENDAR_PREVIEW
+ switch( type1 )
+ {
+ case CCalEntry::ETodo:
+ // to-dos come always first...
+ ret = ELessThan;
+ break;
+
+ case CCalEntry::EEvent:
+ // ...then day notes...
+ if( type2 == CCalEntry::ETodo )
+ {
+ ret = EGreaterThan;
+ }
+ else
+ {
+ ret = ELessThan;
+ }
+ break;
+
+ case CCalEntry::EAnniv:
+ // ...and anniversaries...
+ if( (type2 == CCalEntry::ETodo) || (type2 == CCalEntry::EEvent))
+ {
+ ret = EGreaterThan;
+ }
+ else
+ {
+ ret = ELessThan;
+ }
+ break;
+
+ case CCalEntry::EReminder:
+ case CCalEntry::EAppt:
+ // ...and finally timed notes.
+ ret = EGreaterThan;
+ break;
+
+ default:
+ ASSERT(EFalse);
+ }
+#endif // RD_CALENDAR_PREVIEW
+ }
+
+ TRACE_EXIT_POINT;
+ return ret;
+ }
+
+TInt CalenAgendaUtils::PopupEntryCompare( const CCalInstance& aInstance1,
+ const CCalInstance& aInstance2 )
+ {
+ TRACE_ENTRY_POINT;
+
+ TInt res = KErrArgument;
+ TRAP_IGNORE( ( res = DoPopupEntryCompareL( aInstance1, aInstance2 ) ) );
+
+ TRACE_EXIT_POINT;
+ return res;
+ }
+
+// -----------------------------------------------------------------------------
+// CalenAgendaUtils::DoPopupEntryCompareL
+// Compare for calendar pop-up. Order as follows:
+// 1. ETodo
+// 2. EAnniv
+// 3. EEvent
+// 4. EAppt, EReminder
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TInt CalenAgendaUtils::DoPopupEntryCompareL( const CCalInstance& aInstance1,
+ const CCalInstance& aInstance2 )
+ {
+ TRACE_ENTRY_POINT;
+
+ TInt ret( EEqual );
+ const CCalEntry& entry1 = aInstance1.Entry();
+ const CCalEntry& entry2 = aInstance2.Entry();
+ const CCalEntry::TType type1 = entry1.EntryTypeL();
+ const CCalEntry::TType type2 = entry2.EntryTypeL();
+
+ // types are equal (reminders are handled as meetings)
+ if( type1 == type2 ||
+ ((type1 == CCalEntry::EAppt && type2 == CCalEntry::EReminder) ||
+ (type2 == CCalEntry::EAppt && type1 == CCalEntry::EReminder)) )
+ {
+ switch( type1 )
+ {
+ case CCalEntry::ETodo:
+ ret = CalenAgendaUtils::CompareToDosL( entry1, entry2 );
+ break;
+
+ case CCalEntry::EAnniv:
+ case CCalEntry::EEvent:
+ ret = CalenAgendaUtils::CompareNonTimedNotesL( aInstance1, aInstance2 );
+ break;
+
+ case CCalEntry::EReminder:
+ case CCalEntry::EAppt:
+ ret = CalenAgendaUtils::CompareTimedNotesL( aInstance1, aInstance2 );
+ break;
+
+ default:
+ ASSERT(EFalse);
+ }
+ }
+ else // types are different
{
-
- TRACE_ENTRY_POINT;
+ switch( type1 )
+ {
+ case CCalEntry::ETodo:
+ // to-dos come always first...
+ ret = ELessThan;
+ break;
+
+ case CCalEntry::EAnniv:
+ // ...and then anniversaries...
+ if( type2 == CCalEntry::ETodo )
+ {
+ ret = EGreaterThan;
+ }
+ else
+ {
+ ret = ELessThan;
+ }
+ break;
+
+ case CCalEntry::EEvent:
+ // ...then day notes...
+ if( (type2 == CCalEntry::ETodo) || (type2 == CCalEntry::EAnniv))
+ {
+ ret = EGreaterThan;
+ }
+ else
+ {
+ ret = ELessThan;
+ }
+ break;
+
+ case CCalEntry::EReminder:
+ case CCalEntry::EAppt:
+ // ...and finally timed notes...
+ ret = EGreaterThan;
+ break;
+
+ default:
+ ASSERT(EFalse);
+ }
+ }
+
+ TRACE_EXIT_POINT;
+ return ret;
+ }
+
+// -----------------------------------------------------------------------------
+// CalenAgendaUtils::CompareToDos
+// Compares two to-do entries. Sort criteria:
+// 1. Status: ETodoNeedsAction before ETodoCompleted
+// 2. Due date: oldest first (1.1.2005 before 2.1.2005 )
+// 3. Priority: highest first (1 before 2 )
+// 4. Last modified: oldest first (1.1.2005 09:00 before 1.1.2005 10:00 )
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TInt CalenAgendaUtils::CompareToDosL( const CCalEntry& aEntry1,
+ const CCalEntry& aEntry2 )
+ {
+ TRACE_ENTRY_POINT;
- bool allDayEvent( false );
- if (AgendaEntry::TypeAppoinment == entry.type() ||
- AgendaEntry::TypeEvent == entry.type()) {
- QDateTime startTime = entry.startTime();
- QDateTime stopTime = entry.endTime();
-
- int differenceInDays = startTime.daysTo(stopTime);
- if( startTime != stopTime &&
- startTime == CalenDateUtils::beginningOfDay( startTime ) &&
- stopTime == CalenDateUtils::beginningOfDay( stopTime ) &&
- differenceInDays >= 1 )
- {
- allDayEvent = true;
- }
- else
- {
- allDayEvent = false;
- }
- }
-
- TRACE_EXIT_POINT;
- return allDayEvent;
- }
+ TInt ret( EEqual );
+ CCalEntry::TStatus status1 = aEntry1.StatusL();
+ CCalEntry::TStatus status2 = aEntry2.StatusL();
+
+ if( status1 == CCalEntry::ENullStatus )
+ {
+ status1 = CCalEntry::ETodoNeedsAction;
+ }
+
+ if( status2 == CCalEntry::ENullStatus )
+ {
+ status2 = CCalEntry::ETodoNeedsAction;
+ }
+
+ if( status1 == status2 )
+ {
+ TTime time1 = aEntry1.EndTimeL().TimeUtcL();
+ TTime time2 = aEntry2.EndTimeL().TimeUtcL();
+
+ if( time1 == time2 )
+ {
+ const TUint pri1( aEntry1.PriorityL() );
+ const TUint pri2( aEntry2.PriorityL() );
+
+ if( pri1 == pri2 )
+ {
+ time1 = aEntry1.LastModifiedDateL().TimeUtcL();
+ time2 = aEntry2.LastModifiedDateL().TimeUtcL();
+
+ if( time1 == time2 )
+ {
+ ret = EEqual;
+ }
+ else if( time1 > time2 )
+ {
+ ret = EGreaterThan; // oldest first
+ }
+ else
+ {
+ ret = ELessThan;
+ }
+ }
+ else
+ {
+ if( pri1 > pri2 )
+ {
+ ret = EGreaterThan;
+ }
+ else
+ {
+ ret = ELessThan;
+ }
+ }
+ }
+ else
+ {
+ if( time1 > time2 )
+ {
+ ret = EGreaterThan;
+ }
+ else
+ {
+ ret = ELessThan;
+ }
+ }
+ }
+ else
+ {
+ if( status1 == CCalEntry::ETodoCompleted )
+ {
+ ret = EGreaterThan;
+ }
+ else
+ {
+ ret = ELessThan;
+ }
+ }
+
+ TRACE_EXIT_POINT;
+ return ret;
+ }
+
+// -----------------------------------------------------------------------------
+// CalenAgendaUtils::CompareNonTimedNotes
+// Compares two non-timed notes. Sort criteria:
+// 1. start time: oldest first
+// 2. last modified: oldest first
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TInt CalenAgendaUtils::CompareNonTimedNotesL( const CCalInstance& aInstance1,
+ const CCalInstance& aInstance2 )
+ {
+ TRACE_ENTRY_POINT;
+
+ TInt ret( EEqual );
+ TTime time1 = aInstance1.Time().TimeUtcL();
+ TTime time2 = aInstance2.Time().TimeUtcL();
+
+ if( time1 == time2 )
+ {
+ time1 = aInstance1.Entry().LastModifiedDateL().TimeUtcL();
+ time2 = aInstance2.Entry().LastModifiedDateL().TimeUtcL();
+
+ if( time1 == time2 )
+ {
+ ret = EEqual;
+ }
+ else if( time1 > time2 )
+ {
+ ret = EGreaterThan; // oldest first
+ }
+ else
+ {
+ ret = ELessThan;
+ }
+ }
+ else
+ {
+ if( time1 < time2 )
+ {
+ ret = ELessThan;
+ }
+ else
+ {
+ ret = EGreaterThan;
+ }
+ }
+
+ TRACE_EXIT_POINT;
+ return ret;
+ }
+
+// -----------------------------------------------------------------------------
+// CalenAgendaUtils::CompareTimedNotes
+// Compares two non-timed notes. Sort criteria:
+// 1. start time: oldest first
+// 2. duration: shortest first
+// 3. last modified: oldest first
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TInt CalenAgendaUtils::CompareTimedNotesL( const CCalInstance& aInstance1,
+ const CCalInstance& aInstance2 )
+ {
+ TRACE_ENTRY_POINT;
+
+ TInt ret( EEqual );
+ TTime time1 = aInstance1.Time().TimeUtcL();
+ TTime time2 = aInstance2.Time().TimeUtcL();
+
+ if( time1 == time2 )
+ {
+ TTimeIntervalMinutes duration1;
+ TTimeIntervalMinutes duration2;
+ aInstance1.EndTimeL().TimeUtcL().MinutesFrom( aInstance1.StartTimeL().TimeUtcL(), duration1 );
+ aInstance2.EndTimeL().TimeUtcL().MinutesFrom( aInstance2.StartTimeL().TimeUtcL(), duration2 );
+
+ if( duration1 == duration2 )
+ {
+ time1 = aInstance1.Entry().LastModifiedDateL().TimeUtcL();
+ time2 = aInstance2.Entry().LastModifiedDateL().TimeUtcL();
+
+ if( time1 == time2 )
+ {
+ ret = EEqual;
+ }
+ else if( time1 > time2 )
+ {
+ ret = EGreaterThan; // oldest first
+ }
+ else
+ {
+ ret = ELessThan;
+ }
+ }
+ else
+ {
+ if( duration1 < duration2 )
+ {
+ ret = ELessThan;
+ }
+ else
+ {
+ ret = EGreaterThan;
+ }
+ }
+ }
+ else
+ {
+ if( time1 < time2 )
+ {
+ ret = ELessThan;
+ }
+ else
+ {
+ ret = EGreaterThan;
+ }
+ }
+
+ TRACE_EXIT_POINT;
+ return ret;
+ }
+
+EXPORT_C TTimeIntervalMinutes CalenAgendaUtils::DurationL( const CCalEntry& aEntry )
+ {
+ TRACE_ENTRY_POINT;
+
+ TTimeIntervalMinutes duration;
+
+ const TTime start = aEntry.StartTimeL().TimeUtcL();
+ const TTime end = aEntry.EndTimeL().TimeUtcL();
+ end.MinutesFrom( start, duration );
+
+ TRACE_EXIT_POINT;
+ return duration;
+ }
+
+
+EXPORT_C TTime CalenAgendaUtils::EntryTimeL( const CCalEntry& aEntry )
+ {
+ TRACE_ENTRY_POINT;
+
+ // FIXME: instance time!
+ TTime entryTime;
+
+ if( aEntry.EntryTypeL() == CCalEntry::ETodo )
+ {
+ entryTime = aEntry.EndTimeL().TimeLocalL();
+ }
+ else
+ {
+ entryTime = aEntry.StartTimeL().TimeLocalL();
+ }
+
+ if ( entryTime == Time::NullTTime() )
+ {
+ TTime today;
+ today.HomeTime();
+ entryTime = today;
+ }
+
+ //FIXME: should we add one more step
+ // entryTime = CalenDateUtils::LimitToValidRange( entryTime );
+ TRACE_EXIT_POINT;
+ return entryTime;
+ }
+
+EXPORT_C TBool CalenAgendaUtils::IsTimedEntryL( CCalEntry::TType aType )
+ {
+ TRACE_ENTRY_POINT;
+
+ TRACE_EXIT_POINT;
+ return aType == CCalEntry::EAppt || aType == CCalEntry::EReminder;
+ }
+
+// ---------------------------------------------------------
+// CCalenDayOnlyEventContainer::IsRepeatingL
+// (other items were commented in a header).
+// ---------------------------------------------------------
+//
+EXPORT_C TBool CalenAgendaUtils::IsRepeatingL( const CCalEntry& aEntry )
+ {
+ TRACE_ENTRY_POINT;
+
+ TBool isRepeating = EFalse;
+ RArray<TCalTime> rdates;
+ CleanupClosePushL( rdates );
+ aEntry.GetRDatesL( rdates );
+ TBool isRDate = rdates.Count() > 0;
+ CleanupStack::PopAndDestroy(); // rdates
+
+ TCalRRule newRule;
+
+ if ( ( isRDate ) || ( aEntry.GetRRuleL(newRule) && newRule.Type() != TCalRRule::EInvalid ) )
+ {
+ isRepeating = ETrue;
+ }
+
+ TRACE_EXIT_POINT;
+ return isRepeating;
+ }
+
+EXPORT_C TBool CalenAgendaUtils::IsEmptyText(const TDesC& aDes)
+ {
+ TRACE_ENTRY_POINT;
+
+ TBool empty = ETrue;
+ TInt length = aDes.Length();
+ for(TUint i = 0; i < length; ++i)
+ {
+ if( !VersitUtils::IsWhiteSpace(aDes.operator[](i)) )
+ {
+ empty = EFalse;
+ break;
+ }
+ }
+
+ TRACE_EXIT_POINT;
+ return empty;
+ }
// End of File