diff -r 96907930389d -r 12af337248b1 calendarui/caleneditor/src/caleneditorreminderfield.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/calendarui/caleneditor/src/caleneditorreminderfield.cpp	Tue Aug 31 15:13:43 2010 +0300
@@ -0,0 +1,884 @@
+/*
+* Copyright (c) 2010 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:
+* Definition of CalenEditorReminderField class.
+*
+*/
+
+
+// System Includes
+#include <QDate>
+
+#include <hbdataformmodelitem.h>
+#include <hbdataformmodel.h>
+#include <hbdataform.h>
+#include <hbdatetimepicker.h>
+#include <hbextendedlocale.h>
+#include <hbi18ndef.h>
+#include <hbdialog.h>
+#include <hblabel.h>
+#include <hbaction.h>
+
+// User Includes
+#include "calenagendautils.h"
+#include "caleneditorreminderfield.h"
+#include "OstTraceDefinitions.h"
+#ifdef OST_TRACE_COMPILER_IN_USE
+#include "caleneditorreminderfieldTraces.h"
+#endif
+
+
+#define numberOfMinutesInADay 1440
+/*!
+	\class CalenEditorReminderField
+ */
+/*!
+	Constructor.
+
+	\param parent QObject pointer
+ */
+
+CalenEditorReminderField::CalenEditorReminderField(
+										CalenEditorPrivate* calenEditor,
+										HbDataForm* form, 
+										HbDataFormModel* model,
+										QObject *parent)
+	:QObject(parent),
+	 mCalenEditor(calenEditor), 
+	 mEditorForm(form), 
+	 mCalenEditorModel(model),
+	 mCustomReminderTimeItem(0),
+	 mReminderTimeAdded(false)
+{
+	OstTraceFunctionEntry0( CALENEDITORREMINDERFIELD_CALENEDITORREMINDERFIELD_ENTRY );
+	mReminderItem = new HbDataFormModelItem();
+	mReminderItem->setType(HbDataFormModelItem::ComboBoxItem);
+	mReminderItem->setData(HbDataFormModelItem::LabelRole,
+						   hbTrId("txt_calendar_setlabel_reminder"));	
+	// Add it to the model
+	mCalenEditorModel->appendDataFormItem(mReminderItem,
+										mCalenEditorModel->invisibleRootItem());
+	OstTraceFunctionExit0( CALENEDITORREMINDERFIELD_CALENEDITORREMINDERFIELD_EXIT );
+}
+
+/*!
+	 Destructor
+ */
+CalenEditorReminderField::~CalenEditorReminderField()
+{
+	OstTraceFunctionEntry0( DUP1_CALENEDITORREMINDERFIELD_CALENEDITORREMINDERFIELD_ENTRY );
+	if(mReminderHash.count()) {
+		mReminderHash.clear();
+	}
+	OstTraceFunctionExit0( DUP1_CALENEDITORREMINDERFIELD_CALENEDITORREMINDERFIELD_EXIT );
+}
+
+/*!
+	 Set the reminder choices.
+ */
+void CalenEditorReminderField::setReminderChoices()
+{
+	OstTraceFunctionEntry0( CALENEDITORREMINDERFIELD_SETREMINDERCHOICES_ENTRY );
+	
+	// Disconnect the slot and connect it back again at end to avoid unnecessary
+	// calls to handleReminderIndexChanged slot. Or else the slot gets called 
+	// when we add all of items to the repeat combobox.
+	mEditorForm->removeConnection(mReminderItem,
+							SIGNAL(currentIndexChanged(int)), this,
+							SLOT(handleReminderIndexChanged(int)));
+	// Create the reminder choices
+	QStringList reminderChoices;
+	reminderChoices << hbTrId("txt_calendar_setlabel_reminder_val_off")
+				<< hbTrId("txt_calendar_setlabel_reminder_val_at_the_start")
+				<< hbTrId("txt_calendar_setlabel_reminder_val_15_minutes_befo")
+				<< hbTrId("txt_calendar_setlabel_reminder_val_30_minutes_befo")
+				<< hbTrId("txt_calendar_setlabel_reminder_val_1_hour_before");
+
+	mReminderItem->setContentWidgetData("items", reminderChoices);
+	mReminderItem->setEnabled(true);
+	
+	mEditorForm->addConnection(mReminderItem,
+							SIGNAL(currentIndexChanged(int)), this,
+							SLOT(handleReminderIndexChanged(int)));
+	OstTraceFunctionExit0( CALENEDITORREMINDERFIELD_SETREMINDERCHOICES_EXIT );
+}
+
+/*!
+	 Adds reminder item to the model
+ */
+void CalenEditorReminderField::addItemToModel()
+{	
+	OstTraceFunctionEntry0( CALENEDITORREMINDERFIELD_ADDITEMTOMODEL_ENTRY );
+	// Add reminder to the model
+	mCalenEditorModel->appendDataFormItem( mReminderItem,
+				   mCalenEditorModel->invisibleRootItem());
+	OstTraceFunctionExit0( CALENEDITORREMINDERFIELD_ADDITEMTOMODEL_EXIT );
+}
+
+/*!
+	 Removes reminder item from the model
+ */
+void CalenEditorReminderField::removeItemFromModel()
+{
+	OstTraceFunctionEntry0( CALENEDITORREMINDERFIELD_REMOVEITEMFROMMODEL_ENTRY );
+	mCalenEditorModel->removeItem(modelIndex());
+	OstTraceFunctionExit0( CALENEDITORREMINDERFIELD_REMOVEITEMFROMMODEL_EXIT );
+}
+
+/*!
+	 Set the current reminder index with the value which was saved 
+	 before, if it is valid or else default the value to 15MinsBefore
+	 or AtTheStart whichever is appropriate
+ */
+void CalenEditorReminderField::setSavedMeetingReminderIndex()
+{
+	// Get the reminder offset value.
+	int reminderOffset =
+	mCalenEditor->editedEntry()->alarm().timeOffset();
+	// Get the index value for the reminder combo box from the hash 
+	// table. 2nd argument is defaultKey if the hash contains no item mapped to value
+	//TODO: Need to confirm the default reminder to set if none of the choices are met like in case of synch from outlook.
+	int index = mReminderHash.key(reminderOffset, Reminder15MinsBefore); 
+	
+	if (index < reminderItemsCount())
+		setCurrentIndex(index);
+	else if (reminderItemsCount() == (ReminderAtStart + 1)) //+1 because enum starts from 0.
+		setCurrentIndex(ReminderAtStart); 
+	else
+		setCurrentIndex(Reminder15MinsBefore);
+}
+
+/*!
+	 Populates reminder item with available choices to the user
+	 \param newEntry bool value to indicate if its a new entry
+ */
+void CalenEditorReminderField::populateReminderItem(bool newEntry)
+{
+	OstTraceFunctionEntry0( CALENEDITORREMINDERFIELD_POPULATEREMINDERITEM_ENTRY );
+	AgendaAlarm reminder;
+	bool pastEvent =  false;
+	bool repeatingEntry = false;
+	bool sameDay = false;
+	
+	mReminderItem->setContentWidgetData("objectName", "remainderItem");
+	// Build the hash map for the reminder.
+	mReminderHash[ReminderOff] = -1; // OFF.
+	mReminderHash[ReminderAtStart] = 0;
+	mReminderHash[Reminder15MinsBefore] = 15;
+	mReminderHash[Reminder30MinsBefore] = 30;
+	mReminderHash[Reminder1HourBefore] = 60;
+	    
+	// Set reference date to start date or repeat until date accordingly to 
+	// decide whether its a past event or not.
+	QDate referenceDate;
+	if (!mCalenEditor->editedEntry()->isRepeating() || 
+					(mCalenEditor->isEditRangeThisOnly())) {
+		referenceDate = mCalenEditor->editedEntry()->startTime().date();
+	} else {
+		referenceDate = mCalenEditor->editedEntry()->repeatRule().until().date();
+		repeatingEntry = true;
+	}
+	
+	if ((referenceDate < QDate::currentDate()) || 
+					(referenceDate == QDate::currentDate()
+					&& (mCalenEditor->editedEntry()->startTime().time() < 
+					QTime::currentTime()))) {
+		pastEvent = true;
+	}
+	
+	if (mCalenEditor->isAllDayEvent()) {
+		updateReminderChoicesForAllDay(referenceDate);
+	} else {
+		if((referenceDate == QDate::currentDate())
+					&& !pastEvent) {
+			UpdateReminderChoicesForSameDay(mCalenEditor->editedEntry()->startTime().time());
+			sameDay = true;
+		}
+		else {
+		setReminderChoices();
+		}
+	}
+	// Set the default reminder value to 15 minutes 
+	if (newEntry) {
+		if (!pastEvent) {
+			int defaultIndex = Reminder15MinsBefore;
+			if (reminderItemsCount() == (ReminderAtStart + 1))  //If 15MinsBefore option is not available
+				defaultIndex = ReminderAtStart;
+		
+			setCurrentIndex(defaultIndex);
+			// Save the reminder alarm for the entry
+			reminder.setTimeOffset(mReminderHash.value(defaultIndex));
+			reminder.setAlarmSoundName(QString(" "));
+			// Set the reminder to the entry as well as original entry.
+			mCalenEditor->editedEntry()->setAlarm(reminder);
+			mCalenEditor->originalEntry()->setAlarm(reminder);
+		} else {
+			setReminderOff();
+		}
+	} else {
+        int offsetInMins = mCalenEditor->editedEntry()->alarm().timeOffset();
+		// If the alarm is not null,
+		// Check if all day event or not and then set the choices accordingly.
+		if (mCalenEditor->editedEntry()->alarm().isNull()) {
+			// Alarm is set off
+			setCurrentIndex(ReminderOff);
+			if(mReminderTimeAdded) {
+				removeReminderTimeField();
+			}
+		} else if (!mCalenEditor->isAllDayEvent()) {
+			QTime currentTime = QTime::currentTime();
+
+			//TODO: Still need confirmation for proper behaviour when entry is edited after alarm has expired.
+			if (!repeatingEntry && sameDay && (currentTime.addSecs(offsetInMins * 60) >= mCalenEditor->editedEntry()->startTime().time())) {
+				setCurrentIndex(ReminderOff); //Alarm has expired already, so making it off.
+				//The slot for index 0 is not called, since after UpdateReminderChoicesForSameDay()
+				//index is 0 itself and there is no change. So explicitly calling it here.
+				handleReminderIndexChanged(0); 
+			}
+			else {
+				setSavedMeetingReminderIndex();
+			}
+		} else {
+			// Insert reminder time field and display entry's reminder time.
+			// If past then disable the field.
+			if (!mReminderTimeAdded) {
+				insertReminderTimeField();
+			}
+			if (pastEvent && mReminderTimeAdded) {
+				mCustomReminderTimeItem->setEnabled(false);
+			}
+			// Get the appropriate reminder index depending on the value of time offset.
+			int index = getReminderIndexBasedOnEntryAlarm();
+			mReminderItem->setContentWidgetData("currentIndex", index);
+			setDisplayTime();
+		}
+		if (pastEvent) {
+			mReminderItem->setEnabled(false);
+		}
+	}
+	mEditorForm->addConnection(mReminderItem,
+							SIGNAL(currentIndexChanged(int)), this,
+							SLOT(handleReminderIndexChanged(int)));
+	OstTraceFunctionExit0( CALENEDITORREMINDERFIELD_POPULATEREMINDERITEM_EXIT );
+}
+
+/*!
+	Triggered from tapping on reminder item.
+	Handles the reminder time change and updates the same in the event.
+	\param index The new index chosen in the reminder list.
+ */
+void CalenEditorReminderField::handleReminderIndexChanged(int index)
+{
+	OstTraceFunctionEntry0( CALENEDITORREMINDERFIELD_HANDLEREMINDERINDEXCHANGED_ENTRY );
+	AgendaAlarm reminder;
+	if (!mCalenEditor->editedEntry()->alarm().isNull()) {
+		reminder = mCalenEditor->editedEntry()->alarm();
+	}
+	// Check whether all day event or not and store appropriately.
+	if (!mCalenEditor->isAllDayEvent()) {
+		// If value for the index in hash table is -1 i.e reminder is "OFF",
+		// then set the default constructed reminder to
+		// the entry which is Null.
+		if (mReminderHash.value(index) < 0) {
+			// Construct the default alarm which is NULL
+			reminder = AgendaAlarm();
+		} else {
+			// If not zero then set the reminder offset
+			// value to the entry.
+			reminder.setTimeOffset(mReminderHash.value(index));
+			reminder.setAlarmSoundName(QString(" "));
+		}
+	} else {
+		QDateTime reminderDateTimeForAllDay;
+		QDateTime
+		        startDateTimeForAllDay(
+		                               mCalenEditor->editedEntry()->startTime().date(),
+		                               QTime(0, 0, 0));
+		if (mReminderItem->contentWidgetData("currentIndex") == ReminderOff) {
+			reminder = AgendaAlarm();
+			removeReminderTimeField();
+		} else {
+			int offset = 0;
+			if (mReminderItem->contentWidgetData("currentIndex") == ReminderOneDayBefore) {
+				offset = 1;
+			} else if (mReminderItem->contentWidgetData("currentIndex") == ReminderTwoDaysBefore) {
+				offset = 2;
+			}
+			if(!mReminderTimeAdded) {
+				insertReminderTimeField();
+			}
+			// If on same day as that of the event then check if time has been 
+			// changed , if changed retain that else set default time.
+			if (offset == 0) {
+				if(mReminderTimeForAllDay == QTime(18, 0, 0, 0)) {
+					mReminderTimeForAllDay.setHMS(8, 0, 0);
+				}
+			}else {
+				// For the reminder options other than ReminderOnEventDay
+				// reset the default values since the time set for one option 
+				// may not be valid for the other option
+				mReminderTimeForAllDay.setHMS(18, 0, 0, 0);
+			}
+			setDisplayTime();
+			reminderDateTimeForAllDay.setDate(
+					mCalenEditor->editedEntry()->startTime().date().addDays(
+																	-offset));
+			reminderDateTimeForAllDay.setTime(mReminderTimeForAllDay);
+			int seconds =
+					reminderDateTimeForAllDay.secsTo(startDateTimeForAllDay);
+			int timeOffset = seconds / 60;
+			mCustomReminderTimeItem->setEnabled(true);
+			reminder.setTimeOffset(timeOffset);
+			reminder.setAlarmSoundName(QString(" "));
+		}
+	}
+	// Set the reminder to the entry.
+	mCalenEditor->editedEntry()->setAlarm(reminder);
+	if(!mCalenEditor->isNewEntry()) {
+	mCalenEditor->addDiscardAction();
+	}
+	OstTraceFunctionExit0( CALENEDITORREMINDERFIELD_HANDLEREMINDERINDEXCHANGED_EXIT );
+}
+
+/*!
+	 Returns the mode index of the reminder item
+	 \return Mode index of the reminder item
+ */
+QModelIndex CalenEditorReminderField::modelIndex()
+{
+	OstTraceFunctionEntry0( CALENEDITORREMINDERFIELD_MODELINDEX_ENTRY );
+	return mCalenEditorModel->indexFromItem(mReminderItem);
+}
+
+/*!
+	 Set reminder off.
+ */
+void CalenEditorReminderField::setReminderOff()
+{
+	OstTraceFunctionEntry0( CALENEDITORREMINDERFIELD_SETREMINDEROFF_ENTRY );
+	// Create the remindar choices
+	QStringList reminderChoices;
+	reminderChoices << hbTrId("txt_calendar_setlabel_reminder_val_off");
+	mReminderItem->setContentWidgetData(QString("items"), reminderChoices);
+	mReminderItem->setEnabled(false); 
+	OstTraceFunctionExit0( CALENEDITORREMINDERFIELD_SETREMINDEROFF_EXIT );
+}
+
+/*!
+	 Set the default alarm for a new all day event.
+ */
+void CalenEditorReminderField::setDefaultAlarmForAllDay()
+{	
+	OstTraceFunctionEntry0( CALENEDITORREMINDERFIELD_SETDEFAULTALARMFORALLDAY_ENTRY );
+	// Set default alarm if its a new entry.
+	if (mCalenEditor->isNewEntry()) {
+		AgendaAlarm reminder;
+		QDate defaultDate
+				(mCalenEditor->editedEntry()->startTime().date().addDays(-1));
+		// Set default time as 6pm of the previous day.
+		mReminderTimeForAllDay.setHMS(18, 0, 0, 0);
+		setDisplayTime();
+		QDateTime startDateTimeForAllDay(
+				mCalenEditor->editedEntry()->startTime().date(), QTime(0, 0));
+		QDateTime defaultReminderDateTimeForAllDay
+				(defaultDate, mReminderTimeForAllDay);
+		int offsetInSecs = 
+				defaultReminderDateTimeForAllDay.secsTo(startDateTimeForAllDay);
+		int offsetInMins = offsetInSecs/60;
+		reminder.setTimeOffset(offsetInMins);
+		reminder.setAlarmSoundName(QString(" "));
+		// Set the reminder to the entry as well as original entry.
+		mCalenEditor->editedEntry()->setAlarm(reminder);
+		mCalenEditor->originalEntry()->setAlarm(reminder);
+	}
+	OstTraceFunctionExit0( CALENEDITORREMINDERFIELD_SETDEFAULTALARMFORALLDAY_EXIT );
+}
+
+/*!
+	 Update the reminder choices when the meeting is on same day, 
+	 based on the time available from current time to start time of the event.
+ */
+void CalenEditorReminderField::UpdateReminderChoicesForSameDay(QTime startTime)
+{
+	QTime currentTime = QTime::currentTime();
+	int offset = currentTime.secsTo(startTime);
+
+	// Disconnect the slot and connect it back again at end to avoid unnecessary
+	// calls to handleReminderIndexChanged slot. Or else the slot gets called 
+	// when we add all of items to the repeat combobox.
+	mEditorForm->removeConnection(mReminderItem,
+							SIGNAL(currentIndexChanged(int)), this,
+							SLOT(handleReminderIndexChanged(int)));
+
+	//The event start time is within 15mins from current time of today,
+	//then we cannot have alarms "15 mins before", "30mins before" and "1 hour before"
+	if (offset <= SecsIn15Mins)
+	{
+		QStringList reminderChoices;
+		//First to clear all items, we just set items with empty list.
+		mReminderItem->setContentWidgetData("items", reminderChoices); 
+		reminderChoices << hbTrId("txt_calendar_setlabel_reminder_val_off")
+				<< hbTrId("txt_calendar_setlabel_reminder_val_at_the_start");
+		mReminderItem->setContentWidgetData("items", reminderChoices);
+	}
+	//The event start time is within half and hour from current time of today
+	//then we cannot have alarms "30mins before" and "1 hour before"
+	else if (offset <= SecsIn30Mins)
+	{
+		QStringList reminderChoices;
+		//First to clear all items, we just set items with empty list.
+		mReminderItem->setContentWidgetData("items", reminderChoices);
+		reminderChoices << hbTrId("txt_calendar_setlabel_reminder_val_off")
+				<< hbTrId("txt_calendar_setlabel_reminder_val_at_the_start")
+				<< hbTrId("txt_calendar_setlabel_reminder_val_15_minutes_befo");
+		mReminderItem->setContentWidgetData("items", reminderChoices);
+	}
+	//The event start time is within an hour of the current time of today,
+	//then cannot have alarm "1 hour before".
+	else if (offset <= SecsInOneHour)
+	{
+		QStringList reminderChoices;
+		//First to clear all items, we just set items with empty list.
+		mReminderItem->setContentWidgetData("items", reminderChoices);
+		reminderChoices << hbTrId("txt_calendar_setlabel_reminder_val_off")
+				<< hbTrId("txt_calendar_setlabel_reminder_val_at_the_start")
+				<< hbTrId("txt_calendar_setlabel_reminder_val_15_minutes_befo")
+				<< hbTrId("txt_calendar_setlabel_reminder_val_30_minutes_befo");
+		mReminderItem->setContentWidgetData("items", reminderChoices);
+	}
+	// The event start time is more than one hour from current time 
+	// then we can have all choices for alarm.
+	else
+	{
+		QStringList reminderChoices;
+		//First to clear all items, we just set items with empty list.
+		mReminderItem->setContentWidgetData("items", reminderChoices);
+		reminderChoices << hbTrId("txt_calendar_setlabel_reminder_val_off")
+				<< hbTrId("txt_calendar_setlabel_reminder_val_at_the_start")
+				<< hbTrId("txt_calendar_setlabel_reminder_val_15_minutes_befo")
+				<< hbTrId("txt_calendar_setlabel_reminder_val_30_minutes_befo")
+				<< hbTrId("txt_calendar_setlabel_reminder_val_1_hour_before");
+		mReminderItem->setContentWidgetData("items", reminderChoices);
+	}
+	mReminderItem->setEnabled(true);
+	mEditorForm->addConnection(mReminderItem,
+							SIGNAL(currentIndexChanged(int)), this,
+							SLOT(handleReminderIndexChanged(int)));
+}
+
+/*!
+	 Updates the reminder choices for an all day event.
+	 \param referenceDate to indicate past or not.
+ */
+void CalenEditorReminderField::updateReminderChoicesForAllDay(QDate referenceDate)
+{
+	OstTraceFunctionEntry0( CALENEDITORREMINDERFIELD_UPDATEREMINDERCHOICESFORALLDAY_ENTRY );
+	if (!mReminderTimeAdded){
+		insertReminderTimeField();
+	}
+	// This functions rearranges the reminder options based on the date and time
+	// To avoid the unecessary call to handleReminderIndexChanged 
+	// the connection is removed.
+	mEditorForm->removeConnection(mReminderItem,
+								SIGNAL(currentIndexChanged(int)), this,
+								SLOT(handleReminderIndexChanged(int)));
+	
+	// Since the combox box is not updated as per the current datetime
+	// there can be a conflict between the previousIndex set on the combobox
+	// and the actual index. This comes while populating an existing entry.
+	// So the index has to be taken from the entry alarm 
+	
+	AgendaAlarm actualAlarm = mCalenEditor->editedEntry()->alarm();
+	// Get the actual alarm index from the entry alarm which is been set
+	int actualIndex = getReminderIndexBasedOnEntryAlarm();
+	int offsetInMins = actualAlarm.timeOffset();
+
+	// Calculate the alarm time
+	QDateTime alarmDateTime;
+	alarmDateTime.setDate(referenceDate);
+	alarmDateTime.setTime(mCalenEditor->editedEntry()->startTime().time());
+	QTime checkTime = alarmDateTime.time().addSecs(-(offsetInMins * 60));
+	alarmDateTime.setTime(checkTime);
+	
+	// The combox is updated based on the reference date which is beed passed.
+	// And the reminder time has to be set acoordingly
+	QStringList reminderChoicesForAllDay;
+	QDate tomorrow = QDate::currentDate().addDays(1);
+	QDate theDayAfterTomorrow = QDate::currentDate().addDays(2);
+
+	// If the event is on a past date the default alarm will be off.
+	if (referenceDate < QDate::currentDate() || 
+			referenceDate == QDate::currentDate()) {
+		// Set reminder off for past event.
+		reminderChoicesForAllDay << hbTrId("txt_calendar_setlabel_reminder_val_off");
+		mReminderItem->setContentWidgetData(QString("items"), 
+		                                    reminderChoicesForAllDay);
+		mReminderItem->setEnabled(false);		
+		// Remove the reminder field if it was added
+		if(mReminderTimeAdded) {
+			removeReminderTimeField();
+		}
+	} else if (theDayAfterTomorrow < referenceDate) {
+		// If the event is on a future date which is two days after the current date
+		// The options are off, on event day, 1 day before and 2 days before
+		reminderChoicesForAllDay 
+			<< hbTrId("txt_calendar_setlabel_reminder_val_off")
+			<< hbTrId("txt_calendar_setlabel_reminder_val_on_event_day")
+			<< hbTrId("txt_calendar_setlabel_reminder_val_1_day_before")
+			<< hbTrId("txt_calendar_setlabel_reminder_val_2_days_before");
+		mReminderItem->setEnabled(true);
+		mCustomReminderTimeItem->setEnabled(true);
+		mReminderItem->setContentWidgetData(QString("items"), 
+		                                    reminderChoicesForAllDay);
+	} else if (theDayAfterTomorrow == referenceDate) {
+		// If the event is on a future date which is two days after the current date
+		// If the current time is before 6.00 pm (default for 2 days before)
+		// The options are off, on event day, 1 day before and 2 days before
+		if (QTime::currentTime() < QTime(18, 0, 0, 0)) {
+			reminderChoicesForAllDay 
+				<< hbTrId("txt_calendar_setlabel_reminder_val_off")
+				<< hbTrId("txt_calendar_setlabel_reminder_val_on_event_day")
+				<< hbTrId("txt_calendar_setlabel_reminder_val_1_day_before")
+				<< hbTrId("txt_calendar_setlabel_reminder_val_2_days_before");
+		}else {
+			// If the event is on a future date which is two days after the current date
+			// the current time is after 6.00 pm (default for 2 days before)
+			// If its after the default time don't show the 2 days before option
+			reminderChoicesForAllDay 
+				<< hbTrId("txt_calendar_setlabel_reminder_val_off")
+				<< hbTrId("txt_calendar_setlabel_reminder_val_on_event_day")
+				<< hbTrId("txt_calendar_setlabel_reminder_val_1_day_before");
+		}
+		mReminderItem->setEnabled(true);
+		mCustomReminderTimeItem->setEnabled(true);
+		mReminderItem->setContentWidgetData(QString("items"), 
+		                                    reminderChoicesForAllDay);
+	}else if (QTime::currentTime() < QTime(18, 0, 0, 0)) {
+		// If the event is on a future date which is one day after the current date
+		// and current time is before 6.00 pm.
+		// The options are off, on event day and 1 day before
+		reminderChoicesForAllDay 
+			<< hbTrId("txt_calendar_setlabel_reminder_val_off")
+			<< hbTrId("txt_calendar_setlabel_reminder_val_on_event_day")
+			<< hbTrId("txt_calendar_setlabel_reminder_val_1_day_before");
+		mReminderItem->setEnabled(true);
+		mCustomReminderTimeItem->setEnabled(true);
+		mReminderItem->setContentWidgetData(QString("items"), 
+		                                    reminderChoicesForAllDay);
+	}else {
+		// If the event is on a future date which is one day after the current date
+		// and current time is after 6.00 pm.
+		// The options are off and on event day
+		reminderChoicesForAllDay 
+			<< hbTrId("txt_calendar_setlabel_reminder_val_off")
+			<< hbTrId("txt_calendar_setlabel_reminder_val_on_event_day");
+		mReminderItem->setEnabled(true);
+		mCustomReminderTimeItem->setEnabled(true);
+		mReminderItem->setContentWidgetData(QString("items"), 
+		                                    reminderChoicesForAllDay);
+	}
+	// Get the count of the reminder options after the rearrangement 
+	// based on the date and time 
+	int count = reminderItemsCount();
+	// Set the reminder index
+	
+	if (count <= actualIndex || 
+			alarmDateTime < QDateTime::currentDateTime() || 
+			actualIndex == ReminderOff) {
+		// This will be executed when the actual index is not 
+		// available in the combobox or the alarm time is already passed
+		// or the actual alarm is off
+		// So set it as off
+		mReminderItem->setContentWidgetData("currentIndex", ReminderOff);
+		actualAlarm = AgendaAlarm();
+		mCalenEditor->editedEntry()->setAlarm(actualAlarm);
+		removeReminderTimeField();
+	}else {
+		// Set the actual reminder index
+		mReminderItem->setContentWidgetData("currentIndex", actualIndex);
+		if( actualIndex != ReminderOff) {
+			if(!mReminderTimeAdded) {
+				insertReminderTimeField();
+			}
+			mCalenEditor->editedEntry()->setAlarm(actualAlarm);
+			// Get the alarm time from the offset
+			QTime alarmTime = alarmDateTime.time();
+			// Set the alarm time and display it on the button
+			mReminderTimeForAllDay.setHMS(
+					alarmTime.hour(),alarmTime.minute(),alarmTime.second());
+			setDisplayTime();
+		}else {
+			actualAlarm = AgendaAlarm();
+			removeReminderTimeField();
+		}
+	}
+	// Connect the slot for the index change
+	mEditorForm->addConnection(mReminderItem,
+								SIGNAL(currentIndexChanged(int)), this,
+								SLOT(handleReminderIndexChanged(int)));
+
+	OstTraceFunctionExit0( CALENEDITORREMINDERFIELD_UPDATEREMINDERCHOICESFORALLDAY_EXIT );
+}
+
+/*!
+	 Gets the reminder index for all day events based on the alarm
+	 which is saved for the entry
+ */
+int CalenEditorReminderField::getReminderIndexBasedOnEntryAlarm()
+{
+	// Get the appropriate reminder index depending on the value of time offset.
+	AgendaAlarm actualAlarm = mCalenEditor->editedEntry()->alarm();
+	QTime referenceTime(0, 0, 0);
+	int index = ReminderOff;
+	int offsetInMins = actualAlarm.timeOffset();
+	if(offsetInMins == -1) {
+		index = ReminderOff;
+	}else if (offsetInMins < 0 || offsetInMins == 0) {
+		index = ReminderOnEventDay;
+		mReminderTimeForAllDay = referenceTime.addSecs(-(offsetInMins
+				* 60));
+	} else if (offsetInMins <= numberOfMinutesInADay) {
+		index = ReminderOneDayBefore;
+		mReminderTimeForAllDay = referenceTime.addSecs(-(offsetInMins
+				* 60));
+	} else {
+		index = ReminderTwoDaysBefore;
+		offsetInMins %= (24 * 60);
+		mReminderTimeForAllDay = referenceTime.addSecs(-(offsetInMins
+				* 60));
+	}
+	return index;
+}
+
+/*!
+	 Insert the reminder time field for an all day event.
+ */
+void CalenEditorReminderField::insertReminderTimeField()
+{
+	OstTraceFunctionEntry0( CALENEDITORREMINDERFIELD_INSERTREMINDERTIMEFIELD_ENTRY );
+	HbDataFormModelItem::DataItemType itemType =
+			static_cast<HbDataFormModelItem::DataItemType> (ReminderTimeOffset);
+	
+	// If all day item is not added then insert at one level before.
+	int index = CalenEditorPrivate::ReminderTimeForAllDayItem;
+	if(!mCalenEditor->isAllDayFieldAdded()) {
+		index = CalenEditorPrivate::ReminderTimeForAllDayItem - 1;
+	} 
+	mCustomReminderTimeItem = mCalenEditorModel->insertDataFormItem(
+							index,
+							itemType,
+							QString(hbTrId("txt_calendar_setlabel_reminder_time")),
+							mCalenEditorModel->invisibleRootItem());
+	if (currentReminderIndex() != 1){
+		mReminderTimeForAllDay.setHMS(18,0,0,0);
+	} else {
+		mReminderTimeForAllDay.setHMS(8,0,0,0);
+	}
+	
+	mEditorForm->addConnection(mCustomReminderTimeItem, SIGNAL(clicked()),
+	                           this, SLOT(launchReminderTimePicker()));
+	setDisplayTime();
+	mReminderTimeAdded = true;
+	OstTraceFunctionExit0( CALENEDITORREMINDERFIELD_INSERTREMINDERTIMEFIELD_EXIT );
+}
+
+/*!
+	 Set the reminder time selected by the user.
+ */
+void CalenEditorReminderField::setDisplayTime()
+{
+	OstTraceFunctionEntry0( CALENEDITORREMINDERFIELD_SETDISPLAYTIME_ENTRY );
+	HbExtendedLocale locale = HbExtendedLocale::system();
+	QString timeString = locale.format(
+			mReminderTimeForAllDay,
+			r_qtn_time_usual_with_zero);
+	mCustomReminderTimeItem->setContentWidgetData("text", timeString);
+	OstTraceFunctionExit0( CALENEDITORREMINDERFIELD_SETDISPLAYTIME_EXIT );
+}
+
+/*!
+	Remove the reminder time field if its not an all day event.
+ */
+void CalenEditorReminderField::removeReminderTimeField()
+{
+	OstTraceFunctionEntry0( CALENEDITORREMINDERFIELD_REMOVEREMINDERTIMEFIELD_ENTRY );
+	mReminderTimeAdded = false;
+	mEditorForm->removeConnection(mCustomReminderTimeItem, SIGNAL(clicked()),
+		                           this, SLOT(launchReminderTimePicker()));
+	if (mCustomReminderTimeItem) {
+		QModelIndex reminderIndex =
+				mCalenEditorModel->indexFromItem(mCustomReminderTimeItem);
+		mCalenEditorModel->removeItem(
+				mCalenEditorModel->index(
+						reminderIndex.row(), 0));
+		mCustomReminderTimeItem = 0;
+	}
+	OstTraceFunctionExit0( CALENEDITORREMINDERFIELD_REMOVEREMINDERTIMEFIELD_EXIT );
+}
+
+/*!
+	 Launches time picker to select time.
+ */
+void CalenEditorReminderField::launchReminderTimePicker()
+{
+	OstTraceFunctionEntry0( CALENEDITORREMINDERFIELD_LAUNCHREMINDERTIMEPICKER_ENTRY );
+	
+	HbDialog *popUp = new HbDialog();
+	popUp->setDismissPolicy(HbDialog::NoDismiss);
+	popUp->setTimeout(HbDialog::NoTimeout);
+	popUp->setAttribute( Qt::WA_DeleteOnClose, true );
+	popUp->setHeadingWidget( new HbLabel(
+				hbTrId("Reminder Time")));
+	
+	HbExtendedLocale locale = HbExtendedLocale::system();
+	mTimePicker = new HbDateTimePicker(mReminderTimeForAllDay);
+	// Set the display format
+	if(locale.timeStyle() == HbExtendedLocale::Time12) {
+		mTimePicker->setDisplayFormat("hh:mm ap");	
+	}else {
+		mTimePicker->setDisplayFormat("hh:mm");
+	}
+	
+	// Check if the entry is repeating based on the repeatuntil item
+	if(!mCalenEditor->isRepeatUntilItemAdded()) {
+		int index = currentReminderIndex();
+		QDate checkDate = mCalenEditor->editedEntry()->startTime().date();
+		// Restrict the time picker to show the valid time 
+		// depending on the reminder options
+		// Take an offset of 5 mins
+		QTime minTime = QTime::currentTime().addSecs(5 * 60);
+		if(index == ReminderTwoDaysBefore &&  checkDate.addDays(-2) == QDate::currentDate()) {
+				mTimePicker->setMinimumTime(minTime);
+		}else if(index == ReminderOneDayBefore && checkDate.addDays(-1) == QDate::currentDate()) {
+				mTimePicker->setMinimumTime(minTime);
+		}else if(index == ReminderOnEventDay && checkDate == QDate::currentDate()) {
+				mTimePicker->setMinimumTime(minTime);
+		}
+	}
+	mTimePicker->setTime(mReminderTimeForAllDay);
+	popUp->setContentWidget(mTimePicker);
+	
+	HbAction *okAction = new HbAction(hbTrId("txt_common_button_ok"), popUp);
+	popUp->addAction(okAction);
+	connect(okAction, SIGNAL(triggered()), this, SLOT(setReminderTimeForAllDay()));
+	popUp->addAction(new HbAction(hbTrId("txt_common_button_cancel"),
+	                                      popUp));
+	popUp->open();
+	OstTraceFunctionExit0( CALENEDITORREMINDERFIELD_LAUNCHREMINDERTIMEPICKER_EXIT );
+}
+
+/*!
+	 Set the reminder time chosen.
+ */
+void CalenEditorReminderField::setReminderTimeForAllDay()
+{
+	OstTraceFunctionEntry0( CALENEDITORREMINDERFIELD_SETREMINDERTIMEFORALLDAY_ENTRY );
+	mReminderTimeForAllDay = mTimePicker->time();
+	if (mReminderTimeForAllDay.isValid()) {
+		// Change the time displayed to that selected by the user.
+		setDisplayTime();
+		int offset = 0;
+		if (currentReminderIndex() == ReminderOneDayBefore) {
+			offset = 1;
+		} else if (currentReminderIndex() == ReminderTwoDaysBefore) {
+			offset = 2;
+		}
+		QDateTime startDateTimeForAllDay(
+			mCalenEditor->editedEntry()->startTime().date(), QTime(0, 0, 0));
+		QDateTime reminderDateTimeForAllDay; 
+		reminderDateTimeForAllDay.setDate(
+				mCalenEditor->editedEntry()->startTime().date().addDays(
+						-offset));
+		reminderDateTimeForAllDay.setTime(mReminderTimeForAllDay);
+		int seconds =
+				reminderDateTimeForAllDay.secsTo(startDateTimeForAllDay);
+		int timeOffset = seconds / 60;
+		mCustomReminderTimeItem->setEnabled(true);
+		AgendaAlarm reminder;
+		reminder.setTimeOffset(timeOffset);
+		reminder.setAlarmSoundName(QString(" "));
+		// Set the reminder to the entry.
+		mCalenEditor->editedEntry()->setAlarm(reminder);
+	}	
+	OstTraceFunctionExit0( CALENEDITORREMINDERFIELD_SETREMINDERTIMEFORALLDAY_EXIT );
+}
+
+/*!
+	 Checks if reminder field is enabled or not.
+ */
+bool CalenEditorReminderField::isReminderFieldEnabled()
+{
+	OstTraceFunctionEntry0( CALENEDITORREMINDERFIELD_ISREMINDERFIELDENABLED_ENTRY );
+	return mReminderItem->isEnabled();
+}
+
+/*!
+	 Returns the number of items present in the reminder option.
+ */
+int CalenEditorReminderField::reminderItemsCount()
+{
+	OstTraceFunctionEntry0( CALENEDITORREMINDERFIELD_REMINDERITEMSCOUNT_ENTRY );
+	QVariant strings = mReminderItem->contentWidgetData("items");
+	QStringList stringList(strings.toStringList());
+	int count = stringList.count();
+	OstTraceFunctionExit0( CALENEDITORREMINDERFIELD_REMINDERITEMSCOUNT_EXIT );
+	return count;
+}
+
+/*!
+	 Returns the current chosen index.
+ */
+int CalenEditorReminderField::currentReminderIndex()
+{
+	OstTraceFunctionEntry0( CALENEDITORREMINDERFIELD_CURRENTREMINDERINDEX_ENTRY );
+	QVariant countVariant = mReminderItem->contentWidgetData("currentIndex");
+	int index = countVariant.toInt();
+	OstTraceFunctionExit0( CALENEDITORREMINDERFIELD_CURRENTREMINDERINDEX_EXIT );
+	return index;
+}
+
+/*!
+	 Sets the chosen index as current index.
+	 /param index indicates the idex value to be set.
+ */
+void CalenEditorReminderField::setCurrentIndex(int index)
+{
+	OstTraceFunctionEntry0( CALENEDITORREMINDERFIELD_SETCURRENTINDEX_ENTRY );
+	mReminderItem->setContentWidgetData("currentIndex", index);
+	OstTraceFunctionExit0( CALENEDITORREMINDERFIELD_SETCURRENTINDEX_EXIT );
+}
+
+/*!
+	 Disables the reminder time field.
+ */
+void CalenEditorReminderField::disableReminderTimeField()
+{
+	OstTraceFunctionEntry0( CALENEDITORREMINDERFIELD_DISABLEREMINDERTIMEFIELD_ENTRY );
+	if (mReminderTimeAdded) {
+		mCustomReminderTimeItem->setEnabled(false);
+	}
+	OstTraceFunctionExit0( CALENEDITORREMINDERFIELD_DISABLEREMINDERTIMEFIELD_EXIT );
+}
+
+/*!
+	 Checks if reminder time field is added or not.
+ */
+bool CalenEditorReminderField::isReminderTimeForAllDayAdded()
+{
+	OstTraceFunctionEntry0( CALENEDITORREMINDERFIELD_ISREMINDERTIMEFORALLDAYADDED_ENTRY );
+	OstTraceFunctionExit0( CALENEDITORREMINDERFIELD_ISREMINDERTIMEFORALLDAYADDED_EXIT );
+	return mReminderTimeAdded;
+}
+
+// End of file	--Don't remove this.