40 HbDataFormModel* model, |
49 HbDataFormModel* model, |
41 QObject *parent) |
50 QObject *parent) |
42 :QObject(parent), |
51 :QObject(parent), |
43 mCalenEditor(calenEditor), |
52 mCalenEditor(calenEditor), |
44 mEditorForm(form), |
53 mEditorForm(form), |
45 mCalenEditorModel(model) |
54 mCalenEditorModel(model), |
|
55 mCustomReminderTimeItem(NULL), |
|
56 mReminderTimeAdded(false) |
46 { |
57 { |
47 mReminderItem = new HbDataFormModelItem(); |
58 mReminderItem = new HbDataFormModelItem(); |
48 mReminderItem->setType(HbDataFormModelItem::ComboBoxItem); |
59 mReminderItem->setType(HbDataFormModelItem::ComboBoxItem); |
49 mReminderItem->setData(HbDataFormModelItem::LabelRole, |
60 mReminderItem->setData(HbDataFormModelItem::LabelRole, |
50 hbTrId("txt_calendar_setlabel_alarm")); |
61 hbTrId("txt_calendar_setlabel_reminder")); |
51 // Create the remaindar choices |
62 // Add it to the model |
52 QStringList remaindarChoices; |
63 mCalenEditorModel->appendDataFormItem(mReminderItem, |
53 remaindarChoices << hbTrId("txt_calendar_setlabel_alarm_val_off") |
64 mCalenEditorModel->invisibleRootItem()); |
54 << hbTrId("txt_calendar_setlabel_alarm_val_before_ln_minutes", 5) |
65 } |
55 << hbTrId("txt_calendar_setlabel_alarm_val_before_ln_minutes", 10) |
66 |
56 << hbTrId("txt_calendar_setlabel_alarm_val_before_ln_minutes", 15) |
67 /*! |
57 << hbTrId("txt_calendar_setlabel_alarm_val_before_ln_minutes", 30) |
68 Destructor |
58 << hbTrId("txt_calendar_setlabel_alarm_val_before_ln_hours", 1) |
69 */ |
59 << hbTrId("txt_calendar_setlabel_alarm_val_before_ln_hours", 2); |
70 CalenEditorReminderField::~CalenEditorReminderField() |
60 |
71 { |
61 mReminderItem->setContentWidgetData(QString("items"), remaindarChoices); |
72 if(mReminderHash.count()) { |
|
73 mReminderHash.clear(); |
|
74 } |
|
75 } |
|
76 |
|
77 /*! |
|
78 Set the reminder choices. |
|
79 */ |
|
80 void CalenEditorReminderField::setReminderChoices() |
|
81 { |
|
82 // Create the reminder choices |
|
83 QStringList reminderChoices; |
|
84 reminderChoices << hbTrId("txt_calendar_setlabel_reminder_val_off") |
|
85 << hbTrId("txt_calendar_setlabel_reminder_val_at_the_start") |
|
86 << hbTrId("txt_calendar_setlabel_reminder_val_15_minutes_befo") |
|
87 << hbTrId("txt_calendar_setlabel_reminder_val_30_minutes_befo") |
|
88 << hbTrId("txt_calendar_setlabel_reminder_val_1_hour_before"); |
|
89 |
|
90 mReminderItem->setContentWidgetData(QString("items"), reminderChoices); |
62 |
91 |
63 // Build the hash map for the reminder. |
92 // Build the hash map for the reminder. |
64 mReminderHash[0] = 0; // OFF. |
93 mReminderHash[0] = -1; // OFF. |
65 mReminderHash[1] = 5; |
94 mReminderHash[1] = 0; |
66 mReminderHash[2] = 10; |
95 mReminderHash[2] = 15; |
67 mReminderHash[3] = 15; |
96 mReminderHash[3] = 30; |
68 mReminderHash[4] = 30; |
97 mReminderHash[4] = 60; |
69 mReminderHash[5] = 60; |
98 mReminderItem->setEnabled(true); |
70 mReminderHash[6] = 120; |
|
71 |
|
72 // Add it to the model |
|
73 mCalenEditorModel->appendDataFormItem( mReminderItem, |
|
74 mCalenEditorModel->invisibleRootItem()); |
|
75 } |
|
76 |
|
77 /*! |
|
78 Destructor |
|
79 */ |
|
80 CalenEditorReminderField::~CalenEditorReminderField() |
|
81 { |
|
82 // Nothing Yet |
|
83 } |
99 } |
84 |
100 |
85 /*! |
101 /*! |
86 Adds reminder item to the model |
102 Adds reminder item to the model |
87 */ |
103 */ |
104 Populates reminder item with available choices to the user |
120 Populates reminder item with available choices to the user |
105 \param newEntry bool value to indicate if its a new entry |
121 \param newEntry bool value to indicate if its a new entry |
106 */ |
122 */ |
107 void CalenEditorReminderField::populateReminderItem(bool newEntry) |
123 void CalenEditorReminderField::populateReminderItem(bool newEntry) |
108 { |
124 { |
|
125 AgendaAlarm reminder; |
|
126 bool pastEvent = false; |
|
127 |
|
128 // Set reference date to start date or repeat until date accordingly to |
|
129 // decide whether its a past event or not. |
|
130 QDate referenceDate; |
|
131 if (!mCalenEditor->editedEntry()->isRepeating() || |
|
132 (mCalenEditor->isEditRangeThisOnly())) { |
|
133 referenceDate = mCalenEditor->editedEntry()->startTime().date(); |
|
134 } else { |
|
135 referenceDate = mCalenEditor->editedEntry()->repeatRule().until().date(); |
|
136 } |
|
137 |
|
138 if ((referenceDate < QDate::currentDate()) || |
|
139 (referenceDate == QDate::currentDate() |
|
140 && (mCalenEditor->editedEntry()->startTime().time() < |
|
141 QTime::currentTime()))) { |
|
142 pastEvent = true; |
|
143 } |
|
144 |
|
145 if (mCalenEditor->isAllDayEvent()) { |
|
146 updateReminderChoicesForAllDay(referenceDate); |
|
147 } else { |
|
148 setReminderChoices(); |
|
149 } |
109 // Set the default reminder value to 15 minutes |
150 // Set the default reminder value to 15 minutes |
110 if (newEntry) { |
151 if (newEntry) { |
111 mReminderItem->setContentWidgetData("currentIndex", 3); |
152 if (!pastEvent) { |
112 // Save the reminder alarm for the entry |
153 mReminderItem->setContentWidgetData("currentIndex", 2); |
|
154 // Save the reminder alarm for the entry |
|
155 reminder.setTimeOffset(mReminderHash.value(2)); |
|
156 reminder.setAlarmSoundName(QString(" ")); |
|
157 // Set the reminder to the entry as well as original entry. |
|
158 mCalenEditor->editedEntry()->setAlarm(reminder); |
|
159 mCalenEditor->originalEntry()->setAlarm(reminder); |
|
160 } else { |
|
161 mReminderItem->setContentWidgetData("currentIndex", 0); |
|
162 mReminderItem->setEnabled(false); |
|
163 } |
|
164 } else { |
|
165 // If the alarm is not null, |
|
166 // Check if all day event or not and then set the choices accordingly. |
|
167 if (mCalenEditor->editedEntry()->alarm().isNull()) { |
|
168 // Alarm is set off |
|
169 mReminderItem->setContentWidgetData("currentIndex", 0); |
|
170 if(mReminderTimeAdded) { |
|
171 removeReminderTimeField(); |
|
172 } |
|
173 } else if (mCalenEditor->editedEntry()->type() |
|
174 != AgendaEntry::TypeEvent) { |
|
175 // Get the reminder offset value. |
|
176 int reminderOffset = |
|
177 mCalenEditor->editedEntry()->alarm().timeOffset(); |
|
178 // Get the index value for the reminder combo box from the hash |
|
179 // table. |
|
180 int index = mReminderHash.key(reminderOffset); |
|
181 mReminderItem->setContentWidgetData("currentIndex", index); |
|
182 } else { |
|
183 // Insert reminder time field and display entry's reminder time. |
|
184 // If past then disable the field. |
|
185 if (!mReminderTimeAdded) { |
|
186 insertReminderTimeField(); |
|
187 if (pastEvent) { |
|
188 mCustomReminderTimeItem->setEnabled(false); |
|
189 } |
|
190 } |
|
191 QStringList reminderChoicesForAllDay; |
|
192 reminderChoicesForAllDay << hbTrId("txt_calendar_setlabel_reminder_val_off") |
|
193 << hbTrId("txt_calendar_setlabel_reminder_val_on_event_day") |
|
194 << hbTrId("txt_calendar_setlabel_reminder_val_1_day_before") |
|
195 << hbTrId("txt_calendar_setlabel_reminder_val_2_days_before"); |
|
196 mReminderItem->setContentWidgetData(QString("items"), |
|
197 reminderChoicesForAllDay); |
|
198 QTime referenceTime(0, 0, 0); |
|
199 // Set the appropriate reminder depending on the value of time offset. |
|
200 reminder = mCalenEditor->editedEntry()->alarm(); |
|
201 int offsetInMins = reminder.timeOffset(); |
|
202 if (offsetInMins < 0 || offsetInMins == 0) { |
|
203 mReminderItem->setContentWidgetData("currentIndex", 1); |
|
204 mReminderTimeForAllDay = referenceTime.addSecs(-(offsetInMins |
|
205 * 60)); |
|
206 } else if (offsetInMins < numberOfMinutesInADay) { |
|
207 mReminderItem->setContentWidgetData("currentIndex", 2); |
|
208 mReminderTimeForAllDay = referenceTime.addSecs(-(offsetInMins |
|
209 * 60)); |
|
210 } else { |
|
211 mReminderItem->setContentWidgetData("currentIndex", 3); |
|
212 offsetInMins %= (24 * 60); |
|
213 mReminderTimeForAllDay = referenceTime.addSecs(-(offsetInMins |
|
214 * 60)); |
|
215 } |
|
216 setDisplayTime(); |
|
217 } |
|
218 if (pastEvent) { |
|
219 mReminderItem->setEnabled(false); |
|
220 } |
|
221 } |
|
222 mEditorForm->addConnection(mReminderItem, |
|
223 SIGNAL(currentIndexChanged(int)), this, |
|
224 SLOT(handleReminderIndexChanged(int))); |
|
225 } |
|
226 |
|
227 /*! |
|
228 Triggerd from tapping on reminder item. |
|
229 Handles the reminder time change and updates the same in the event. |
|
230 \param index The new index chosen in the reminder list. |
|
231 */ |
|
232 void CalenEditorReminderField::handleReminderIndexChanged(int index) |
|
233 { |
|
234 AgendaAlarm reminder; |
|
235 if (!mCalenEditor->editedEntry()->alarm().isNull()) { |
|
236 reminder = mCalenEditor->editedEntry()->alarm(); |
|
237 } |
|
238 // Check whether all day event or not and store appropriately. |
|
239 if (!mCalenEditor->isAllDayEvent()) { |
|
240 // If value for the index in hash table is -1 i.e reminder is "OFF", |
|
241 // then set the default constructed reminder to |
|
242 // the entry which is Null. |
|
243 if (mReminderHash.value(index) < 0) { |
|
244 // Construct the default alarm which is NULL |
|
245 reminder = AgendaAlarm(); |
|
246 } else { |
|
247 // If not zero then set the reminder offset |
|
248 // value to the entry. |
|
249 reminder.setTimeOffset(mReminderHash.value(index)); |
|
250 reminder.setAlarmSoundName(QString(" ")); |
|
251 } |
|
252 } else { |
|
253 QDateTime reminderDateTimeForAllDay; |
|
254 QDateTime |
|
255 startDateTimeForAllDay( |
|
256 mCalenEditor->editedEntry()->startTime().date(), |
|
257 QTime(0, 0, 0)); |
|
258 if (mReminderItem->contentWidgetData("currentIndex") == 0) { |
|
259 reminder = AgendaAlarm(); |
|
260 mCustomReminderTimeItem->setEnabled(false); |
|
261 } else { |
|
262 int offset = 0; |
|
263 if (mReminderItem->contentWidgetData("currentIndex") == 2) { |
|
264 offset = 1; |
|
265 } else if (mReminderItem->contentWidgetData("currentIndex") == 3) { |
|
266 offset = 2; |
|
267 } |
|
268 if(!mReminderTimeAdded) { |
|
269 insertReminderTimeField() |
|
270 ; } |
|
271 // If on same day as that of the event then check if time has been |
|
272 // changed , if changed retain that else set default time. |
|
273 if (offset == 0) { |
|
274 if(mReminderTimeForAllDay == QTime(18, 0, 0, 0)) { |
|
275 mReminderTimeForAllDay.setHMS(8, 0, 0); |
|
276 setDisplayTime(); |
|
277 } |
|
278 } |
|
279 reminderDateTimeForAllDay.setDate( |
|
280 mCalenEditor->editedEntry()->startTime().date().addDays( |
|
281 -offset)); |
|
282 reminderDateTimeForAllDay.setTime(mReminderTimeForAllDay); |
|
283 int seconds = |
|
284 reminderDateTimeForAllDay.secsTo(startDateTimeForAllDay); |
|
285 int timeOffest = seconds / 60; |
|
286 mCustomReminderTimeItem->setEnabled(true); |
|
287 reminder.setTimeOffset(timeOffest); |
|
288 reminder.setAlarmSoundName(QString(" ")); |
|
289 } |
|
290 } |
|
291 // Set the reminder to the entry. |
|
292 mCalenEditor->editedEntry()->setAlarm(reminder); |
|
293 if(!mCalenEditor->isNewEntry()) { |
|
294 mCalenEditor->addDiscardAction(); |
|
295 } |
|
296 } |
|
297 |
|
298 /*! |
|
299 Returns the mode index of the reminder item |
|
300 \return Mode index of the reminder item |
|
301 */ |
|
302 QModelIndex CalenEditorReminderField::modelIndex() |
|
303 { |
|
304 return mCalenEditorModel->indexFromItem(mReminderItem); |
|
305 } |
|
306 |
|
307 /*! |
|
308 Set reminder off. |
|
309 */ |
|
310 void CalenEditorReminderField::setReminderOff() |
|
311 { |
|
312 // Create the remindar choices |
|
313 QStringList reminderChoices; |
|
314 reminderChoices << hbTrId("txt_calendar_setlabel_reminder_val_off"); |
|
315 mReminderItem->setContentWidgetData(QString("items"), reminderChoices); |
|
316 mReminderItem->setEnabled(false); |
|
317 } |
|
318 |
|
319 /*! |
|
320 Set the default alarm for a new all day event. |
|
321 */ |
|
322 void CalenEditorReminderField::setDefaultAlarmForAllDay() |
|
323 { |
|
324 // Set default alarm if its a new entry. |
|
325 if (mCalenEditor->isNewEntry()) { |
113 AgendaAlarm reminder; |
326 AgendaAlarm reminder; |
114 reminder.setTimeOffset(mReminderHash.value(3)); |
327 QDate defaultDate |
|
328 (mCalenEditor->editedEntry()->startTime().date().addDays(-1)); |
|
329 // Set default time. |
|
330 mReminderTimeForAllDay.setHMS(18, 0, 0, 0); |
|
331 setDisplayTime(); |
|
332 QDateTime startDateTimeForAllDay( |
|
333 mCalenEditor->editedEntry()->startTime().date(), QTime(0, 0)); |
|
334 QDateTime defaultReminderDateTimeForAllDay |
|
335 (defaultDate, mReminderTimeForAllDay); |
|
336 int offsetInSecs = |
|
337 defaultReminderDateTimeForAllDay.secsTo(startDateTimeForAllDay); |
|
338 int offsetInMins = offsetInSecs/60; |
|
339 reminder.setTimeOffset(offsetInMins); |
115 reminder.setAlarmSoundName(QString(" ")); |
340 reminder.setAlarmSoundName(QString(" ")); |
116 // Set the reminder to the entry as well as original entry. |
341 // Set the reminder to the entry as well as original entry. |
117 mCalenEditor->editedEntry()->setAlarm(reminder); |
342 mCalenEditor->editedEntry()->setAlarm(reminder); |
118 mCalenEditor->originalEntry()->setAlarm(reminder); |
343 mCalenEditor->originalEntry()->setAlarm(reminder); |
|
344 } |
|
345 } |
|
346 |
|
347 /*! |
|
348 Updates the reminder choices for an all day event. |
|
349 \param referenceDate to indicate past or not. |
|
350 */ |
|
351 void CalenEditorReminderField::updateReminderChoicesForAllDay(QDate referenceDate) |
|
352 { |
|
353 if (!mReminderTimeAdded){ |
|
354 insertReminderTimeField(); |
|
355 } |
|
356 QStringList reminderChoicesForAllDay; |
|
357 QDate tomorrow = QDate::currentDate().addDays(1); |
|
358 QDate theDayAfterTomorrow = QDate::currentDate().addDays(2); |
|
359 |
|
360 if (referenceDate < QDate::currentDate() || |
|
361 referenceDate == QDate::currentDate()) { |
|
362 // Set reminder off for past event. |
|
363 reminderChoicesForAllDay << hbTrId("txt_calendar_setlabel_reminder_val_off"); |
|
364 mReminderItem->setContentWidgetData(QString("items"), |
|
365 reminderChoicesForAllDay); |
|
366 mReminderItem->setEnabled(false); |
|
367 removeReminderTimeField(); |
|
368 } else if (theDayAfterTomorrow < referenceDate || |
|
369 theDayAfterTomorrow == referenceDate) { |
|
370 reminderChoicesForAllDay |
|
371 << hbTrId("txt_calendar_setlabel_reminder_val_off") |
|
372 << hbTrId("txt_calendar_setlabel_reminder_val_on_event_day") |
|
373 << hbTrId("txt_calendar_setlabel_reminder_val_1_day_before") |
|
374 << hbTrId("txt_calendar_setlabel_reminder_val_2_days_before"); |
|
375 mReminderItem->setEnabled(true); |
|
376 mCustomReminderTimeItem->setEnabled(true); |
119 } else { |
377 } else { |
120 if (mCalenEditor->editedEntry()->alarm().isNull()) { |
378 reminderChoicesForAllDay |
121 // Alarm is set off |
379 << hbTrId("txt_calendar_setlabel_reminder_val_off") |
122 mReminderItem->setContentWidgetData("currentIndex", 0); |
380 << hbTrId("txt_calendar_setlabel_reminder_val_on_event_day") |
123 } else { |
381 << hbTrId("txt_calendar_setlabel_reminder_val_1_day_before"); |
124 // Get the reminder offset value. |
382 mReminderItem->setEnabled(true); |
125 int reminderOffset = mCalenEditor->editedEntry()->alarm().timeOffset(); |
383 mCustomReminderTimeItem->setEnabled(true); |
126 // Get the index value for the reminder combo box from the hash |
384 } |
127 // table. |
385 if (mReminderItem->isEnabled()) { |
128 int index = mReminderHash.key(reminderOffset); |
386 mReminderItem->setContentWidgetData(QString("items"), |
129 mReminderItem->setContentWidgetData("currentIndex", index); |
387 reminderChoicesForAllDay); |
130 } |
388 } |
131 } |
389 } |
132 mEditorForm->addConnection(mReminderItem, |
390 |
133 SIGNAL(currentIndexChanged(int)), this, |
391 /*! |
134 SLOT(handleReminderIndexChanged(int))); |
392 Insert the reminder time field for an all day event. |
135 |
393 */ |
136 } |
394 void CalenEditorReminderField::insertReminderTimeField() |
137 |
395 { |
138 /*! |
396 HbDataFormModelItem::DataItemType itemType = |
139 Triggerd from tapping on reminder item. |
397 static_cast<HbDataFormModelItem::DataItemType> (ReminderTimeOffset); |
140 Handles the reminder time change and updates the same in the event. |
398 |
141 \param index The new index chosen in the reminder list. |
399 // If all day item is not added then insert at one level before. |
142 */ |
400 int index = CalenEditorPrivate::ReminderTimeForAllDayItem; |
143 void CalenEditorReminderField::handleReminderIndexChanged(int index) |
401 if(!mCalenEditor->isAllDayFieldAdded()) { |
144 { |
402 index = CalenEditorPrivate::ReminderTimeForAllDayItem - 1; |
145 AgendaAlarm reminder; |
403 } |
146 if (!mCalenEditor->editedEntry()->alarm().isNull()) { |
404 mCustomReminderTimeItem = mCalenEditorModel->insertDataFormItem( |
147 reminder = mCalenEditor->editedEntry()->alarm(); |
405 index, |
148 } |
406 itemType, |
149 // If value for the index in hash table is 0 i.e reminder is "OFF", |
407 QString(hbTrId("txt_calendar_setlabel_reminder_time")), |
150 // then dont do anything only set the default constructed reminder to |
408 mCalenEditorModel->invisibleRootItem()); |
151 // the entry which is Null. |
409 if (currentReminderIndex() != 1){ |
152 if (mReminderHash.value(index)) { |
410 mReminderTimeForAllDay.setHMS(18,0,0,0); |
153 // If not zero then set the reminder offset |
|
154 // value to the entry. |
|
155 reminder.setTimeOffset(mReminderHash.value(index)); |
|
156 reminder.setAlarmSoundName(QString(" ")); |
|
157 } else { |
411 } else { |
158 // Construct the default alarm which is NULL |
412 mReminderTimeForAllDay.setHMS(8,0,0,0); |
159 reminder = AgendaAlarm(); |
413 } |
160 } |
414 |
161 // Set the reminder to the entry. |
415 mEditorForm->addConnection(mCustomReminderTimeItem, SIGNAL(clicked()), |
162 mCalenEditor->editedEntry()->setAlarm(reminder); |
416 this, SLOT(launchReminderTimePicker())); |
163 mCalenEditor->addDiscardAction(); |
417 setDisplayTime(); |
164 } |
418 mReminderTimeAdded = true; |
165 |
419 } |
166 /*! |
420 |
167 Returns the mode index of the reminder item |
421 /*! |
168 \return Mode index of the reminder item |
422 Set the reminder time selected by the user. |
169 */ |
423 */ |
170 QModelIndex CalenEditorReminderField::modelIndex() |
424 void CalenEditorReminderField::setDisplayTime() |
171 { |
425 { |
172 return mCalenEditorModel->indexFromItem(mReminderItem); |
426 HbExtendedLocale locale = HbExtendedLocale::system(); |
173 } |
427 QString timeString = locale.format( |
|
428 mReminderTimeForAllDay, |
|
429 r_qtn_time_usual_with_zero); |
|
430 mCustomReminderTimeItem->setContentWidgetData("text", timeString); |
|
431 } |
|
432 |
|
433 /*! |
|
434 Remove the reminder time field if its not an all day event. |
|
435 */ |
|
436 void CalenEditorReminderField::removeReminderTimeField() |
|
437 { |
|
438 mReminderTimeAdded = false; |
|
439 if (mCustomReminderTimeItem) { |
|
440 QModelIndex reminderIndex = |
|
441 mCalenEditorModel->indexFromItem(mCustomReminderTimeItem); |
|
442 mCalenEditorModel->removeItem( |
|
443 mCalenEditorModel->index( |
|
444 reminderIndex.row(), 0)); |
|
445 mCustomReminderTimeItem = NULL; |
|
446 } |
|
447 } |
|
448 |
|
449 /*! |
|
450 Launches time picker to select time. |
|
451 */ |
|
452 void CalenEditorReminderField::launchReminderTimePicker() |
|
453 { |
|
454 mTimePicker = new HbDateTimePicker(mReminderTimeForAllDay); |
|
455 mTimePicker->setTime(mReminderTimeForAllDay); |
|
456 HbDialog *popUp = new HbDialog(); |
|
457 popUp->setDismissPolicy(HbDialog::NoDismiss); |
|
458 popUp->setTimeout(HbDialog::NoTimeout); |
|
459 popUp->setContentWidget(mTimePicker); |
|
460 popUp->setHeadingWidget( new HbLabel( |
|
461 hbTrId("Reminder Time"))); |
|
462 HbAction *okAction = new HbAction(hbTrId("txt_common_button_ok")); |
|
463 popUp->addAction(okAction); |
|
464 connect(okAction, SIGNAL(triggered()), this, SLOT(setReminderTimeForAllDay())); |
|
465 connect(okAction, SIGNAL(triggered()), popUp, SLOT(close())); |
|
466 popUp->addAction(new HbAction(hbTrId("txt_common_button_cancel"), |
|
467 popUp)); |
|
468 popUp->open(); |
|
469 } |
|
470 |
|
471 /*! |
|
472 Set the reminder time chosen. |
|
473 */ |
|
474 void CalenEditorReminderField::setReminderTimeForAllDay() |
|
475 { |
|
476 mReminderTimeForAllDay = mTimePicker->time(); |
|
477 if (mReminderTimeForAllDay.isValid()) { |
|
478 // Change the time displayed to that selected by the user. |
|
479 setDisplayTime(); |
|
480 handleReminderIndexChanged(currentReminderIndex()); |
|
481 } |
|
482 } |
|
483 |
|
484 /*! |
|
485 Checks if reminder field is enabled or not. |
|
486 */ |
|
487 bool CalenEditorReminderField::isReminderFieldEnabled() |
|
488 { |
|
489 return mReminderItem->isEnabled(); |
|
490 } |
|
491 |
|
492 /*! |
|
493 Returns the number of items present in the reminder option. |
|
494 */ |
|
495 int CalenEditorReminderField::reminderItemsCount() |
|
496 { |
|
497 QVariant strings = mReminderItem->contentWidgetData("items"); |
|
498 QStringList stringList(strings.toStringList()); |
|
499 int count = stringList.count(); |
|
500 return count; |
|
501 } |
|
502 |
|
503 /*! |
|
504 Returns the current chosen index. |
|
505 */ |
|
506 int CalenEditorReminderField::currentReminderIndex() |
|
507 { |
|
508 QVariant countVariant = mReminderItem->contentWidgetData("currentIndex"); |
|
509 int index = countVariant.toInt(); |
|
510 return index; |
|
511 } |
|
512 |
|
513 /*! |
|
514 Sets the chosen index as current index. |
|
515 /param index indicates the idex value to be set. |
|
516 */ |
|
517 void CalenEditorReminderField::setCurrentIndex(int index) |
|
518 { |
|
519 mReminderItem->setContentWidgetData("currentIndex", index); |
|
520 } |
|
521 |
|
522 /*! |
|
523 Disables the reminder time field. |
|
524 */ |
|
525 void CalenEditorReminderField::disableReminderTimeField() |
|
526 { |
|
527 if (mReminderTimeAdded) { |
|
528 mCustomReminderTimeItem->setEnabled(false); |
|
529 } |
|
530 } |
|
531 |
|
532 /*! |
|
533 Checks if reminder time field is added or not. |
|
534 */ |
|
535 bool CalenEditorReminderField::isReminderTimeForAllDayAdded() |
|
536 { |
|
537 return mReminderTimeAdded; |
|
538 } |
|
539 |
174 // End of file --Don't remove this. |
540 // End of file --Don't remove this. |