calendarui/caleneditor/src/caleneditorreminderfield.cpp
changeset 51 0b38fc5b94c6
parent 45 b6db4fd4947b
child 55 2c54b51f39c4
equal deleted inserted replaced
46:ecd7b9840282 51:0b38fc5b94c6
    30 #include <hblabel.h>
    30 #include <hblabel.h>
    31 #include <hbaction.h>
    31 #include <hbaction.h>
    32 
    32 
    33 // User Includes
    33 // User Includes
    34 #include "caleneditorreminderfield.h"
    34 #include "caleneditorreminderfield.h"
       
    35 #include "OstTraceDefinitions.h"
       
    36 #ifdef OST_TRACE_COMPILER_IN_USE
       
    37 #include "caleneditorreminderfieldTraces.h"
       
    38 #endif
       
    39 
    35 
    40 
    36 #define numberOfMinutesInADay 1440
    41 #define numberOfMinutesInADay 1440
    37 /*!
    42 /*!
    38 	\class CalenEditorReminderField
    43 	\class CalenEditorReminderField
    39  */
    44  */
    53 	 mEditorForm(form), 
    58 	 mEditorForm(form), 
    54 	 mCalenEditorModel(model),
    59 	 mCalenEditorModel(model),
    55 	 mCustomReminderTimeItem(NULL),
    60 	 mCustomReminderTimeItem(NULL),
    56 	 mReminderTimeAdded(false)
    61 	 mReminderTimeAdded(false)
    57 {
    62 {
       
    63 	OstTraceFunctionEntry0( CALENEDITORREMINDERFIELD_CALENEDITORREMINDERFIELD_ENTRY );
    58 	mReminderItem = new HbDataFormModelItem();
    64 	mReminderItem = new HbDataFormModelItem();
    59 	mReminderItem->setType(HbDataFormModelItem::ComboBoxItem);
    65 	mReminderItem->setType(HbDataFormModelItem::ComboBoxItem);
    60 	mReminderItem->setData(HbDataFormModelItem::LabelRole,
    66 	mReminderItem->setData(HbDataFormModelItem::LabelRole,
    61 						   hbTrId("txt_calendar_setlabel_reminder"));	
    67 						   hbTrId("txt_calendar_setlabel_reminder"));	
    62 	// Add it to the model
    68 	// Add it to the model
    63 	mCalenEditorModel->appendDataFormItem(mReminderItem,
    69 	mCalenEditorModel->appendDataFormItem(mReminderItem,
    64 										mCalenEditorModel->invisibleRootItem());
    70 										mCalenEditorModel->invisibleRootItem());
       
    71 	OstTraceFunctionExit0( CALENEDITORREMINDERFIELD_CALENEDITORREMINDERFIELD_EXIT );
    65 }
    72 }
    66 
    73 
    67 /*!
    74 /*!
    68 	 Destructor
    75 	 Destructor
    69  */
    76  */
    70 CalenEditorReminderField::~CalenEditorReminderField()
    77 CalenEditorReminderField::~CalenEditorReminderField()
    71 {
    78 {
       
    79 	OstTraceFunctionEntry0( DUP1_CALENEDITORREMINDERFIELD_CALENEDITORREMINDERFIELD_ENTRY );
    72 	if(mReminderHash.count()) {
    80 	if(mReminderHash.count()) {
    73 		mReminderHash.clear();
    81 		mReminderHash.clear();
    74 	}
    82 	}
       
    83 	OstTraceFunctionExit0( DUP1_CALENEDITORREMINDERFIELD_CALENEDITORREMINDERFIELD_EXIT );
    75 }
    84 }
    76 
    85 
    77 /*!
    86 /*!
    78 	 Set the reminder choices.
    87 	 Set the reminder choices.
    79  */
    88  */
    80 void CalenEditorReminderField::setReminderChoices()
    89 void CalenEditorReminderField::setReminderChoices()
    81 {
    90 {
       
    91 	OstTraceFunctionEntry0( CALENEDITORREMINDERFIELD_SETREMINDERCHOICES_ENTRY );
    82 	// Create the reminder choices
    92 	// Create the reminder choices
    83 	QStringList reminderChoices;
    93 	QStringList reminderChoices;
    84 	reminderChoices << hbTrId("txt_calendar_setlabel_reminder_val_off")
    94 	reminderChoices << hbTrId("txt_calendar_setlabel_reminder_val_off")
    85 				<< hbTrId("txt_calendar_setlabel_reminder_val_at_the_start")
    95 				<< hbTrId("txt_calendar_setlabel_reminder_val_at_the_start")
    86 				<< hbTrId("txt_calendar_setlabel_reminder_val_15_minutes_befo")
    96 				<< hbTrId("txt_calendar_setlabel_reminder_val_15_minutes_befo")
    87 				<< hbTrId("txt_calendar_setlabel_reminder_val_30_minutes_befo")
    97 				<< hbTrId("txt_calendar_setlabel_reminder_val_30_minutes_befo")
    88 				<< hbTrId("txt_calendar_setlabel_reminder_val_1_hour_before");
    98 				<< hbTrId("txt_calendar_setlabel_reminder_val_1_hour_before");
    89 
    99 
    90 	mReminderItem->setContentWidgetData(QString("items"), reminderChoices);
   100 	mReminderItem->setContentWidgetData("items", reminderChoices);
       
   101 	mReminderItem->setContentWidgetData("objectName", "remainderItem");
    91 
   102 
    92 	// Build the hash map for the reminder.
   103 	// Build the hash map for the reminder.
    93 	mReminderHash[0] = -1; // OFF.
   104 	mReminderHash[0] = -1; // OFF.
    94 	mReminderHash[1] = 0;
   105 	mReminderHash[1] = 0;
    95 	mReminderHash[2] = 15;
   106 	mReminderHash[2] = 15;
    96 	mReminderHash[3] = 30;
   107 	mReminderHash[3] = 30;
    97 	mReminderHash[4] = 60;
   108 	mReminderHash[4] = 60;
    98 	mReminderItem->setEnabled(true);
   109 	mReminderItem->setEnabled(true);
       
   110 	OstTraceFunctionExit0( CALENEDITORREMINDERFIELD_SETREMINDERCHOICES_EXIT );
    99 }
   111 }
   100 
   112 
   101 /*!
   113 /*!
   102 	 Adds reminder item to the model
   114 	 Adds reminder item to the model
   103  */
   115  */
   104 void CalenEditorReminderField::addItemToModel()
   116 void CalenEditorReminderField::addItemToModel()
   105 {	
   117 {	
       
   118 	OstTraceFunctionEntry0( CALENEDITORREMINDERFIELD_ADDITEMTOMODEL_ENTRY );
   106 	// Add reminder to the model
   119 	// Add reminder to the model
   107 	mCalenEditorModel->appendDataFormItem( mReminderItem,
   120 	mCalenEditorModel->appendDataFormItem( mReminderItem,
   108 				   mCalenEditorModel->invisibleRootItem());
   121 				   mCalenEditorModel->invisibleRootItem());
       
   122 	OstTraceFunctionExit0( CALENEDITORREMINDERFIELD_ADDITEMTOMODEL_EXIT );
   109 }
   123 }
   110 
   124 
   111 /*!
   125 /*!
   112 	 Removes reminder item from the model
   126 	 Removes reminder item from the model
   113  */
   127  */
   114 void CalenEditorReminderField::removeItemFromModel()
   128 void CalenEditorReminderField::removeItemFromModel()
   115 {
   129 {
       
   130 	OstTraceFunctionEntry0( CALENEDITORREMINDERFIELD_REMOVEITEMFROMMODEL_ENTRY );
   116 	mCalenEditorModel->removeItem(modelIndex());
   131 	mCalenEditorModel->removeItem(modelIndex());
       
   132 	OstTraceFunctionExit0( CALENEDITORREMINDERFIELD_REMOVEITEMFROMMODEL_EXIT );
   117 }
   133 }
   118 
   134 
   119 /*!
   135 /*!
   120 	 Populates reminder item with available choices to the user
   136 	 Populates reminder item with available choices to the user
   121 	 \param newEntry bool value to indicate if its a new entry
   137 	 \param newEntry bool value to indicate if its a new entry
   122  */
   138  */
   123 void CalenEditorReminderField::populateReminderItem(bool newEntry)
   139 void CalenEditorReminderField::populateReminderItem(bool newEntry)
   124 {
   140 {
       
   141 	OstTraceFunctionEntry0( CALENEDITORREMINDERFIELD_POPULATEREMINDERITEM_ENTRY );
   125 	AgendaAlarm reminder;
   142 	AgendaAlarm reminder;
   126 	bool pastEvent =  false;
   143 	bool pastEvent =  false;
   127 	
   144 	
   128 	// Set reference date to start date or repeat until date accordingly to 
   145 	// Set reference date to start date or repeat until date accordingly to 
   129 	// decide whether its a past event or not.
   146 	// decide whether its a past event or not.
   220 		}
   237 		}
   221 	}
   238 	}
   222 	mEditorForm->addConnection(mReminderItem,
   239 	mEditorForm->addConnection(mReminderItem,
   223 							SIGNAL(currentIndexChanged(int)), this,
   240 							SIGNAL(currentIndexChanged(int)), this,
   224 							SLOT(handleReminderIndexChanged(int)));
   241 							SLOT(handleReminderIndexChanged(int)));
       
   242 	OstTraceFunctionExit0( CALENEDITORREMINDERFIELD_POPULATEREMINDERITEM_EXIT );
   225 }
   243 }
   226 
   244 
   227 /*!
   245 /*!
   228 	Triggerd from tapping on reminder item.
   246 	Triggerd from tapping on reminder item.
   229 	Handles the reminder time change and updates the same in the event.
   247 	Handles the reminder time change and updates the same in the event.
   230 	\param index The new index chosen in the reminder list.
   248 	\param index The new index chosen in the reminder list.
   231  */
   249  */
   232 void CalenEditorReminderField::handleReminderIndexChanged(int index)
   250 void CalenEditorReminderField::handleReminderIndexChanged(int index)
   233 {
   251 {
       
   252 	OstTraceFunctionEntry0( CALENEDITORREMINDERFIELD_HANDLEREMINDERINDEXCHANGED_ENTRY );
   234 	AgendaAlarm reminder;
   253 	AgendaAlarm reminder;
   235 	if (!mCalenEditor->editedEntry()->alarm().isNull()) {
   254 	if (!mCalenEditor->editedEntry()->alarm().isNull()) {
   236 		reminder = mCalenEditor->editedEntry()->alarm();
   255 		reminder = mCalenEditor->editedEntry()->alarm();
   237 	}
   256 	}
   238 	// Check whether all day event or not and store appropriately.
   257 	// Check whether all day event or not and store appropriately.
   289 		}
   308 		}
   290 	}
   309 	}
   291 	// Set the reminder to the entry.
   310 	// Set the reminder to the entry.
   292 	mCalenEditor->editedEntry()->setAlarm(reminder);
   311 	mCalenEditor->editedEntry()->setAlarm(reminder);
   293 	if(!mCalenEditor->isNewEntry()) {
   312 	if(!mCalenEditor->isNewEntry()) {
   294 		mCalenEditor->addDiscardAction();
   313 	mCalenEditor->addDiscardAction();
   295 	}
   314 	}
       
   315 	OstTraceFunctionExit0( CALENEDITORREMINDERFIELD_HANDLEREMINDERINDEXCHANGED_EXIT );
   296 }
   316 }
   297 
   317 
   298 /*!
   318 /*!
   299 	 Returns the mode index of the reminder item
   319 	 Returns the mode index of the reminder item
   300 	 \return Mode index of the reminder item
   320 	 \return Mode index of the reminder item
   301  */
   321  */
   302 QModelIndex CalenEditorReminderField::modelIndex()
   322 QModelIndex CalenEditorReminderField::modelIndex()
   303 {
   323 {
       
   324 	OstTraceFunctionEntry0( CALENEDITORREMINDERFIELD_MODELINDEX_ENTRY );
   304 	return mCalenEditorModel->indexFromItem(mReminderItem);
   325 	return mCalenEditorModel->indexFromItem(mReminderItem);
   305 }
   326 }
   306 
   327 
   307 /*!
   328 /*!
   308 	 Set reminder off.
   329 	 Set reminder off.
   309  */
   330  */
   310 void CalenEditorReminderField::setReminderOff()
   331 void CalenEditorReminderField::setReminderOff()
   311 {
   332 {
       
   333 	OstTraceFunctionEntry0( CALENEDITORREMINDERFIELD_SETREMINDEROFF_ENTRY );
   312 	// Create the remindar choices
   334 	// Create the remindar choices
   313 	QStringList reminderChoices;
   335 	QStringList reminderChoices;
   314 	reminderChoices << hbTrId("txt_calendar_setlabel_reminder_val_off");
   336 	reminderChoices << hbTrId("txt_calendar_setlabel_reminder_val_off");
   315 	mReminderItem->setContentWidgetData(QString("items"), reminderChoices);
   337 	mReminderItem->setContentWidgetData(QString("items"), reminderChoices);
   316 	mReminderItem->setEnabled(false); 
   338 	mReminderItem->setEnabled(false); 
       
   339 	OstTraceFunctionExit0( CALENEDITORREMINDERFIELD_SETREMINDEROFF_EXIT );
   317 }
   340 }
   318 
   341 
   319 /*!
   342 /*!
   320 	 Set the default alarm for a new all day event.
   343 	 Set the default alarm for a new all day event.
   321  */
   344  */
   322 void CalenEditorReminderField::setDefaultAlarmForAllDay()
   345 void CalenEditorReminderField::setDefaultAlarmForAllDay()
   323 {	
   346 {	
       
   347 	OstTraceFunctionEntry0( CALENEDITORREMINDERFIELD_SETDEFAULTALARMFORALLDAY_ENTRY );
   324 	// Set default alarm if its a new entry.
   348 	// Set default alarm if its a new entry.
   325 	if (mCalenEditor->isNewEntry()) {
   349 	if (mCalenEditor->isNewEntry()) {
   326 		AgendaAlarm reminder;
   350 		AgendaAlarm reminder;
   327 		QDate defaultDate
   351 		QDate defaultDate
   328 				(mCalenEditor->editedEntry()->startTime().date().addDays(-1));
   352 				(mCalenEditor->editedEntry()->startTime().date().addDays(-1));
   340 		reminder.setAlarmSoundName(QString(" "));
   364 		reminder.setAlarmSoundName(QString(" "));
   341 		// Set the reminder to the entry as well as original entry.
   365 		// Set the reminder to the entry as well as original entry.
   342 		mCalenEditor->editedEntry()->setAlarm(reminder);
   366 		mCalenEditor->editedEntry()->setAlarm(reminder);
   343 		mCalenEditor->originalEntry()->setAlarm(reminder);
   367 		mCalenEditor->originalEntry()->setAlarm(reminder);
   344 	}
   368 	}
       
   369 	OstTraceFunctionExit0( CALENEDITORREMINDERFIELD_SETDEFAULTALARMFORALLDAY_EXIT );
   345 }
   370 }
   346 
   371 
   347 /*!
   372 /*!
   348 	 Updates the reminder choices for an all day event.
   373 	 Updates the reminder choices for an all day event.
   349 	 \param referenceDate to indicate past or not.
   374 	 \param referenceDate to indicate past or not.
   350  */
   375  */
   351 void CalenEditorReminderField::updateReminderChoicesForAllDay(QDate referenceDate)
   376 void CalenEditorReminderField::updateReminderChoicesForAllDay(QDate referenceDate)
   352 {
   377 {
       
   378 	OstTraceFunctionEntry0( CALENEDITORREMINDERFIELD_UPDATEREMINDERCHOICESFORALLDAY_ENTRY );
   353 	if (!mReminderTimeAdded){
   379 	if (!mReminderTimeAdded){
   354 		insertReminderTimeField();
   380 		insertReminderTimeField();
   355 	}
   381 	}
   356 	QStringList reminderChoicesForAllDay;
   382 	QStringList reminderChoicesForAllDay;
   357 	QDate tomorrow = QDate::currentDate().addDays(1);
   383 	QDate tomorrow = QDate::currentDate().addDays(1);
   384 	}
   410 	}
   385 	if (mReminderItem->isEnabled()) {
   411 	if (mReminderItem->isEnabled()) {
   386 		mReminderItem->setContentWidgetData(QString("items"), 
   412 		mReminderItem->setContentWidgetData(QString("items"), 
   387 											reminderChoicesForAllDay);
   413 											reminderChoicesForAllDay);
   388 	}
   414 	}
       
   415 	OstTraceFunctionExit0( CALENEDITORREMINDERFIELD_UPDATEREMINDERCHOICESFORALLDAY_EXIT );
   389 }
   416 }
   390 
   417 
   391 /*!
   418 /*!
   392 	 Insert the reminder time field for an all day event.
   419 	 Insert the reminder time field for an all day event.
   393  */
   420  */
   394 void CalenEditorReminderField::insertReminderTimeField()
   421 void CalenEditorReminderField::insertReminderTimeField()
   395 {
   422 {
       
   423 	OstTraceFunctionEntry0( CALENEDITORREMINDERFIELD_INSERTREMINDERTIMEFIELD_ENTRY );
   396 	HbDataFormModelItem::DataItemType itemType =
   424 	HbDataFormModelItem::DataItemType itemType =
   397 			static_cast<HbDataFormModelItem::DataItemType> (ReminderTimeOffset);
   425 			static_cast<HbDataFormModelItem::DataItemType> (ReminderTimeOffset);
   398 	
   426 	
   399 	// If all day item is not added then insert at one level before.
   427 	// If all day item is not added then insert at one level before.
   400 	int index = CalenEditorPrivate::ReminderTimeForAllDayItem;
   428 	int index = CalenEditorPrivate::ReminderTimeForAllDayItem;
   414 	
   442 	
   415 	mEditorForm->addConnection(mCustomReminderTimeItem, SIGNAL(clicked()),
   443 	mEditorForm->addConnection(mCustomReminderTimeItem, SIGNAL(clicked()),
   416 	                           this, SLOT(launchReminderTimePicker()));
   444 	                           this, SLOT(launchReminderTimePicker()));
   417 	setDisplayTime();
   445 	setDisplayTime();
   418 	mReminderTimeAdded = true;
   446 	mReminderTimeAdded = true;
       
   447 	OstTraceFunctionExit0( CALENEDITORREMINDERFIELD_INSERTREMINDERTIMEFIELD_EXIT );
   419 }
   448 }
   420 
   449 
   421 /*!
   450 /*!
   422 	 Set the reminder time selected by the user.
   451 	 Set the reminder time selected by the user.
   423  */
   452  */
   424 void CalenEditorReminderField::setDisplayTime()
   453 void CalenEditorReminderField::setDisplayTime()
   425 {
   454 {
       
   455 	OstTraceFunctionEntry0( CALENEDITORREMINDERFIELD_SETDISPLAYTIME_ENTRY );
   426 	HbExtendedLocale locale = HbExtendedLocale::system();
   456 	HbExtendedLocale locale = HbExtendedLocale::system();
   427 	QString timeString = locale.format(
   457 	QString timeString = locale.format(
   428 			mReminderTimeForAllDay,
   458 			mReminderTimeForAllDay,
   429 			r_qtn_time_usual_with_zero);
   459 			r_qtn_time_usual_with_zero);
   430 	mCustomReminderTimeItem->setContentWidgetData("text", timeString);
   460 	mCustomReminderTimeItem->setContentWidgetData("text", timeString);
       
   461 	OstTraceFunctionExit0( CALENEDITORREMINDERFIELD_SETDISPLAYTIME_EXIT );
   431 }
   462 }
   432 
   463 
   433 /*!
   464 /*!
   434 	Remove the reminder time field if its not an all day event.
   465 	Remove the reminder time field if its not an all day event.
   435  */
   466  */
   436 void CalenEditorReminderField::removeReminderTimeField()
   467 void CalenEditorReminderField::removeReminderTimeField()
   437 {
   468 {
       
   469 	OstTraceFunctionEntry0( CALENEDITORREMINDERFIELD_REMOVEREMINDERTIMEFIELD_ENTRY );
   438 	mReminderTimeAdded = false;
   470 	mReminderTimeAdded = false;
   439 	if (mCustomReminderTimeItem) {
   471 	if (mCustomReminderTimeItem) {
   440 		QModelIndex reminderIndex =
   472 		QModelIndex reminderIndex =
   441 				mCalenEditorModel->indexFromItem(mCustomReminderTimeItem);
   473 				mCalenEditorModel->indexFromItem(mCustomReminderTimeItem);
   442 		mCalenEditorModel->removeItem(
   474 		mCalenEditorModel->removeItem(
   443 				mCalenEditorModel->index(
   475 				mCalenEditorModel->index(
   444 						reminderIndex.row(), 0));
   476 						reminderIndex.row(), 0));
   445 		mCustomReminderTimeItem = NULL;
   477 		mCustomReminderTimeItem = NULL;
   446 	}
   478 	}
       
   479 	OstTraceFunctionExit0( CALENEDITORREMINDERFIELD_REMOVEREMINDERTIMEFIELD_EXIT );
   447 }
   480 }
   448 
   481 
   449 /*!
   482 /*!
   450 	 Launches time picker to select time.
   483 	 Launches time picker to select time.
   451  */
   484  */
   452 void CalenEditorReminderField::launchReminderTimePicker()
   485 void CalenEditorReminderField::launchReminderTimePicker()
   453 {
   486 {
       
   487 	OstTraceFunctionEntry0( CALENEDITORREMINDERFIELD_LAUNCHREMINDERTIMEPICKER_ENTRY );
   454 	mTimePicker = new HbDateTimePicker(mReminderTimeForAllDay);
   488 	mTimePicker = new HbDateTimePicker(mReminderTimeForAllDay);
   455 	mTimePicker->setTime(mReminderTimeForAllDay);
   489 	mTimePicker->setTime(mReminderTimeForAllDay);
   456 	HbDialog *popUp = new HbDialog();
   490 	HbDialog *popUp = new HbDialog();
   457 	popUp->setDismissPolicy(HbDialog::NoDismiss);
   491 	popUp->setDismissPolicy(HbDialog::NoDismiss);
   458 	popUp->setTimeout(HbDialog::NoTimeout);
   492 	popUp->setTimeout(HbDialog::NoTimeout);
   464 	connect(okAction, SIGNAL(triggered()), this, SLOT(setReminderTimeForAllDay()));
   498 	connect(okAction, SIGNAL(triggered()), this, SLOT(setReminderTimeForAllDay()));
   465 	connect(okAction, SIGNAL(triggered()), popUp, SLOT(close()));
   499 	connect(okAction, SIGNAL(triggered()), popUp, SLOT(close()));
   466 	popUp->addAction(new HbAction(hbTrId("txt_common_button_cancel"),
   500 	popUp->addAction(new HbAction(hbTrId("txt_common_button_cancel"),
   467 	                                      popUp));
   501 	                                      popUp));
   468 	popUp->open();
   502 	popUp->open();
       
   503 	OstTraceFunctionExit0( CALENEDITORREMINDERFIELD_LAUNCHREMINDERTIMEPICKER_EXIT );
   469 }
   504 }
   470 
   505 
   471 /*!
   506 /*!
   472 	 Set the reminder time chosen.
   507 	 Set the reminder time chosen.
   473  */
   508  */
   474 void CalenEditorReminderField::setReminderTimeForAllDay()
   509 void CalenEditorReminderField::setReminderTimeForAllDay()
   475 {
   510 {
       
   511 	OstTraceFunctionEntry0( CALENEDITORREMINDERFIELD_SETREMINDERTIMEFORALLDAY_ENTRY );
   476 	mReminderTimeForAllDay = mTimePicker->time();
   512 	mReminderTimeForAllDay = mTimePicker->time();
   477 	if (mReminderTimeForAllDay.isValid()) {
   513 	if (mReminderTimeForAllDay.isValid()) {
   478 		// Change the time displayed to that selected by the user.
   514 		// Change the time displayed to that selected by the user.
   479 		setDisplayTime();
   515 		setDisplayTime();
   480 		handleReminderIndexChanged(currentReminderIndex());
   516 		handleReminderIndexChanged(currentReminderIndex());
   481 	}	
   517 	}	
       
   518 	OstTraceFunctionExit0( CALENEDITORREMINDERFIELD_SETREMINDERTIMEFORALLDAY_EXIT );
   482 }
   519 }
   483 
   520 
   484 /*!
   521 /*!
   485 	 Checks if reminder field is enabled or not.
   522 	 Checks if reminder field is enabled or not.
   486  */
   523  */
   487 bool CalenEditorReminderField::isReminderFieldEnabled()
   524 bool CalenEditorReminderField::isReminderFieldEnabled()
   488 {
   525 {
       
   526 	OstTraceFunctionEntry0( CALENEDITORREMINDERFIELD_ISREMINDERFIELDENABLED_ENTRY );
   489 	return mReminderItem->isEnabled();
   527 	return mReminderItem->isEnabled();
   490 }
   528 }
   491 
   529 
   492 /*!
   530 /*!
   493 	 Returns the number of items present in the reminder option.
   531 	 Returns the number of items present in the reminder option.
   494  */
   532  */
   495 int CalenEditorReminderField::reminderItemsCount()
   533 int CalenEditorReminderField::reminderItemsCount()
   496 {
   534 {
       
   535 	OstTraceFunctionEntry0( CALENEDITORREMINDERFIELD_REMINDERITEMSCOUNT_ENTRY );
   497 	QVariant strings = mReminderItem->contentWidgetData("items");
   536 	QVariant strings = mReminderItem->contentWidgetData("items");
   498 	QStringList stringList(strings.toStringList());
   537 	QStringList stringList(strings.toStringList());
   499 	int count = stringList.count();
   538 	int count = stringList.count();
       
   539 	OstTraceFunctionExit0( CALENEDITORREMINDERFIELD_REMINDERITEMSCOUNT_EXIT );
   500 	return count;
   540 	return count;
   501 }
   541 }
   502 
   542 
   503 /*!
   543 /*!
   504 	 Returns the current chosen index.
   544 	 Returns the current chosen index.
   505  */
   545  */
   506 int CalenEditorReminderField::currentReminderIndex()
   546 int CalenEditorReminderField::currentReminderIndex()
   507 {
   547 {
       
   548 	OstTraceFunctionEntry0( CALENEDITORREMINDERFIELD_CURRENTREMINDERINDEX_ENTRY );
   508 	QVariant countVariant = mReminderItem->contentWidgetData("currentIndex");
   549 	QVariant countVariant = mReminderItem->contentWidgetData("currentIndex");
   509 	int index = countVariant.toInt();
   550 	int index = countVariant.toInt();
       
   551 	OstTraceFunctionExit0( CALENEDITORREMINDERFIELD_CURRENTREMINDERINDEX_EXIT );
   510 	return index;
   552 	return index;
   511 }
   553 }
   512 
   554 
   513 /*!
   555 /*!
   514 	 Sets the chosen index as current index.
   556 	 Sets the chosen index as current index.
   515 	 /param index indicates the idex value to be set.
   557 	 /param index indicates the idex value to be set.
   516  */
   558  */
   517 void CalenEditorReminderField::setCurrentIndex(int index)
   559 void CalenEditorReminderField::setCurrentIndex(int index)
   518 {
   560 {
       
   561 	OstTraceFunctionEntry0( CALENEDITORREMINDERFIELD_SETCURRENTINDEX_ENTRY );
   519 	mReminderItem->setContentWidgetData("currentIndex", index);
   562 	mReminderItem->setContentWidgetData("currentIndex", index);
       
   563 	OstTraceFunctionExit0( CALENEDITORREMINDERFIELD_SETCURRENTINDEX_EXIT );
   520 }
   564 }
   521 
   565 
   522 /*!
   566 /*!
   523 	 Disables the reminder time field.
   567 	 Disables the reminder time field.
   524  */
   568  */
   525 void CalenEditorReminderField::disableReminderTimeField()
   569 void CalenEditorReminderField::disableReminderTimeField()
   526 {
   570 {
       
   571 	OstTraceFunctionEntry0( CALENEDITORREMINDERFIELD_DISABLEREMINDERTIMEFIELD_ENTRY );
   527 	if (mReminderTimeAdded) {
   572 	if (mReminderTimeAdded) {
   528 		mCustomReminderTimeItem->setEnabled(false);
   573 		mCustomReminderTimeItem->setEnabled(false);
   529 	}
   574 	}
       
   575 	OstTraceFunctionExit0( CALENEDITORREMINDERFIELD_DISABLEREMINDERTIMEFIELD_EXIT );
   530 }
   576 }
   531 
   577 
   532 /*!
   578 /*!
   533 	 Checks if reminder time field is added or not.
   579 	 Checks if reminder time field is added or not.
   534  */
   580  */
   535 bool CalenEditorReminderField::isReminderTimeForAllDayAdded()
   581 bool CalenEditorReminderField::isReminderTimeForAllDayAdded()
   536 {
   582 {
       
   583 	OstTraceFunctionEntry0( CALENEDITORREMINDERFIELD_ISREMINDERTIMEFORALLDAYADDED_ENTRY );
       
   584 	OstTraceFunctionExit0( CALENEDITORREMINDERFIELD_ISREMINDERTIMEFORALLDAYADDED_EXIT );
   537 	return mReminderTimeAdded;
   585 	return mReminderTimeAdded;
   538 }
   586 }
   539 
   587 
   540 // End of file	--Don't remove this.
   588 // End of file	--Don't remove this.