26 #include <tqtooltip.h>
29 #include <tqwidgetstack.h>
30 #include <tqlistbox.h>
33 #include <tqpushbutton.h>
34 #include <tqlineedit.h>
35 #include <tqwhatsthis.h>
37 #include <tdeglobal.h>
38 #include <tdelocale.h>
39 #include <kcalendarsystem.h>
40 #include <kiconloader.h>
42 #include <tdemessagebox.h>
45 #include <libkcal/event.h>
48 #include "alarmtimewidget.h"
54 #include "karecurrence.h"
55 #include "preferences.h"
56 #include "radiobutton.h"
57 #include "repetition.h"
60 #include "timespinbox.h"
61 #include "buttongroup.h"
64 #include "recurrenceedit.moc"
65 #include "recurrenceeditprivate.moc"
69 TQString RecurrenceEdit::i18n_Norecur() {
return i18n(
"No recurrence"); }
70 TQString RecurrenceEdit::i18n_NoRecur() {
return i18n(
"No Recurrence"); }
71 TQString RecurrenceEdit::i18n_AtLogin() {
return i18n(
"At Login"); }
72 TQString RecurrenceEdit::i18n_l_Atlogin() {
return i18n(
"At &login"); }
73 TQString RecurrenceEdit::i18n_HourlyMinutely() {
return i18n(
"Hourly/Minutely"); }
74 TQString RecurrenceEdit::i18n_u_HourlyMinutely() {
return i18n(
"Ho&urly/Minutely"); }
75 TQString RecurrenceEdit::i18n_Daily() {
return i18n(
"Daily"); }
76 TQString RecurrenceEdit::i18n_d_Daily() {
return i18n(
"&Daily"); }
77 TQString RecurrenceEdit::i18n_Weekly() {
return i18n(
"Weekly"); }
78 TQString RecurrenceEdit::i18n_w_Weekly() {
return i18n(
"&Weekly"); }
79 TQString RecurrenceEdit::i18n_Monthly() {
return i18n(
"Monthly"); }
80 TQString RecurrenceEdit::i18n_m_Monthly() {
return i18n(
"&Monthly"); }
81 TQString RecurrenceEdit::i18n_Yearly() {
return i18n(
"Yearly"); }
82 TQString RecurrenceEdit::i18n_y_Yearly() {
return i18n(
"&Yearly"); }
85 RecurrenceEdit::RecurrenceEdit(
bool readOnly, TQWidget* parent,
const char* name)
86 : TQFrame(parent, name),
88 mRuleButtonType(INVALID_RECUR),
93 mNoEmitTypeChanged(true),
97 TQVBoxLayout* topLayout =
new TQVBoxLayout(
this, 0, KDialog::spacingHint());
106 TQGroupBox* recurGroup =
new TQGroupBox(1, Qt::Vertical, i18n(
"Recurrence Rule"),
this,
"recurGroup");
107 topLayout->addWidget(recurGroup);
108 TQFrame* ruleFrame =
new TQFrame(recurGroup,
"ruleFrame");
109 layout =
new TQVBoxLayout(ruleFrame, 0);
110 layout->addSpacing(KDialog::spacingHint()/2);
112 layout =
new TQHBoxLayout(layout, 0);
113 TQBoxLayout* lay =
new TQVBoxLayout(layout, 0);
114 mRuleButtonGroup =
new ButtonGroup(1, Qt::Horizontal, ruleFrame);
115 mRuleButtonGroup->setInsideMargin(0);
116 mRuleButtonGroup->setFrameStyle(TQFrame::NoFrame);
117 lay->addWidget(mRuleButtonGroup);
119 connect(mRuleButtonGroup, TQT_SIGNAL(buttonSet(
int)), TQT_SLOT(periodClicked(
int)));
121 mNoneButton =
new RadioButton(i18n_Norecur(), mRuleButtonGroup);
122 mNoneButton->setFixedSize(mNoneButton->sizeHint());
123 mNoneButton->setReadOnly(mReadOnly);
124 TQWhatsThis::add(mNoneButton, i18n(
"Do not repeat the alarm"));
126 mAtLoginButton =
new RadioButton(i18n_l_Atlogin(), mRuleButtonGroup);
127 mAtLoginButton->setFixedSize(mAtLoginButton->sizeHint());
128 mAtLoginButton->setReadOnly(mReadOnly);
129 TQWhatsThis::add(mAtLoginButton,
130 i18n(
"Trigger the alarm at the specified date/time and at every login until then.\n"
131 "Note that it will also be triggered any time the alarm daemon is restarted."));
133 mSubDailyButton =
new RadioButton(i18n_u_HourlyMinutely(), mRuleButtonGroup);
134 mSubDailyButton->setFixedSize(mSubDailyButton->sizeHint());
135 mSubDailyButton->setReadOnly(mReadOnly);
136 TQWhatsThis::add(mSubDailyButton,
137 i18n(
"Repeat the alarm at hourly/minutely intervals"));
139 mDailyButton =
new RadioButton(i18n_d_Daily(), mRuleButtonGroup);
140 mDailyButton->setFixedSize(mDailyButton->sizeHint());
141 mDailyButton->setReadOnly(mReadOnly);
142 TQWhatsThis::add(mDailyButton,
143 i18n(
"Repeat the alarm at daily intervals"));
145 mWeeklyButton =
new RadioButton(i18n_w_Weekly(), mRuleButtonGroup);
146 mWeeklyButton->setFixedSize(mWeeklyButton->sizeHint());
147 mWeeklyButton->setReadOnly(mReadOnly);
148 TQWhatsThis::add(mWeeklyButton,
149 i18n(
"Repeat the alarm at weekly intervals"));
151 mMonthlyButton =
new RadioButton(i18n_m_Monthly(), mRuleButtonGroup);
152 mMonthlyButton->setFixedSize(mMonthlyButton->sizeHint());
153 mMonthlyButton->setReadOnly(mReadOnly);
154 TQWhatsThis::add(mMonthlyButton,
155 i18n(
"Repeat the alarm at monthly intervals"));
157 mYearlyButton =
new RadioButton(i18n_y_Yearly(), mRuleButtonGroup);
158 mYearlyButton->setFixedSize(mYearlyButton->sizeHint());
159 mYearlyButton->setReadOnly(mReadOnly);
160 TQWhatsThis::add(mYearlyButton,
161 i18n(
"Repeat the alarm at annual intervals"));
163 mNoneButtonId = mRuleButtonGroup->id(mNoneButton);
164 mAtLoginButtonId = mRuleButtonGroup->id(mAtLoginButton);
165 mSubDailyButtonId = mRuleButtonGroup->id(mSubDailyButton);
166 mDailyButtonId = mRuleButtonGroup->id(mDailyButton);
167 mWeeklyButtonId = mRuleButtonGroup->id(mWeeklyButton);
168 mMonthlyButtonId = mRuleButtonGroup->id(mMonthlyButton);
169 mYearlyButtonId = mRuleButtonGroup->id(mYearlyButton);
172 mSubRepetition =
new RepetitionButton(i18n(
"Sub-Repetition"),
true, ruleFrame);
173 mSubRepetition->setFixedSize(mSubRepetition->sizeHint());
174 mSubRepetition->setReadOnly(mReadOnly);
175 connect(mSubRepetition, TQT_SIGNAL(needsInitialisation()), TQT_SIGNAL(repeatNeedsInitialisation()));
176 connect(mSubRepetition, TQT_SIGNAL(changed()), TQT_SIGNAL(frequencyChanged()));
177 TQWhatsThis::add(mSubRepetition, i18n(
"Set up a repetition within the recurrence, to trigger the alarm multiple times each time the recurrence is due."));
178 lay->addSpacing(KDialog::spacingHint());
179 lay->addWidget(mSubRepetition);
181 lay =
new TQVBoxLayout(layout);
184 layout =
new TQHBoxLayout(lay);
186 layout->addSpacing(KDialog::marginHint());
187 TQFrame* divider =
new TQFrame(ruleFrame);
188 divider->setFrameStyle(TQFrame::VLine | TQFrame::Sunken);
189 layout->addWidget(divider);
190 layout->addSpacing(KDialog::marginHint());
192 mNoRule =
new NoRule(ruleFrame,
"noFrame");
193 mSubDailyRule =
new SubDailyRule(mReadOnly, ruleFrame,
"subdayFrame");
194 mDailyRule =
new DailyRule(mReadOnly, ruleFrame,
"dayFrame");
195 mWeeklyRule =
new WeeklyRule(mReadOnly, ruleFrame,
"weekFrame");
196 mMonthlyRule =
new MonthlyRule(mReadOnly, ruleFrame,
"monthFrame");
197 mYearlyRule =
new YearlyRule(mReadOnly, ruleFrame,
"yearFrame");
199 connect(mSubDailyRule, TQT_SIGNAL(frequencyChanged()),
this, TQT_SIGNAL(frequencyChanged()));
200 connect(mDailyRule, TQT_SIGNAL(frequencyChanged()),
this, TQT_SIGNAL(frequencyChanged()));
201 connect(mWeeklyRule, TQT_SIGNAL(frequencyChanged()),
this, TQT_SIGNAL(frequencyChanged()));
202 connect(mMonthlyRule, TQT_SIGNAL(frequencyChanged()),
this, TQT_SIGNAL(frequencyChanged()));
203 connect(mYearlyRule, TQT_SIGNAL(frequencyChanged()),
this, TQT_SIGNAL(frequencyChanged()));
205 mRuleStack =
new TQWidgetStack(ruleFrame);
206 layout->addWidget(mRuleStack);
207 layout->addStretch(1);
208 mRuleStack->addWidget(mNoRule, 0);
209 mRuleStack->addWidget(mSubDailyRule, 1);
210 mRuleStack->addWidget(mDailyRule, 2);
211 mRuleStack->addWidget(mWeeklyRule, 3);
212 mRuleStack->addWidget(mMonthlyRule, 4);
213 mRuleStack->addWidget(mYearlyRule, 5);
214 layout->addSpacing(KDialog::marginHint());
219 mRangeButtonGroup =
new ButtonGroup(i18n(
"Recurrence End"),
this,
"mRangeButtonGroup");
220 connect(mRangeButtonGroup, TQT_SIGNAL(buttonSet(
int)), TQT_SLOT(rangeTypeClicked()));
221 topLayout->addWidget(mRangeButtonGroup);
223 TQVBoxLayout* vlayout =
new TQVBoxLayout(mRangeButtonGroup, KDialog::marginHint(), KDialog::spacingHint());
224 vlayout->addSpacing(fontMetrics().lineSpacing()/2);
225 mNoEndDateButton =
new RadioButton(i18n(
"No &end"), mRangeButtonGroup);
226 mNoEndDateButton->setFixedSize(mNoEndDateButton->sizeHint());
227 mNoEndDateButton->setReadOnly(mReadOnly);
228 TQWhatsThis::add(mNoEndDateButton, i18n(
"Repeat the alarm indefinitely"));
229 vlayout->addWidget(mNoEndDateButton, 1, TQt::AlignAuto);
230 TQSize size = mNoEndDateButton->size();
232 layout =
new TQHBoxLayout(vlayout, KDialog::spacingHint());
233 mRepeatCountButton =
new RadioButton(i18n(
"End a&fter:"), mRangeButtonGroup);
234 mRepeatCountButton->setReadOnly(mReadOnly);
235 TQWhatsThis::add(mRepeatCountButton,
236 i18n(
"Repeat the alarm for the number of times specified"));
237 mRepeatCountEntry =
new SpinBox(1, 9999, 1, mRangeButtonGroup);
238 mRepeatCountEntry->setFixedSize(mRepeatCountEntry->sizeHint());
239 mRepeatCountEntry->setLineShiftStep(10);
240 mRepeatCountEntry->setSelectOnStep(
false);
241 mRepeatCountEntry->setReadOnly(mReadOnly);
242 connect(mRepeatCountEntry, TQT_SIGNAL(valueChanged(
int)), TQT_SLOT(repeatCountChanged(
int)));
243 TQWhatsThis::add(mRepeatCountEntry,
244 i18n(
"Enter the total number of times to trigger the alarm"));
245 mRepeatCountButton->setFocusWidget(mRepeatCountEntry);
246 mRepeatCountLabel =
new TQLabel(i18n(
"occurrence(s)"), mRangeButtonGroup);
247 mRepeatCountLabel->setFixedSize(mRepeatCountLabel->sizeHint());
248 layout->addWidget(mRepeatCountButton);
249 layout->addSpacing(KDialog::spacingHint());
250 layout->addWidget(mRepeatCountEntry);
251 layout->addWidget(mRepeatCountLabel);
252 layout->addStretch();
253 size = size.expandedTo(mRepeatCountButton->sizeHint());
255 layout =
new TQHBoxLayout(vlayout, KDialog::spacingHint());
256 mEndDateButton =
new RadioButton(i18n(
"End &by:"), mRangeButtonGroup);
257 mEndDateButton->setReadOnly(mReadOnly);
258 TQWhatsThis::add(mEndDateButton,
259 i18n(
"Repeat the alarm until the date/time specified.\n\n"
260 "Note: This applies to the main recurrence only. It does not limit any sub-repetition which will occur regardless after the last main recurrence."));
261 mEndDateEdit =
new DateEdit(mRangeButtonGroup);
262 mEndDateEdit->setFixedSize(mEndDateEdit->sizeHint());
263 mEndDateEdit->setReadOnly(mReadOnly);
264 TQWhatsThis::add(mEndDateEdit,
265 i18n(
"Enter the last date to repeat the alarm"));
266 mEndDateButton->setFocusWidget(mEndDateEdit);
267 mEndTimeEdit =
new TimeEdit(mRangeButtonGroup);
268 mEndTimeEdit->setFixedSize(mEndTimeEdit->sizeHint());
269 mEndTimeEdit->setReadOnly(mReadOnly);
270 static const TQString lastTimeText = i18n(
"Enter the last time to repeat the alarm.");
271 TQWhatsThis::add(mEndTimeEdit, TQString(
"%1\n\n%2").arg(lastTimeText).arg(TimeSpinBox::shiftWhatsThis()));
272 mEndAnyTimeCheckBox =
new CheckBox(i18n(
"Any time"), mRangeButtonGroup);
273 mEndAnyTimeCheckBox->setFixedSize(mEndAnyTimeCheckBox->sizeHint());
274 mEndAnyTimeCheckBox->setReadOnly(mReadOnly);
275 connect(mEndAnyTimeCheckBox, TQT_SIGNAL(toggled(
bool)), TQT_SLOT(slotAnyTimeToggled(
bool)));
276 TQWhatsThis::add(mEndAnyTimeCheckBox,
277 i18n(
"Stop repeating the alarm after your first login on or after the specified end date"));
278 layout->addWidget(mEndDateButton);
279 layout->addSpacing(KDialog::spacingHint());
280 layout->addWidget(mEndDateEdit);
281 layout->addWidget(mEndTimeEdit);
282 layout->addWidget(mEndAnyTimeCheckBox);
283 layout->addStretch();
284 size = size.expandedTo(mEndDateButton->sizeHint());
287 mRepeatCountButton->setFixedSize(size);
288 mEndDateButton->setFixedSize(size);
293 mExceptionGroup =
new TQGroupBox(i18n(
"E&xceptions"),
this,
"mExceptionGroup");
294 topLayout->addWidget(mExceptionGroup);
295 topLayout->setStretchFactor(mExceptionGroup, 2);
296 vlayout =
new TQVBoxLayout(mExceptionGroup, KDialog::marginHint(), KDialog::spacingHint());
297 vlayout->addSpacing(fontMetrics().lineSpacing()/2);
298 layout =
new TQHBoxLayout(vlayout, KDialog::spacingHint());
299 vlayout =
new TQVBoxLayout(layout);
301 mExceptionDateList =
new TQListBox(mExceptionGroup);
302 mExceptionDateList->setSizePolicy(TQSizePolicy(TQSizePolicy::Expanding, TQSizePolicy::Expanding));
303 connect(mExceptionDateList, TQT_SIGNAL(selectionChanged()), TQT_SLOT(enableExceptionButtons()));
304 TQWhatsThis::add(mExceptionDateList,
305 i18n(
"The list of exceptions, i.e. dates/times excluded from the recurrence"));
306 vlayout->addWidget(mExceptionDateList);
310 mExceptionDateEdit = 0;
311 mChangeExceptionButton = 0;
312 mDeleteExceptionButton = 0;
316 vlayout =
new TQVBoxLayout(layout);
317 mExceptionDateEdit =
new DateEdit(mExceptionGroup);
318 mExceptionDateEdit->setFixedSize(mExceptionDateEdit->sizeHint());
319 mExceptionDateEdit->setDate(TQDate::currentDate());
320 TQWhatsThis::add(mExceptionDateEdit,
321 i18n(
"Enter a date to insert in the exceptions list. "
322 "Use in conjunction with the Add or Change button below."));
323 vlayout->addWidget(mExceptionDateEdit);
325 layout =
new TQHBoxLayout(vlayout, KDialog::spacingHint());
326 TQPushButton* button =
new TQPushButton(i18n(
"Add"), mExceptionGroup);
327 button->setFixedSize(button->sizeHint());
328 connect(button, TQT_SIGNAL(clicked()), TQT_SLOT(addException()));
329 TQWhatsThis::add(button,
330 i18n(
"Add the date entered above to the exceptions list"));
331 layout->addWidget(button);
333 mChangeExceptionButton =
new TQPushButton(i18n(
"Change"), mExceptionGroup);
334 mChangeExceptionButton->setFixedSize(mChangeExceptionButton->sizeHint());
335 connect(mChangeExceptionButton, TQT_SIGNAL(clicked()), TQT_SLOT(changeException()));
336 TQWhatsThis::add(mChangeExceptionButton,
337 i18n(
"Replace the currently highlighted item in the exceptions list with the date entered above"));
338 layout->addWidget(mChangeExceptionButton);
340 mDeleteExceptionButton =
new TQPushButton(i18n(
"Delete"), mExceptionGroup);
341 mDeleteExceptionButton->setFixedSize(mDeleteExceptionButton->sizeHint());
342 connect(mDeleteExceptionButton, TQT_SIGNAL(clicked()), TQT_SLOT(deleteException()));
343 TQWhatsThis::add(mDeleteExceptionButton,
344 i18n(
"Remove the currently highlighted item from the exceptions list"));
345 layout->addWidget(mDeleteExceptionButton);
348 mNoEmitTypeChanged =
false;
355 TQWidget* RecurrenceEdit::checkData(
const TQDateTime& startDateTime, TQString& errorMessage)
const
357 if (mAtLoginButton->isOn())
359 const_cast<RecurrenceEdit*
>(
this)->mCurrStartDateTime = startDateTime;
360 if (mEndDateButton->isChecked())
362 TQWidget* errWidget = 0;
363 bool noTime = !mEndTimeEdit->isEnabled();
364 TQDate endDate = mEndDateEdit->date();
365 if (endDate < startDateTime.date())
366 errWidget = mEndDateEdit;
367 else if (!noTime && TQDateTime(endDate, mEndTimeEdit->time()) < startDateTime)
368 errWidget = mEndTimeEdit;
371 errorMessage = noTime
372 ? i18n(
"End date is earlier than start date")
373 : i18n(
"End date/time is earlier than start date/time");
379 return mRule->validate(errorMessage);
385 void RecurrenceEdit::periodClicked(
int id)
387 RepeatType oldType = mRuleButtonType;
388 bool none = (
id == mNoneButtonId);
389 bool atLogin = (
id == mAtLoginButtonId);
390 bool subdaily = (
id == mSubDailyButtonId);
394 mRuleButtonType = NO_RECUR;
399 mRuleButtonType = AT_LOGIN;
400 mRangeButtonGroup->setButton(mRangeButtonGroup->id(mEndDateButton));
404 mRule = mSubDailyRule;
405 mRuleButtonType = SUBDAILY;
407 else if (
id == mDailyButtonId)
410 mRuleButtonType = DAILY;
413 else if (
id == mWeeklyButtonId)
416 mRuleButtonType = WEEKLY;
419 else if (
id == mMonthlyButtonId)
421 mRule = mMonthlyRule;
422 mRuleButtonType = MONTHLY;
423 mMonthlyShown =
true;
425 else if (
id == mYearlyButtonId)
428 mRuleButtonType = ANNUAL;
434 if (mRuleButtonType != oldType)
436 mRuleStack->raiseWidget(mRule ? mRule : mNoRule);
437 if (oldType == NO_RECUR || none)
438 mRangeButtonGroup->setEnabled(!none);
439 mExceptionGroup->setEnabled(!(none || atLogin));
440 mEndAnyTimeCheckBox->setEnabled(atLogin);
443 mNoEndDateButton->setEnabled(!atLogin);
444 mRepeatCountButton->setEnabled(!atLogin);
447 mSubRepetition->setEnabled(!(none || atLogin));
448 if (!mNoEmitTypeChanged)
449 emit typeChanged(mRuleButtonType);
453 void RecurrenceEdit::slotAnyTimeToggled(
bool on)
455 TQButton* button = mRuleButtonGroup->selected();
456 mEndTimeEdit->setEnabled((button == mAtLoginButton && !on)
457 || (button == mSubDailyButton && mEndDateButton->isChecked()));
463 void RecurrenceEdit::rangeTypeClicked()
465 bool endDate = mEndDateButton->isOn();
466 mEndDateEdit->setEnabled(endDate);
467 mEndTimeEdit->setEnabled(endDate
468 && ((mAtLoginButton->isOn() && !mEndAnyTimeCheckBox->isChecked())
469 || mSubDailyButton->isOn()));
470 bool repeatCount = mRepeatCountButton->isOn();
471 mRepeatCountEntry->setEnabled(repeatCount);
472 mRepeatCountLabel->setEnabled(repeatCount);
475 void RecurrenceEdit::showEvent(TQShowEvent*)
478 mRule->setFrequencyFocus();
480 mRuleButtonGroup->selected()->setFocus();
488 int RecurrenceEdit::subRepeatCount(
int* subRepeatInterval)
const
490 int count = (mRuleButtonType >= SUBDAILY) ? mSubRepetition->count() : 0;
491 if (subRepeatInterval)
492 *subRepeatInterval = count ? mSubRepetition->interval() : 0;
504 void RecurrenceEdit::setSubRepetition(
int reminderMinutes,
bool dateOnly)
507 switch (mRuleButtonType)
509 case RecurrenceEdit::NO_RECUR:
510 case RecurrenceEdit::AT_LOGIN:
516 updateEvent(event,
false);
517 maxDuration =
event.longestRecurrenceInterval() - reminderMinutes - 1;
521 mSubRepetition->initialise(mSubRepetition->interval(), mSubRepetition->count(), dateOnly, maxDuration);
522 mSubRepetition->setEnabled(mRuleButtonType >= SUBDAILY && maxDuration);
528 void RecurrenceEdit::activateSubRepetition()
530 mSubRepetition->activate();
537 void RecurrenceEdit::repeatCountChanged(
int value)
539 if (value > 0 && mRepeatCountEntry->minValue() == 0)
540 mRepeatCountEntry->setMinValue(1);
547 void RecurrenceEdit::addException()
549 if (!mExceptionDateEdit || !mExceptionDateEdit->isValid())
551 TQDate date = mExceptionDateEdit->date();
552 TQValueList<TQDate>::Iterator it;
555 for (it = mExceptionDates.begin(); it != mExceptionDates.end(); ++index, ++it)
559 insert = (date != *it);
565 mExceptionDates.insert(it, date);
566 mExceptionDateList->insertItem(TDEGlobal::locale()->formatDate(date), index);
568 mExceptionDateList->setCurrentItem(index);
569 enableExceptionButtons();
576 void RecurrenceEdit::changeException()
578 if (!mExceptionDateEdit || !mExceptionDateEdit->isValid())
580 int index = mExceptionDateList->currentItem();
581 if (index >= 0 && mExceptionDateList->isSelected(index))
583 TQDate olddate = mExceptionDates[index];
584 TQDate newdate = mExceptionDateEdit->date();
585 if (newdate != olddate)
587 mExceptionDates.remove(mExceptionDates.at(index));
588 mExceptionDateList->removeItem(index);
597 void RecurrenceEdit::deleteException()
599 int index = mExceptionDateList->currentItem();
600 if (index >= 0 && mExceptionDateList->isSelected(index))
602 mExceptionDates.remove(mExceptionDates.at(index));
603 mExceptionDateList->removeItem(index);
604 enableExceptionButtons();
612 void RecurrenceEdit::enableExceptionButtons()
614 int index = mExceptionDateList->currentItem();
615 bool enable = (index >= 0 && mExceptionDateList->isSelected(index));
616 if (mDeleteExceptionButton)
617 mDeleteExceptionButton->setEnabled(enable);
618 if (mChangeExceptionButton)
619 mChangeExceptionButton->setEnabled(enable);
622 mExceptionDateList->setFocusPolicy(mExceptionDateList->count() ? TQ_WheelFocus : TQ_NoFocus);
628 void RecurrenceEdit::setStartDate(
const TQDate& start,
const TQDate& today)
632 setRuleDefaults(start);
635 mEndDateEdit->setMinDate(today);
636 if (mExceptionDateEdit)
637 mExceptionDateEdit->setMinDate(today);
641 const TQString startString = i18n(
"Date cannot be earlier than start date",
"start date");
642 mEndDateEdit->setMinDate(start, startString);
643 if (mExceptionDateEdit)
644 mExceptionDateEdit->setMinDate(start, startString);
652 void RecurrenceEdit::setDefaultEndDate(
const TQDate& end)
654 if (!mEndDateButton->isOn())
655 mEndDateEdit->setDate(end);
658 void RecurrenceEdit::setEndDateTime(
const DateTime& end)
660 mEndDateEdit->setDate(end.date());
661 mEndTimeEdit->setValue(end.time());
662 mEndTimeEdit->setEnabled(!end.isDateOnly());
663 mEndAnyTimeCheckBox->setChecked(end.isDateOnly());
666 DateTime RecurrenceEdit::endDateTime()
const
668 if (mRuleButtonGroup->selected() == mAtLoginButton && mEndAnyTimeCheckBox->isChecked())
669 return DateTime(mEndDateEdit->date());
670 return DateTime(mEndDateEdit->date(), mEndTimeEdit->time());
676 void RecurrenceEdit::setDefaults(
const TQDateTime& from)
678 mCurrStartDateTime = from;
679 TQDate fromDate = from.date();
680 mNoEndDateButton->setChecked(
true);
682 mSubDailyRule->setFrequency(1);
683 mDailyRule->setFrequency(1);
684 mWeeklyRule->setFrequency(1);
685 mMonthlyRule->setFrequency(1);
686 mYearlyRule->setFrequency(1);
688 setRuleDefaults(fromDate);
689 mMonthlyRule->setType(MonthYearRule::DATE);
690 mYearlyRule->setType(MonthYearRule::DATE);
692 mEndDateEdit->setDate(fromDate);
694 mNoEmitTypeChanged =
true;
696 switch (Preferences::defaultRecurPeriod())
698 case AT_LOGIN: button = mAtLoginButtonId;
break;
699 case ANNUAL: button = mYearlyButtonId;
break;
700 case MONTHLY: button = mMonthlyButtonId;
break;
701 case WEEKLY: button = mWeeklyButtonId;
break;
702 case DAILY: button = mDailyButtonId;
break;
703 case SUBDAILY: button = mSubDailyButtonId;
break;
705 default: button = mNoneButtonId;
break;
707 mRuleButtonGroup->setButton(button);
708 mNoEmitTypeChanged =
false;
710 enableExceptionButtons();
719 void RecurrenceEdit::setRuleDefaults(
const TQDate& fromDate)
721 int day = fromDate.day();
722 int dayOfWeek = fromDate.dayOfWeek();
723 int month = fromDate.month();
725 mDailyRule->setDays(
true);
727 mWeeklyRule->setDay(dayOfWeek);
729 mMonthlyRule->setDefaultValues(day, dayOfWeek);
731 mYearlyRule->setDefaultValues(day, dayOfWeek, month);
739 void RecurrenceEdit::set(
const KAEvent& event,
bool keepDuration)
741 setDefaults(event.mainDateTime().dateTime());
742 if (event.repeatAtLogin())
744 mRuleButtonGroup->setButton(mAtLoginButtonId);
745 mEndDateButton->setChecked(
true);
748 mRuleButtonGroup->setButton(mNoneButtonId);
749 KARecurrence* recurrence =
event.recurrence();
752 KARecurrence::Type rtype = recurrence->type();
755 case KARecurrence::MINUTELY:
756 mRuleButtonGroup->setButton(mSubDailyButtonId);
759 case KARecurrence::DAILY:
761 mRuleButtonGroup->setButton(mDailyButtonId);
762 TQBitArray rDays = recurrence->days();
764 for (
int i = 0; i < 7 && !set; ++i)
765 set = rDays.testBit(i);
767 mDailyRule->setDays(rDays);
769 mDailyRule->setDays(
true);
772 case KARecurrence::WEEKLY:
774 mRuleButtonGroup->setButton(mWeeklyButtonId);
775 TQBitArray rDays = recurrence->days();
776 mWeeklyRule->setDays(rDays);
779 case KARecurrence::MONTHLY_POS:
781 TQValueList<RecurrenceRule::WDayPos> posns = recurrence->monthPositions();
782 int i = posns.first().pos();
787 mRuleButtonGroup->setButton(mWeeklyButtonId);
788 mWeeklyRule->setFrequency(recurrence->frequency());
790 for (TQValueList<RecurrenceRule::WDayPos>::ConstIterator it = posns.begin(); it != posns.end(); ++it)
793 rDays.setBit((*it).day() - 1, 1);
795 mWeeklyRule->setDays(rDays);
798 mRuleButtonGroup->setButton(mMonthlyButtonId);
799 mMonthlyRule->setPosition(i, posns.first().day());
802 case KARecurrence::MONTHLY_DAY:
804 mRuleButtonGroup->setButton(mMonthlyButtonId);
805 TQValueList<int> rmd = recurrence->monthDays();
806 int day = (rmd.isEmpty()) ? event.mainDate().day() : rmd.first();
807 mMonthlyRule->setDate(day);
810 case KARecurrence::ANNUAL_DATE:
811 case KARecurrence::ANNUAL_POS:
813 if (rtype == KARecurrence::ANNUAL_DATE)
815 mRuleButtonGroup->setButton(mYearlyButtonId);
816 const TQValueList<int> rmd = recurrence->monthDays();
817 int day = (rmd.isEmpty()) ? event.mainDate().day() : rmd.first();
818 mYearlyRule->setDate(day);
819 mYearlyRule->setFeb29Type(recurrence->feb29Type());
821 else if (rtype == KARecurrence::ANNUAL_POS)
823 mRuleButtonGroup->setButton(mYearlyButtonId);
824 TQValueList<RecurrenceRule::WDayPos> posns = recurrence->yearPositions();
825 mYearlyRule->setPosition(posns.first().pos(), posns.first().day());
827 mYearlyRule->setMonths(recurrence->yearMonths());
834 mRule->setFrequency(recurrence->frequency());
837 TQDateTime endtime = mCurrStartDateTime;
838 int duration = recurrence->duration();
840 mNoEndDateButton->setChecked(
true);
843 mRepeatCountButton->setChecked(
true);
844 mRepeatCountEntry->setValue(duration);
848 mEndDateButton->setChecked(
true);
849 endtime = recurrence->endDateTime();
850 mEndTimeEdit->setValue(endtime.time());
852 mEndDateEdit->setDate(endtime.date());
855 mExceptionDates =
event.recurrence()->exDates();
856 qHeapSort(mExceptionDates);
857 mExceptionDateList->clear();
858 for (DateList::ConstIterator it = mExceptionDates.begin(); it != mExceptionDates.end(); ++it)
859 mExceptionDateList->insertItem(TDEGlobal::locale()->formatDate(*it));
860 enableExceptionButtons();
863 mSubRepetition->set(event.repeatInterval(), event.repeatCount());
875 void RecurrenceEdit::updateEvent(
KAEvent& event,
bool adjustStart)
881 if (mNoEndDateButton->isChecked())
883 else if (mRepeatCountButton->isChecked())
884 repeatCount = mRepeatCountEntry->value();
888 endDate = mEndDateEdit->date();
889 endTime = mEndTimeEdit->time();
893 TQButton* button = mRuleButtonGroup->selected();
894 event.setRepeatAtLogin(button == mAtLoginButton);
895 int frequency = mRule ? mRule->frequency() : 0;
896 if (button == mSubDailyButton)
898 TQDateTime endDateTime(endDate, endTime);
899 event.setRecurMinutely(frequency, repeatCount, endDateTime);
901 else if (button == mDailyButton)
903 event.setRecurDaily(frequency, mDailyRule->days(), repeatCount, endDate);
905 else if (button == mWeeklyButton)
907 event.setRecurWeekly(frequency, mWeeklyRule->days(), repeatCount, endDate);
909 else if (button == mMonthlyButton)
911 if (mMonthlyRule->type() == MonthlyRule::POS)
914 KAEvent::MonthPos pos;
915 pos.days.fill(
false);
916 pos.days.setBit(mMonthlyRule->dayOfWeek() - 1);
917 pos.weeknum = mMonthlyRule->week();
918 TQValueList<KAEvent::MonthPos> poses;
920 event.setRecurMonthlyByPos(frequency, poses, repeatCount, endDate);
925 int daynum = mMonthlyRule->date();
926 TQValueList<int> daynums;
927 daynums.append(daynum);
928 event.setRecurMonthlyByDate(frequency, daynums, repeatCount, endDate);
931 else if (button == mYearlyButton)
933 TQValueList<int> months = mYearlyRule->months();
934 if (mYearlyRule->type() == YearlyRule::POS)
937 KAEvent::MonthPos pos;
938 pos.days.fill(
false);
939 pos.days.setBit(mYearlyRule->dayOfWeek() - 1);
940 pos.weeknum = mYearlyRule->week();
941 TQValueList<KAEvent::MonthPos> poses;
943 event.setRecurAnnualByPos(frequency, poses, months, repeatCount, endDate);
948 event.setRecurAnnualByDate(frequency, months, mYearlyRule->date(),
949 mYearlyRule->feb29Type(), repeatCount, endDate);
960 event.setFirstRecurrence();
964 int count = mSubRepetition->count();
965 if (mRuleButtonType < SUBDAILY)
967 event.setRepetition(mSubRepetition->interval(), count);
970 event.recurrence()->setExDates(mExceptionDates);
978 void RecurrenceEdit::saveState()
980 mSavedRuleButton = mRuleButtonGroup->selected();
983 mSavedRangeButton = mRangeButtonGroup->selected();
984 if (mSavedRangeButton == mRepeatCountButton)
985 mSavedRecurCount = mRepeatCountEntry->value();
986 else if (mSavedRangeButton == mEndDateButton)
987 mSavedEndDateTime.set(TQDateTime(mEndDateEdit->date(), mEndTimeEdit->time()), mEndAnyTimeCheckBox->isChecked());
988 mSavedExceptionDates = mExceptionDates;
989 mSavedRepeatInterval = mSubRepetition->interval();
990 mSavedRepeatCount = mSubRepetition->count();
996 bool RecurrenceEdit::stateChanged()
const
998 if (mSavedRuleButton != mRuleButtonGroup->selected()
999 || mSavedRangeButton != mRangeButtonGroup->selected()
1000 || (mRule && mRule->stateChanged()))
1002 if (mSavedRangeButton == mRepeatCountButton
1003 && mSavedRecurCount != mRepeatCountEntry->value())
1005 if (mSavedRangeButton == mEndDateButton
1006 && mSavedEndDateTime != DateTime(TQDateTime(mEndDateEdit->date(), mEndTimeEdit->time()), mEndAnyTimeCheckBox->isChecked()))
1008 if (mSavedExceptionDates != mExceptionDates
1009 || mSavedRepeatInterval != mSubRepetition->interval()
1010 || mSavedRepeatCount != mSubRepetition->count())
1022 Rule::Rule(
const TQString& freqText,
const TQString& freqWhatsThis,
bool time,
bool readOnly, TQWidget* parent,
const char* name)
1023 : NoRule(parent, name)
1025 mLayout =
new TQVBoxLayout(
this, 0, KDialog::spacingHint());
1026 TQHBox* freqBox =
new TQHBox(
this);
1027 mLayout->addWidget(freqBox);
1028 TQHBox* box =
new TQHBox(freqBox);
1029 box->setSpacing(KDialog::spacingHint());
1031 TQLabel* label =
new TQLabel(i18n(
"Recur e&very"), box);
1032 label->setFixedSize(label->sizeHint());
1036 mSpinBox = mTimeSpinBox =
new TimeSpinBox(1, 5999, box);
1037 mTimeSpinBox->setFixedSize(mTimeSpinBox->sizeHint());
1038 mTimeSpinBox->setReadOnly(readOnly);
1043 mSpinBox = mIntSpinBox =
new SpinBox(1, 999, 1, box);
1044 mIntSpinBox->setFixedSize(mIntSpinBox->sizeHint());
1045 mIntSpinBox->setReadOnly(readOnly);
1047 connect(mSpinBox, TQT_SIGNAL(valueChanged(
int)), TQT_SIGNAL(frequencyChanged()));
1048 label->setBuddy(mSpinBox);
1049 label =
new TQLabel(freqText, box);
1050 label->setFixedSize(label->sizeHint());
1051 box->setFixedSize(sizeHint());
1052 TQWhatsThis::add(box, freqWhatsThis);
1054 new TQWidget(freqBox);
1055 freqBox->setFixedHeight(freqBox->sizeHint().height());
1056 freqBox->setFocusProxy(mSpinBox);
1059 int Rule::frequency()
const
1062 return mIntSpinBox->value();
1064 return mTimeSpinBox->value();
1068 void Rule::setFrequency(
int n)
1071 mIntSpinBox->setValue(n);
1073 mTimeSpinBox->setValue(n);
1079 void Rule::saveState()
1081 mSavedFrequency = frequency();
1087 bool Rule::stateChanged()
const
1089 return (mSavedFrequency != frequency());
1098 SubDailyRule::SubDailyRule(
bool readOnly, TQWidget* parent,
const char* name)
1099 : Rule(i18n(
"hours:minutes"),
1100 i18n(
"Enter the number of hours and minutes between repetitions of the alarm"),
1101 true, readOnly, parent, name)
1110 DayWeekRule::DayWeekRule(
const TQString& freqText,
const TQString& freqWhatsThis,
const TQString& daysWhatsThis,
1111 bool readOnly, TQWidget* parent,
const char* name)
1112 : Rule(freqText, freqWhatsThis, false, readOnly, parent, name),
1115 TQGridLayout* grid =
new TQGridLayout(layout(), 1, 4, KDialog::spacingHint());
1116 grid->setRowStretch(0, 1);
1118 TQLabel* label =
new TQLabel(i18n(
"On: Tuesday",
"O&n:"),
this);
1119 label->setFixedSize(label->sizeHint());
1120 grid->addWidget(label, 0, 0, TQt::AlignRight | TQt::AlignTop);
1121 grid->addColSpacing(1, KDialog::spacingHint());
1125 TQWidget* box =
new TQWidget(
this);
1126 TQGridLayout* dgrid =
new TQGridLayout(box, 4, 2, 0, KDialog::spacingHint());
1127 const KCalendarSystem* calendar = TDEGlobal::locale()->calendar();
1128 for (
int i = 0; i < 7; ++i)
1130 int day = KAlarm::localeDayInWeek_to_weekDay(i);
1131 mDayBox[i] =
new CheckBox(calendar->weekDayName(day), box);
1132 mDayBox[i]->setFixedSize(mDayBox[i]->sizeHint());
1133 mDayBox[i]->setReadOnly(readOnly);
1134 dgrid->addWidget(mDayBox[i], i%4, i/4, TQt::AlignAuto);
1136 box->setFixedSize(box->sizeHint());
1137 TQWhatsThis::add(box, daysWhatsThis);
1138 grid->addWidget(box, 0, 2, TQt::AlignAuto);
1139 label->setBuddy(mDayBox[0]);
1140 grid->setColStretch(3, 1);
1146 TQBitArray DayWeekRule::days()
const
1150 for (
int i = 0; i < 7; ++i)
1151 if (mDayBox[i]->isChecked())
1152 ds.setBit(KAlarm::localeDayInWeek_to_weekDay(i) - 1, 1);
1159 void DayWeekRule::setDays(
bool tick)
1161 for (
int i = 0; i < 7; ++i)
1162 mDayBox[i]->setChecked(tick);
1168 void DayWeekRule::setDays(
const TQBitArray& days)
1170 for (
int i = 0; i < 7; ++i)
1172 bool x = days.testBit(KAlarm::localeDayInWeek_to_weekDay(i) - 1);
1173 mDayBox[i]->setChecked(x);
1180 void DayWeekRule::setDay(
int dayOfWeek)
1182 for (
int i = 0; i < 7; ++i)
1183 mDayBox[i]->setChecked(
false);
1184 if (dayOfWeek > 0 && dayOfWeek <= 7)
1185 mDayBox[KAlarm::weekDay_to_localeDayInWeek(dayOfWeek)]->setChecked(
true);
1191 TQWidget* DayWeekRule::validate(TQString& errorMessage)
1193 for (
int i = 0; i < 7; ++i)
1194 if (mDayBox[i]->isChecked())
1196 errorMessage = i18n(
"No day selected");
1203 void DayWeekRule::saveState()
1206 mSavedDays = days();
1212 bool DayWeekRule::stateChanged()
const
1214 return (Rule::stateChanged()
1215 || mSavedDays != days());
1224 DailyRule::DailyRule(
bool readOnly, TQWidget* parent,
const char* name)
1225 : DayWeekRule(i18n(
"day(s)"),
1226 i18n(
"Enter the number of days between repetitions of the alarm"),
1227 i18n(
"Select the days of the week on which the alarm is allowed to occur"),
1228 readOnly, parent, name)
1237 WeeklyRule::WeeklyRule(
bool readOnly, TQWidget* parent,
const char* name)
1238 : DayWeekRule(i18n(
"week(s)"),
1239 i18n(
"Enter the number of weeks between repetitions of the alarm"),
1240 i18n(
"Select the days of the week on which to repeat the alarm"),
1241 readOnly, parent, name)
1250 MonthYearRule::MonthYearRule(
const TQString& freqText,
const TQString& freqWhatsThis,
bool allowEveryWeek,
1251 bool readOnly, TQWidget* parent,
const char* name)
1252 : Rule(freqText, freqWhatsThis, false, readOnly, parent, name),
1253 mEveryWeek(allowEveryWeek)
1255 mButtonGroup =
new ButtonGroup(
this);
1256 mButtonGroup->hide();
1259 TQHBox* box =
new TQHBox(
this);
1260 box->setSpacing(KDialog::spacingHint());
1261 layout()->addWidget(box);
1263 mDayButton =
new RadioButton(i18n(
"On day number in the month",
"O&n day"), box);
1264 mDayButton->setFixedSize(mDayButton->sizeHint());
1265 mDayButton->setReadOnly(readOnly);
1266 mDayButtonId = mButtonGroup->insert(mDayButton);
1267 TQWhatsThis::add(mDayButton, i18n(
"Repeat the alarm on the selected day of the month"));
1269 mDayCombo =
new ComboBox(
false, box);
1270 mDayCombo->setSizeLimit(11);
1271 for (
int i = 0; i < 31; ++i)
1272 mDayCombo->insertItem(TQString::number(i + 1));
1273 mDayCombo->insertItem(i18n(
"Last day of month",
"Last"));
1274 mDayCombo->setFixedSize(mDayCombo->sizeHint());
1275 mDayCombo->setReadOnly(readOnly);
1276 TQWhatsThis::add(mDayCombo, i18n(
"Select the day of the month on which to repeat the alarm"));
1277 mDayButton->setFocusWidget(mDayCombo);
1278 connect(mDayCombo, TQT_SIGNAL(activated(
int)), TQT_SLOT(slotDaySelected(
int)));
1280 box->setStretchFactor(
new TQWidget(box), 1);
1281 box->setFixedHeight(box->sizeHint().height());
1284 box =
new TQHBox(
this);
1285 box->setSpacing(KDialog::spacingHint());
1286 layout()->addWidget(box);
1288 mPosButton =
new RadioButton(i18n(
"On the 1st Tuesday",
"On t&he"), box);
1289 mPosButton->setFixedSize(mPosButton->sizeHint());
1290 mPosButton->setReadOnly(readOnly);
1291 mPosButtonId = mButtonGroup->insert(mPosButton);
1292 TQWhatsThis::add(mPosButton,
1293 i18n(
"Repeat the alarm on one day of the week, in the selected week of the month"));
1295 mWeekCombo =
new ComboBox(
false, box);
1296 mWeekCombo->insertItem(i18n(
"1st"));
1297 mWeekCombo->insertItem(i18n(
"2nd"));
1298 mWeekCombo->insertItem(i18n(
"3rd"));
1299 mWeekCombo->insertItem(i18n(
"4th"));
1300 mWeekCombo->insertItem(i18n(
"5th"));
1301 mWeekCombo->insertItem(i18n(
"Last Monday in March",
"Last"));
1302 mWeekCombo->insertItem(i18n(
"2nd Last"));
1303 mWeekCombo->insertItem(i18n(
"3rd Last"));
1304 mWeekCombo->insertItem(i18n(
"4th Last"));
1305 mWeekCombo->insertItem(i18n(
"5th Last"));
1308 mWeekCombo->insertItem(i18n(
"Every (Monday...) in month",
"Every"));
1309 mWeekCombo->setSizeLimit(11);
1311 TQWhatsThis::add(mWeekCombo, i18n(
"Select the week of the month in which to repeat the alarm"));
1312 mWeekCombo->setFixedSize(mWeekCombo->sizeHint());
1313 mWeekCombo->setReadOnly(readOnly);
1314 mPosButton->setFocusWidget(mWeekCombo);
1316 mDayOfWeekCombo =
new ComboBox(
false, box);
1317 const KCalendarSystem* calendar = TDEGlobal::locale()->calendar();
1318 for (
int i = 0; i < 7; ++i)
1320 int day = KAlarm::localeDayInWeek_to_weekDay(i);
1321 mDayOfWeekCombo->insertItem(calendar->weekDayName(day));
1323 mDayOfWeekCombo->setReadOnly(readOnly);
1324 TQWhatsThis::add(mDayOfWeekCombo, i18n(
"Select the day of the week on which to repeat the alarm"));
1326 box->setStretchFactor(
new TQWidget(box), 1);
1327 box->setFixedHeight(box->sizeHint().height());
1328 connect(mButtonGroup, TQT_SIGNAL(buttonSet(
int)), TQT_SLOT(clicked(
int)));
1331 MonthYearRule::DayPosType MonthYearRule::type()
const
1333 return (mButtonGroup->selectedId() == mDayButtonId) ? DATE : POS;
1336 void MonthYearRule::setType(MonthYearRule::DayPosType type)
1338 mButtonGroup->setButton(type == DATE ? mDayButtonId : mPosButtonId);
1341 void MonthYearRule::setDefaultValues(
int dayOfMonth,
int dayOfWeek)
1344 mDayCombo->setCurrentItem(dayOfMonth);
1345 mWeekCombo->setCurrentItem(dayOfMonth / 7);
1346 mDayOfWeekCombo->setCurrentItem(KAlarm::weekDay_to_localeDayInWeek(dayOfWeek));
1349 int MonthYearRule::date()
const
1351 int daynum = mDayCombo->currentItem() + 1;
1352 return (daynum <= 31) ? daynum : 31 - daynum;
1355 int MonthYearRule::week()
const
1357 int weeknum = mWeekCombo->currentItem() + 1;
1358 return (weeknum <= 5) ? weeknum : (weeknum == 11) ? 0 : 5 - weeknum;
1361 int MonthYearRule::dayOfWeek()
const
1363 return KAlarm::localeDayInWeek_to_weekDay(mDayOfWeekCombo->currentItem());
1366 void MonthYearRule::setDate(
int dayOfMonth)
1368 mButtonGroup->setButton(mDayButtonId);
1369 mDayCombo->setCurrentItem(dayOfMonth > 0 ? dayOfMonth - 1 : dayOfMonth < 0 ? 30 - dayOfMonth : 0);
1372 void MonthYearRule::setPosition(
int week,
int dayOfWeek)
1374 mButtonGroup->setButton(mPosButtonId);
1375 mWeekCombo->setCurrentItem((week > 0) ? week - 1 : (week < 0) ? 4 - week : mEveryWeek ? 10 : 0);
1376 mDayOfWeekCombo->setCurrentItem(KAlarm::weekDay_to_localeDayInWeek(dayOfWeek));
1379 void MonthYearRule::enableSelection(DayPosType type)
1381 bool date = (type == DATE);
1382 mDayCombo->setEnabled(date);
1383 mWeekCombo->setEnabled(!date);
1384 mDayOfWeekCombo->setEnabled(!date);
1387 void MonthYearRule::clicked(
int id)
1389 enableSelection(
id == mDayButtonId ? DATE : POS);
1392 void MonthYearRule::slotDaySelected(
int index)
1394 daySelected(index <= 30 ? index + 1 : 30 - index);
1400 void MonthYearRule::saveState()
1403 mSavedType = type();
1404 if (mSavedType == DATE)
1408 mSavedWeek = week();
1409 mSavedWeekDay = dayOfWeek();
1416 bool MonthYearRule::stateChanged()
const
1418 if (Rule::stateChanged()
1419 || mSavedType != type())
1421 if (mSavedType == DATE)
1423 if (mSavedDay != date())
1428 if (mSavedWeek != week()
1429 || mSavedWeekDay != dayOfWeek())
1441 MonthlyRule::MonthlyRule(
bool readOnly, TQWidget* parent,
const char* name)
1442 : MonthYearRule(i18n(
"month(s)"),
1443 i18n(
"Enter the number of months between repetitions of the alarm"),
1444 false, readOnly, parent, name)
1453 YearlyRule::YearlyRule(
bool readOnly, TQWidget* parent,
const char* name)
1454 : MonthYearRule(i18n(
"year(s)"),
1455 i18n(
"Enter the number of years between repetitions of the alarm"),
1456 true, readOnly, parent, name)
1459 TQBoxLayout* hlayout =
new TQHBoxLayout(layout(), KDialog::spacingHint());
1460 TQLabel* label =
new TQLabel(i18n(
"List of months to select",
"Months:"),
this);
1461 label->setFixedSize(label->sizeHint());
1462 hlayout->addWidget(label, 0, TQt::AlignAuto | TQt::AlignTop);
1465 TQWidget* w =
new TQWidget(
this);
1466 hlayout->addWidget(w, 1, TQt::AlignAuto);
1467 TQGridLayout* grid =
new TQGridLayout(w, 4, 3, 0, KDialog::spacingHint());
1468 const KCalendarSystem* calendar = TDEGlobal::locale()->calendar();
1469 int year = TQDate::currentDate().year();
1470 for (
int i = 0; i < 12; ++i)
1472 mMonthBox[i] =
new CheckBox(calendar->monthName(i + 1, year,
true), w);
1473 mMonthBox[i]->setFixedSize(mMonthBox[i]->sizeHint());
1474 mMonthBox[i]->setReadOnly(readOnly);
1475 grid->addWidget(mMonthBox[i], i%3, i/3, TQt::AlignAuto);
1477 connect(mMonthBox[1], TQT_SIGNAL(toggled(
bool)), TQT_SLOT(enableFeb29()));
1478 w->setFixedHeight(w->sizeHint().height());
1479 TQWhatsThis::add(w, i18n(
"Select the months of the year in which to repeat the alarm"));
1482 TQHBox* f29box =
new TQHBox(
this);
1483 layout()->addWidget(f29box);
1484 TQHBox* box =
new TQHBox(f29box);
1485 box->setSpacing(KDialog::spacingHint());
1486 mFeb29Label =
new TQLabel(i18n(
"February 2&9th alarm in non-leap years:"), box);
1487 mFeb29Label->setFixedSize(mFeb29Label->sizeHint());
1488 mFeb29Combo =
new ComboBox(
false, box);
1489 mFeb29Combo->insertItem(i18n(
"No date",
"None"));
1490 mFeb29Combo->insertItem(i18n(
"1st March (short form)",
"1 Mar"));
1491 mFeb29Combo->insertItem(i18n(
"28th February (short form)",
"28 Feb"));
1492 mFeb29Combo->setFixedSize(mFeb29Combo->sizeHint());
1493 mFeb29Combo->setReadOnly(readOnly);
1494 mFeb29Label->setBuddy(mFeb29Combo);
1495 box->setFixedSize(box->sizeHint());
1496 TQWhatsThis::add(box,
1497 i18n(
"Select which date, if any, the February 29th alarm should trigger in non-leap years"));
1498 new TQWidget(f29box);
1499 f29box->setFixedHeight(f29box->sizeHint().height());
1502 void YearlyRule::setDefaultValues(
int dayOfMonth,
int dayOfWeek,
int month)
1504 MonthYearRule::setDefaultValues(dayOfMonth, dayOfWeek);
1506 for (
int i = 0; i < 12; ++i)
1507 mMonthBox[i]->setChecked(i == month);
1508 setFeb29Type(Preferences::defaultFeb29Type());
1509 daySelected(dayOfMonth);
1516 TQValueList<int> YearlyRule::months()
const
1518 TQValueList<int> mnths;
1519 for (
int i = 0; i < 12; ++i)
1520 if (mMonthBox[i]->isChecked() && mMonthBox[i]->isEnabled())
1521 mnths.append(i + 1);
1528 void YearlyRule::setMonths(
const TQValueList<int>& mnths)
1531 for (
int i = 0; i < 12; ++i)
1533 for (TQValueListConstIterator<int> it = mnths.begin(); it != mnths.end(); ++it)
1534 checked[(*it) - 1] =
true;
1535 for (
int i = 0; i < 12; ++i)
1536 mMonthBox[i]->setChecked(checked[i]);
1543 KARecurrence::Feb29Type YearlyRule::feb29Type()
const
1545 if (mFeb29Combo->isEnabled())
1547 switch (mFeb29Combo->currentItem())
1549 case 1:
return KARecurrence::FEB29_MAR1;
1550 case 2:
return KARecurrence::FEB29_FEB28;
1554 return KARecurrence::FEB29_FEB29;
1560 void YearlyRule::setFeb29Type(KARecurrence::Feb29Type type)
1566 case KARecurrence::FEB29_FEB29: index = 0;
break;
1567 case KARecurrence::FEB29_MAR1: index = 1;
break;
1568 case KARecurrence::FEB29_FEB28: index = 2;
break;
1570 mFeb29Combo->setCurrentItem(index);
1576 TQWidget* YearlyRule::validate(TQString& errorMessage)
1578 for (
int i = 0; i < 12; ++i)
1579 if (mMonthBox[i]->isChecked() && mMonthBox[i]->isEnabled())
1581 errorMessage = i18n(
"No month selected");
1582 return mMonthBox[0];
1589 void YearlyRule::clicked(
int id)
1591 MonthYearRule::clicked(
id);
1592 daySelected(buttonType(
id) == DATE ? date() : 1);
1599 void YearlyRule::daySelected(
int day)
1601 mMonthBox[1]->setEnabled(day <= 29);
1602 bool enable = (day != 31);
1603 mMonthBox[3]->setEnabled(enable);
1604 mMonthBox[5]->setEnabled(enable);
1605 mMonthBox[8]->setEnabled(enable);
1606 mMonthBox[10]->setEnabled(enable);
1614 void YearlyRule::enableFeb29()
1616 bool enable = (type() == DATE && date() == 29 && mMonthBox[1]->isChecked() && mMonthBox[1]->isEnabled());
1617 mFeb29Label->setEnabled(enable);
1618 mFeb29Combo->setEnabled(enable);
1624 void YearlyRule::saveState()
1626 MonthYearRule::saveState();
1627 mSavedMonths = months();
1628 mSavedFeb29Type = feb29Type();
1634 bool YearlyRule::stateChanged()
const
1636 return (MonthYearRule::stateChanged()
1637 || mSavedMonths != months()
1638 || mSavedFeb29Type != feb29Type());
represents calendar alarms and events
KAEvent corresponds to a KCal::Event instance.
the KAlarm application object