TDE
/
tdepim
mirror of https://mirror.git.trinitydesktop.org/gitea/TDE/tdepim
0
0
Fork 0
Code Issues Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '672beaaffc'
${ noResults }
tdepim/kalarm/recurrenceedit.cpp

1640 lines
56 KiB
Raw Normal View History Unescape

Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features. BUG:215923 git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdepim@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da
15 years ago
/*
* recurrenceedit.cpp - widget to edit the event's recurrence definition
* Program: kalarm
* Copyright © 2002-2008 by David Jarvie <djarvie@kde.org>
*
* Based originally on KOrganizer module koeditorrecurrence.cpp,
* Copyright (c) 2000,2001 Cornelius Schumacher <schumacher@kde.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#include "kalarm.h"
#include <qtooltip.h>
#include <qlayout.h>
#include <qvbox.h>
#include <qwidgetstack.h>
#include <qlistbox.h>
#include <qframe.h>
#include <qlabel.h>
#include <qpushbutton.h>
#include <qlineedit.h>
#include <qwhatsthis.h>
#include <kglobal.h>
#include <klocale.h>
#include <kcalendarsystem.h>
#include <kiconloader.h>
#include <kdialog.h>
#include <kmessagebox.h>
#include <kdebug.h>
#include <libkcal/event.h>
#include "alarmevent.h"
#include "alarmtimewidget.h"
#include "checkbox.h"
#include "combobox.h"
#include "dateedit.h"
#include "functions.h"
#include "kalarmapp.h"
#include "karecurrence.h"
#include "preferences.h"
#include "radiobutton.h"
#include "repetition.h"
#include "spinbox.h"
#include "timeedit.h"
#include "timespinbox.h"
#include "buttongroup.h"
using namespace KCal;
#include "recurrenceedit.moc"
#include "recurrenceeditprivate.moc"
// Collect these widget labels together to ensure consistent wording and
// translations across different modules.
QString RecurrenceEdit::i18n_Norecur() { return i18n("No recurrence"); }
QString RecurrenceEdit::i18n_NoRecur() { return i18n("No Recurrence"); }
QString RecurrenceEdit::i18n_AtLogin() { return i18n("At Login"); }
QString RecurrenceEdit::i18n_l_Atlogin() { return i18n("At &login"); }
QString RecurrenceEdit::i18n_HourlyMinutely() { return i18n("Hourly/Minutely"); }
QString RecurrenceEdit::i18n_u_HourlyMinutely() { return i18n("Ho&urly/Minutely"); }
QString RecurrenceEdit::i18n_Daily() { return i18n("Daily"); }
QString RecurrenceEdit::i18n_d_Daily() { return i18n("&Daily"); }
QString RecurrenceEdit::i18n_Weekly() { return i18n("Weekly"); }
QString RecurrenceEdit::i18n_w_Weekly() { return i18n("&Weekly"); }
QString RecurrenceEdit::i18n_Monthly() { return i18n("Monthly"); }
QString RecurrenceEdit::i18n_m_Monthly() { return i18n("&Monthly"); }
QString RecurrenceEdit::i18n_Yearly() { return i18n("Yearly"); }
QString RecurrenceEdit::i18n_y_Yearly() { return i18n("&Yearly"); }
RecurrenceEdit::RecurrenceEdit(bool readOnly, QWidget* parent, const char* name)
: QFrame(parent, name),
mRule(0),
mRuleButtonType(INVALID_RECUR),
mDailyShown(false),
mWeeklyShown(false),
mMonthlyShown(false),
mYearlyShown(false),
mNoEmitTypeChanged(true),
mReadOnly(readOnly)
{
QBoxLayout* layout;
QVBoxLayout* topLayout = new QVBoxLayout(this, 0, KDialog::spacingHint());
/* Create the recurrence rule Group box which holds the recurrence period
* selection buttons, and the weekly, monthly and yearly recurrence rule
* frames which specify options individual to each of these distinct
* sections of the recurrence rule. Each frame is made visible by the
* selection of its corresponding radio button.
*/
QGroupBox* recurGroup = new QGroupBox(1, Qt::Vertical, i18n("Recurrence Rule"), this, "recurGroup");
topLayout->addWidget(recurGroup);
QFrame* ruleFrame = new QFrame(recurGroup, "ruleFrame");
layout = new QVBoxLayout(ruleFrame, 0);
layout->addSpacing(KDialog::spacingHint()/2);
layout = new QHBoxLayout(layout, 0);
QBoxLayout* lay = new QVBoxLayout(layout, 0);
mRuleButtonGroup = new ButtonGroup(1, Qt::Horizontal, ruleFrame);
mRuleButtonGroup->setInsideMargin(0);
mRuleButtonGroup->setFrameStyle(QFrame::NoFrame);
lay->addWidget(mRuleButtonGroup);
lay->addStretch(); // top-adjust the interval radio buttons
connect(mRuleButtonGroup, SIGNAL(buttonSet(int)), SLOT(periodClicked(int)));
mNoneButton = new RadioButton(i18n_Norecur(), mRuleButtonGroup);
mNoneButton->setFixedSize(mNoneButton->sizeHint());
mNoneButton->setReadOnly(mReadOnly);
QWhatsThis::add(mNoneButton, i18n("Do not repeat the alarm"));
mAtLoginButton = new RadioButton(i18n_l_Atlogin(), mRuleButtonGroup);
mAtLoginButton->setFixedSize(mAtLoginButton->sizeHint());
mAtLoginButton->setReadOnly(mReadOnly);
QWhatsThis::add(mAtLoginButton,
i18n("Trigger the alarm at the specified date/time and at every login until then.\n"
"Note that it will also be triggered any time the alarm daemon is restarted."));
mSubDailyButton = new RadioButton(i18n_u_HourlyMinutely(), mRuleButtonGroup);
mSubDailyButton->setFixedSize(mSubDailyButton->sizeHint());
mSubDailyButton->setReadOnly(mReadOnly);
QWhatsThis::add(mSubDailyButton,
i18n("Repeat the alarm at hourly/minutely intervals"));
mDailyButton = new RadioButton(i18n_d_Daily(), mRuleButtonGroup);
mDailyButton->setFixedSize(mDailyButton->sizeHint());
mDailyButton->setReadOnly(mReadOnly);
QWhatsThis::add(mDailyButton,
i18n("Repeat the alarm at daily intervals"));
mWeeklyButton = new RadioButton(i18n_w_Weekly(), mRuleButtonGroup);
mWeeklyButton->setFixedSize(mWeeklyButton->sizeHint());
mWeeklyButton->setReadOnly(mReadOnly);
QWhatsThis::add(mWeeklyButton,
i18n("Repeat the alarm at weekly intervals"));
mMonthlyButton = new RadioButton(i18n_m_Monthly(), mRuleButtonGroup);
mMonthlyButton->setFixedSize(mMonthlyButton->sizeHint());
mMonthlyButton->setReadOnly(mReadOnly);
QWhatsThis::add(mMonthlyButton,
i18n("Repeat the alarm at monthly intervals"));
mYearlyButton = new RadioButton(i18n_y_Yearly(), mRuleButtonGroup);
mYearlyButton->setFixedSize(mYearlyButton->sizeHint());
mYearlyButton->setReadOnly(mReadOnly);
QWhatsThis::add(mYearlyButton,
i18n("Repeat the alarm at annual intervals"));
mNoneButtonId = mRuleButtonGroup->id(mNoneButton);
mAtLoginButtonId = mRuleButtonGroup->id(mAtLoginButton);
mSubDailyButtonId = mRuleButtonGroup->id(mSubDailyButton);
mDailyButtonId = mRuleButtonGroup->id(mDailyButton);
mWeeklyButtonId = mRuleButtonGroup->id(mWeeklyButton);
mMonthlyButtonId = mRuleButtonGroup->id(mMonthlyButton);
mYearlyButtonId = mRuleButtonGroup->id(mYearlyButton);
// Sub-repetition button
mSubRepetition = new RepetitionButton(i18n("Sub-Repetition"), true, ruleFrame);
mSubRepetition->setFixedSize(mSubRepetition->sizeHint());
mSubRepetition->setReadOnly(mReadOnly);
connect(mSubRepetition, SIGNAL(needsInitialisation()), SIGNAL(repeatNeedsInitialisation()));
connect(mSubRepetition, SIGNAL(changed()), SIGNAL(frequencyChanged()));
QWhatsThis::add(mSubRepetition, i18n("Set up a repetition within the recurrence, to trigger the alarm multiple times each time the recurrence is due."));
lay->addSpacing(KDialog::spacingHint());
lay->addWidget(mSubRepetition);
lay = new QVBoxLayout(layout);
lay->addStretch();
layout = new QHBoxLayout(lay);
layout->addSpacing(KDialog::marginHint());
QFrame* divider = new QFrame(ruleFrame);
divider->setFrameStyle(QFrame::VLine | QFrame::Sunken);
layout->addWidget(divider);
layout->addSpacing(KDialog::marginHint());
mNoRule = new NoRule(ruleFrame, "noFrame");
mSubDailyRule = new SubDailyRule(mReadOnly, ruleFrame, "subdayFrame");
mDailyRule = new DailyRule(mReadOnly, ruleFrame, "dayFrame");
mWeeklyRule = new WeeklyRule(mReadOnly, ruleFrame, "weekFrame");
mMonthlyRule = new MonthlyRule(mReadOnly, ruleFrame, "monthFrame");
mYearlyRule = new YearlyRule(mReadOnly, ruleFrame, "yearFrame");
connect(mSubDailyRule, SIGNAL(frequencyChanged()), this, SIGNAL(frequencyChanged()));
connect(mDailyRule, SIGNAL(frequencyChanged()), this, SIGNAL(frequencyChanged()));
connect(mWeeklyRule, SIGNAL(frequencyChanged()), this, SIGNAL(frequencyChanged()));
connect(mMonthlyRule, SIGNAL(frequencyChanged()), this, SIGNAL(frequencyChanged()));
connect(mYearlyRule, SIGNAL(frequencyChanged()), this, SIGNAL(frequencyChanged()));
mRuleStack = new QWidgetStack(ruleFrame);
layout->addWidget(mRuleStack);
layout->addStretch(1);
mRuleStack->addWidget(mNoRule, 0);
mRuleStack->addWidget(mSubDailyRule, 1);
mRuleStack->addWidget(mDailyRule, 2);
mRuleStack->addWidget(mWeeklyRule, 3);
mRuleStack->addWidget(mMonthlyRule, 4);
mRuleStack->addWidget(mYearlyRule, 5);
layout->addSpacing(KDialog::marginHint());
// Create the recurrence range group which contains the controls
// which specify how long the recurrence is to last.
mRangeButtonGroup = new ButtonGroup(i18n("Recurrence End"), this, "mRangeButtonGroup");
connect(mRangeButtonGroup, SIGNAL(buttonSet(int)), SLOT(rangeTypeClicked()));
topLayout->addWidget(mRangeButtonGroup);
QVBoxLayout* vlayout = new QVBoxLayout(mRangeButtonGroup, KDialog::marginHint(), KDialog::spacingHint());
vlayout->addSpacing(fontMetrics().lineSpacing()/2);
mNoEndDateButton = new RadioButton(i18n("No &end"), mRangeButtonGroup);
mNoEndDateButton->setFixedSize(mNoEndDateButton->sizeHint());
mNoEndDateButton->setReadOnly(mReadOnly);
QWhatsThis::add(mNoEndDateButton, i18n("Repeat the alarm indefinitely"));
vlayout->addWidget(mNoEndDateButton, 1, Qt::AlignAuto);
QSize size = mNoEndDateButton->size();
layout = new QHBoxLayout(vlayout, KDialog::spacingHint());
mRepeatCountButton = new RadioButton(i18n("End a&fter:"), mRangeButtonGroup);
mRepeatCountButton->setReadOnly(mReadOnly);
QWhatsThis::add(mRepeatCountButton,
i18n("Repeat the alarm for the number of times specified"));
mRepeatCountEntry = new SpinBox(1, 9999, 1, mRangeButtonGroup);
mRepeatCountEntry->setFixedSize(mRepeatCountEntry->sizeHint());
mRepeatCountEntry->setLineShiftStep(10);
mRepeatCountEntry->setSelectOnStep(false);
mRepeatCountEntry->setReadOnly(mReadOnly);
connect(mRepeatCountEntry, SIGNAL(valueChanged(int)), SLOT(repeatCountChanged(int)));
QWhatsThis::add(mRepeatCountEntry,
i18n("Enter the total number of times to trigger the alarm"));
mRepeatCountButton->setFocusWidget(mRepeatCountEntry);
mRepeatCountLabel = new QLabel(i18n("occurrence(s)"), mRangeButtonGroup);
mRepeatCountLabel->setFixedSize(mRepeatCountLabel->sizeHint());
layout->addWidget(mRepeatCountButton);
layout->addSpacing(KDialog::spacingHint());
layout->addWidget(mRepeatCountEntry);
layout->addWidget(mRepeatCountLabel);
layout->addStretch();
size = size.expandedTo(mRepeatCountButton->sizeHint());
layout = new QHBoxLayout(vlayout, KDialog::spacingHint());
mEndDateButton = new RadioButton(i18n("End &by:"), mRangeButtonGroup);
mEndDateButton->setReadOnly(mReadOnly);
QWhatsThis::add(mEndDateButton,
i18n("Repeat the alarm until the date/time specified.\n\n"
"Note: This applies to the main recurrence only. It does not limit any sub-repetition which will occur regardless after the last main recurrence."));
mEndDateEdit = new DateEdit(mRangeButtonGroup);
mEndDateEdit->setFixedSize(mEndDateEdit->sizeHint());
mEndDateEdit->setReadOnly(mReadOnly);
QWhatsThis::add(mEndDateEdit,
i18n("Enter the last date to repeat the alarm"));
mEndDateButton->setFocusWidget(mEndDateEdit);
mEndTimeEdit = new TimeEdit(mRangeButtonGroup);
mEndTimeEdit->setFixedSize(mEndTimeEdit->sizeHint());
mEndTimeEdit->setReadOnly(mReadOnly);
static const QString lastTimeText = i18n("Enter the last time to repeat the alarm.");
QWhatsThis::add(mEndTimeEdit, QString("%1\n\n%2").arg(lastTimeText).arg(TimeSpinBox::shiftWhatsThis()));
mEndAnyTimeCheckBox = new CheckBox(i18n("Any time"), mRangeButtonGroup);
mEndAnyTimeCheckBox->setFixedSize(mEndAnyTimeCheckBox->sizeHint());
mEndAnyTimeCheckBox->setReadOnly(mReadOnly);
connect(mEndAnyTimeCheckBox, SIGNAL(toggled(bool)), SLOT(slotAnyTimeToggled(bool)));
QWhatsThis::add(mEndAnyTimeCheckBox,
i18n("Stop repeating the alarm after your first login on or after the specified end date"));
layout->addWidget(mEndDateButton);
layout->addSpacing(KDialog::spacingHint());
layout->addWidget(mEndDateEdit);
layout->addWidget(mEndTimeEdit);
layout->addWidget(mEndAnyTimeCheckBox);
layout->addStretch();
size = size.expandedTo(mEndDateButton->sizeHint());
// Line up the widgets to the right of the radio buttons
mRepeatCountButton->setFixedSize(size);
mEndDateButton->setFixedSize(size);
// Create the exceptions group which specifies dates to be excluded
// from the recurrence.
mExceptionGroup = new QGroupBox(i18n("E&xceptions"), this, "mExceptionGroup");
topLayout->addWidget(mExceptionGroup);
topLayout->setStretchFactor(mExceptionGroup, 2);
vlayout = new QVBoxLayout(mExceptionGroup, KDialog::marginHint(), KDialog::spacingHint());
vlayout->addSpacing(fontMetrics().lineSpacing()/2);
layout = new QHBoxLayout(vlayout, KDialog::spacingHint());
vlayout = new QVBoxLayout(layout);
mExceptionDateList = new QListBox(mExceptionGroup);
mExceptionDateList->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding));
connect(mExceptionDateList, SIGNAL(selectionChanged()), SLOT(enableExceptionButtons()));
QWhatsThis::add(mExceptionDateList,
i18n("The list of exceptions, i.e. dates/times excluded from the recurrence"));
vlayout->addWidget(mExceptionDateList);
if (mReadOnly)
{
mExceptionDateEdit = 0;
mChangeExceptionButton = 0;
mDeleteExceptionButton = 0;
}
else
{
vlayout = new QVBoxLayout(layout);
mExceptionDateEdit = new DateEdit(mExceptionGroup);
mExceptionDateEdit->setFixedSize(mExceptionDateEdit->sizeHint());
mExceptionDateEdit->setDate(QDate::currentDate());
QWhatsThis::add(mExceptionDateEdit,
i18n("Enter a date to insert in the exceptions list. "
"Use in conjunction with the Add or Change button below."));
vlayout->addWidget(mExceptionDateEdit);
layout = new QHBoxLayout(vlayout, KDialog::spacingHint());
QPushButton* button = new QPushButton(i18n("Add"), mExceptionGroup);
button->setFixedSize(button->sizeHint());
connect(button, SIGNAL(clicked()), SLOT(addException()));
QWhatsThis::add(button,
i18n("Add the date entered above to the exceptions list"));
layout->addWidget(button);
mChangeExceptionButton = new QPushButton(i18n("Change"), mExceptionGroup);
mChangeExceptionButton->setFixedSize(mChangeExceptionButton->sizeHint());
connect(mChangeExceptionButton, SIGNAL(clicked()), SLOT(changeException()));
QWhatsThis::add(mChangeExceptionButton,
i18n("Replace the currently highlighted item in the exceptions list with the date entered above"));
layout->addWidget(mChangeExceptionButton);
mDeleteExceptionButton = new QPushButton(i18n("Delete"), mExceptionGroup);
mDeleteExceptionButton->setFixedSize(mDeleteExceptionButton->sizeHint());
connect(mDeleteExceptionButton, SIGNAL(clicked()), SLOT(deleteException()));
QWhatsThis::add(mDeleteExceptionButton,
i18n("Remove the currently highlighted item from the exceptions list"));
layout->addWidget(mDeleteExceptionButton);
}
mNoEmitTypeChanged = false;
}
/******************************************************************************
* Verify the consistency of the entered data.
* Reply = widget to receive focus on error, or 0 if no error.
*/
QWidget* RecurrenceEdit::checkData(const QDateTime& startDateTime, QString& errorMessage) const
{
if (mAtLoginButton->isOn())
return 0;
const_cast<RecurrenceEdit*>(this)->mCurrStartDateTime = startDateTime;
if (mEndDateButton->isChecked())
{
QWidget* errWidget = 0;
bool noTime = !mEndTimeEdit->isEnabled();
QDate endDate = mEndDateEdit->date();
if (endDate < startDateTime.date())
errWidget = mEndDateEdit;
else if (!noTime && QDateTime(endDate, mEndTimeEdit->time()) < startDateTime)
errWidget = mEndTimeEdit;
if (errWidget)
{
errorMessage = noTime
? i18n("End date is earlier than start date")
: i18n("End date/time is earlier than start date/time");
return errWidget;
}
}
if (!mRule)
return 0;
return mRule->validate(errorMessage);
}
/******************************************************************************
* Called when a recurrence period radio button is clicked.
*/
void RecurrenceEdit::periodClicked(int id)
{
RepeatType oldType = mRuleButtonType;
bool none = (id == mNoneButtonId);
bool atLogin = (id == mAtLoginButtonId);
bool subdaily = (id == mSubDailyButtonId);
if (none)
{
mRule = 0;
mRuleButtonType = NO_RECUR;
}
else if (atLogin)
{
mRule = 0;
mRuleButtonType = AT_LOGIN;
mRangeButtonGroup->setButton(mRangeButtonGroup->id(mEndDateButton));
}
else if (subdaily)
{
mRule = mSubDailyRule;
mRuleButtonType = SUBDAILY;
}
else if (id == mDailyButtonId)
{
mRule = mDailyRule;
mRuleButtonType = DAILY;
mDailyShown = true;
}
else if (id == mWeeklyButtonId)
{
mRule = mWeeklyRule;
mRuleButtonType = WEEKLY;
mWeeklyShown = true;
}
else if (id == mMonthlyButtonId)
{
mRule = mMonthlyRule;
mRuleButtonType = MONTHLY;
mMonthlyShown = true;
}
else if (id == mYearlyButtonId)
{
mRule = mYearlyRule;
mRuleButtonType = ANNUAL;
mYearlyShown = true;
}
else
return;
if (mRuleButtonType != oldType)
{
mRuleStack->raiseWidget(mRule ? mRule : mNoRule);
if (oldType == NO_RECUR || none)
mRangeButtonGroup->setEnabled(!none);
mExceptionGroup->setEnabled(!(none || atLogin));
mEndAnyTimeCheckBox->setEnabled(atLogin);
if (!none)
{
mNoEndDateButton->setEnabled(!atLogin);
mRepeatCountButton->setEnabled(!atLogin);
}
rangeTypeClicked();
mSubRepetition->setEnabled(!(none || atLogin));
if (!mNoEmitTypeChanged)
emit typeChanged(mRuleButtonType);
}
}
void RecurrenceEdit::slotAnyTimeToggled(bool on)
{
QButton* button = mRuleButtonGroup->selected();
mEndTimeEdit->setEnabled(button == mAtLoginButton && !on
|| button == mSubDailyButton && mEndDateButton->isChecked());
}
/******************************************************************************
* Called when a recurrence range type radio button is clicked.
*/
void RecurrenceEdit::rangeTypeClicked()
{
bool endDate = mEndDateButton->isOn();
mEndDateEdit->setEnabled(endDate);
mEndTimeEdit->setEnabled(endDate
&& (mAtLoginButton->isOn() && !mEndAnyTimeCheckBox->isChecked()
|| mSubDailyButton->isOn()));
bool repeatCount = mRepeatCountButton->isOn();
mRepeatCountEntry->setEnabled(repeatCount);
mRepeatCountLabel->setEnabled(repeatCount);
}
void RecurrenceEdit::showEvent(QShowEvent*)
{
if (mRule)
mRule->setFrequencyFocus();
else
mRuleButtonGroup->selected()->setFocus();
emit shown();
}
/******************************************************************************
* Return the sub-repetition count within the recurrence, i.e. the number of
* repetitions after the main recurrence.
*/
int RecurrenceEdit::subRepeatCount(int* subRepeatInterval) const
{
int count = (mRuleButtonType >= SUBDAILY) ? mSubRepetition->count() : 0;
if (subRepeatInterval)
*subRepeatInterval = count ? mSubRepetition->interval() : 0;
return count;
}
/******************************************************************************
* Called when the Sub-Repetition button has been pressed to display the
* sub-repetition dialog.
* Alarm repetition has the following restrictions:
* 1) Not allowed for a repeat-at-login alarm
* 2) For a date-only alarm, the repeat interval must be a whole number of days.
* 3) The overall repeat duration must be less than the recurrence interval.
*/
void RecurrenceEdit::setSubRepetition(int reminderMinutes, bool dateOnly)
{
int maxDuration;
switch (mRuleButtonType)
{
case RecurrenceEdit::NO_RECUR:
case RecurrenceEdit::AT_LOGIN: // alarm repeat not allowed
maxDuration = 0;
break;
default: // repeat duration must be less than recurrence interval
{
KAEvent event;
updateEvent(event, false);
maxDuration = event.longestRecurrenceInterval() - reminderMinutes - 1;
break;
}
}
mSubRepetition->initialise(mSubRepetition->interval(), mSubRepetition->count(), dateOnly, maxDuration);
mSubRepetition->setEnabled(mRuleButtonType >= SUBDAILY && maxDuration);
}
/******************************************************************************
* Activate the sub-repetition dialog.
*/
void RecurrenceEdit::activateSubRepetition()
{
mSubRepetition->activate();
}
/******************************************************************************
* Called when the value of the repeat count field changes, to reset the
* minimum value to 1 if the value was 0.
*/
void RecurrenceEdit::repeatCountChanged(int value)
{
if (value > 0 && mRepeatCountEntry->minValue() == 0)
mRepeatCountEntry->setMinValue(1);
}
/******************************************************************************
* Add the date entered in the exception date edit control to the list of
* exception dates.
*/
void RecurrenceEdit::addException()
{
if (!mExceptionDateEdit || !mExceptionDateEdit->isValid())
return;
QDate date = mExceptionDateEdit->date();
QValueList<QDate>::Iterator it;
int index = 0;
bool insert = true;
for (it = mExceptionDates.begin(); it != mExceptionDates.end(); ++index, ++it)
{
if (date <= *it)
{
insert = (date != *it);
break;
}
}
if (insert)
{
mExceptionDates.insert(it, date);
mExceptionDateList->insertItem(KGlobal::locale()->formatDate(date), index);
}
mExceptionDateList->setCurrentItem(index);
enableExceptionButtons();
}
/******************************************************************************
* Change the currently highlighted exception date to that entered in the
* exception date edit control.
*/
void RecurrenceEdit::changeException()
{
if (!mExceptionDateEdit || !mExceptionDateEdit->isValid())
return;
int index = mExceptionDateList->currentItem();
if (index >= 0 && mExceptionDateList->isSelected(index))
{
QDate olddate = mExceptionDates[index];
QDate newdate = mExceptionDateEdit->date();
if (newdate != olddate)
{
mExceptionDates.remove(mExceptionDates.at(index));
mExceptionDateList->removeItem(index);
addException();
}
}
}
/******************************************************************************
* Delete the currently highlighted exception date.
*/
void RecurrenceEdit::deleteException()
{
int index = mExceptionDateList->currentItem();
if (index >= 0 && mExceptionDateList->isSelected(index))
{
mExceptionDates.remove(mExceptionDates.at(index));
mExceptionDateList->removeItem(index);
enableExceptionButtons();
}
}
/******************************************************************************
* Enable/disable the exception group buttons according to whether any item is
* selected in the exceptions listbox.
*/
void RecurrenceEdit::enableExceptionButtons()
{
int index = mExceptionDateList->currentItem();
bool enable = (index >= 0 && mExceptionDateList->isSelected(index));
if (mDeleteExceptionButton)
mDeleteExceptionButton->setEnabled(enable);
if (mChangeExceptionButton)
mChangeExceptionButton->setEnabled(enable);
// Prevent the exceptions list box receiving keyboard focus is it's empty
mExceptionDateList->setFocusPolicy(mExceptionDateList->count() ? QWidget::WheelFocus : QWidget::NoFocus);
}
/******************************************************************************
* Notify this instance of a change in the alarm start date.
*/
void RecurrenceEdit::setStartDate(const QDate& start, const QDate& today)
{
if (!mReadOnly)
{
setRuleDefaults(start);
if (start < today)
{
mEndDateEdit->setMinDate(today);
if (mExceptionDateEdit)
mExceptionDateEdit->setMinDate(today);
}
else
{
const QString startString = i18n("Date cannot be earlier than start date", "start date");
mEndDateEdit->setMinDate(start, startString);
if (mExceptionDateEdit)
mExceptionDateEdit->setMinDate(start, startString);
}
}
}
/******************************************************************************
* Specify the default recurrence end date.
*/
void RecurrenceEdit::setDefaultEndDate(const QDate& end)
{
if (!mEndDateButton->isOn())
mEndDateEdit->setDate(end);
}
void RecurrenceEdit::setEndDateTime(const DateTime& end)
{
mEndDateEdit->setDate(end.date());
mEndTimeEdit->setValue(end.time());
mEndTimeEdit->setEnabled(!end.isDateOnly());
mEndAnyTimeCheckBox->setChecked(end.isDateOnly());
}
DateTime RecurrenceEdit::endDateTime() const
{
if (mRuleButtonGroup->selected() == mAtLoginButton && mEndAnyTimeCheckBox->isChecked())
return DateTime(mEndDateEdit->date());
return DateTime(mEndDateEdit->date(), mEndTimeEdit->time());
}
/******************************************************************************
* Set all controls to their default values.
*/
void RecurrenceEdit::setDefaults(const QDateTime& from)
{
mCurrStartDateTime = from;
QDate fromDate = from.date();
mNoEndDateButton->setChecked(true);
mSubDailyRule->setFrequency(1);
mDailyRule->setFrequency(1);
mWeeklyRule->setFrequency(1);
mMonthlyRule->setFrequency(1);
mYearlyRule->setFrequency(1);
setRuleDefaults(fromDate);
mMonthlyRule->setType(MonthYearRule::DATE); // date in month
mYearlyRule->setType(MonthYearRule::DATE); // date in year
mEndDateEdit->setDate(fromDate);
mNoEmitTypeChanged = true;
int button;
switch (Preferences::defaultRecurPeriod())
{
case AT_LOGIN: button = mAtLoginButtonId; break;
case ANNUAL: button = mYearlyButtonId; break;
case MONTHLY: button = mMonthlyButtonId; break;
case WEEKLY: button = mWeeklyButtonId; break;
case DAILY: button = mDailyButtonId; break;
case SUBDAILY: button = mSubDailyButtonId; break;
case NO_RECUR:
default: button = mNoneButtonId; break;
}
mRuleButtonGroup->setButton(button);
mNoEmitTypeChanged = false;
rangeTypeClicked();
enableExceptionButtons();
saveState();
}
/******************************************************************************
* Set the controls for weekly, monthly and yearly rules which have not so far
* been shown, to their default values, depending on the recurrence start date.
*/
void RecurrenceEdit::setRuleDefaults(const QDate& fromDate)
{
int day = fromDate.day();
int dayOfWeek = fromDate.dayOfWeek();
int month = fromDate.month();
if (!mDailyShown)
mDailyRule->setDays(true);
if (!mWeeklyShown)
mWeeklyRule->setDay(dayOfWeek);
if (!mMonthlyShown)
mMonthlyRule->setDefaultValues(day, dayOfWeek);
if (!mYearlyShown)
mYearlyRule->setDefaultValues(day, dayOfWeek, month);
}
/******************************************************************************
* Set the state of all controls to reflect the data in the specified event.
* Set 'keepDuration' true to prevent the recurrence count being adjusted to the
* remaining number of recurrences.
*/
void RecurrenceEdit::set(const KAEvent& event, bool keepDuration)
{
setDefaults(event.mainDateTime().dateTime());
if (event.repeatAtLogin())
{
mRuleButtonGroup->setButton(mAtLoginButtonId);
mEndDateButton->setChecked(true);
return;
}
mRuleButtonGroup->setButton(mNoneButtonId);
KARecurrence* recurrence = event.recurrence();
if (!recurrence)
return;
KARecurrence::Type rtype = recurrence->type();
switch (rtype)
{
case KARecurrence::MINUTELY:
mRuleButtonGroup->setButton(mSubDailyButtonId);
break;
case KARecurrence::DAILY:
{
mRuleButtonGroup->setButton(mDailyButtonId);
QBitArray rDays = recurrence->days();
bool set = false;
for (int i = 0; i < 7 && !set; ++i)
set = rDays.testBit(i);
if (set)
mDailyRule->setDays(rDays);
else
mDailyRule->setDays(true);
break;
}
case KARecurrence::WEEKLY:
{
mRuleButtonGroup->setButton(mWeeklyButtonId);
QBitArray rDays = recurrence->days();
mWeeklyRule->setDays(rDays);
break;
}
case KARecurrence::MONTHLY_POS: // on nth (Tuesday) of the month
{
QValueList<RecurrenceRule::WDayPos> posns = recurrence->monthPositions();
int i = posns.first().pos();
if (!i)
{
// It's every (Tuesday) of the month. Convert to a weekly recurrence
// (but ignoring any non-every xxxDay positions).
mRuleButtonGroup->setButton(mWeeklyButtonId);
mWeeklyRule->setFrequency(recurrence->frequency());
QBitArray rDays(7);
for (QValueList<RecurrenceRule::WDayPos>::ConstIterator it = posns.begin(); it != posns.end(); ++it)
{
if (!(*it).pos())
rDays.setBit((*it).day() - 1, 1);
}
mWeeklyRule->setDays(rDays);
break;
}
mRuleButtonGroup->setButton(mMonthlyButtonId);
mMonthlyRule->setPosition(i, posns.first().day());
break;
}
case KARecurrence::MONTHLY_DAY: // on nth day of the month
{
mRuleButtonGroup->setButton(mMonthlyButtonId);
QValueList<int> rmd = recurrence->monthDays();
int day = (rmd.isEmpty()) ? event.mainDate().day() : rmd.first();
mMonthlyRule->setDate(day);
break;
}
case KARecurrence::ANNUAL_DATE: // on the nth day of (months...) in the year
case KARecurrence::ANNUAL_POS: // on the nth (Tuesday) of (months...) in the year
{
if (rtype == KARecurrence::ANNUAL_DATE)
{
mRuleButtonGroup->setButton(mYearlyButtonId);
const QValueList<int> rmd = recurrence->monthDays();
int day = (rmd.isEmpty()) ? event.mainDate().day() : rmd.first();
mYearlyRule->setDate(day);
mYearlyRule->setFeb29Type(recurrence->feb29Type());
}
else if (rtype == KARecurrence::ANNUAL_POS)
{
mRuleButtonGroup->setButton(mYearlyButtonId);
QValueList<RecurrenceRule::WDayPos> posns = recurrence->yearPositions();
mYearlyRule->setPosition(posns.first().pos(), posns.first().day());
}
mYearlyRule->setMonths(recurrence->yearMonths());
break;
}
default:
return;
}
mRule->setFrequency(recurrence->frequency());
// Get range information
QDateTime endtime = mCurrStartDateTime;
int duration = recurrence->duration();
if (duration == -1)
mNoEndDateButton->setChecked(true);
else if (duration)
{
mRepeatCountButton->setChecked(true);
mRepeatCountEntry->setValue(duration);
}
else
{
mEndDateButton->setChecked(true);
endtime = recurrence->endDateTime();
mEndTimeEdit->setValue(endtime.time());
}
mEndDateEdit->setDate(endtime.date());
// Get exception information
mExceptionDates = event.recurrence()->exDates();
qHeapSort(mExceptionDates);
mExceptionDateList->clear();
for (DateList::ConstIterator it = mExceptionDates.begin(); it != mExceptionDates.end(); ++it)
mExceptionDateList->insertItem(KGlobal::locale()->formatDate(*it));
enableExceptionButtons();
// Get repetition within recurrence
mSubRepetition->set(event.repeatInterval(), event.repeatCount());
rangeTypeClicked();
saveState();
}
/******************************************************************************
* Update the specified KAEvent with the entered recurrence data.
* If 'adjustStart' is true, the start date/time will be adjusted if necessary
* to be the first date/time which recurs on or after the original start.
*/
void RecurrenceEdit::updateEvent(KAEvent& event, bool adjustStart)
{
// Get end date and repeat count, common to all types of recurring events
QDate endDate;
QTime endTime;
int repeatCount;
if (mNoEndDateButton->isChecked())
repeatCount = -1;
else if (mRepeatCountButton->isChecked())
repeatCount = mRepeatCountEntry->value();
else
{
repeatCount = 0;
endDate = mEndDateEdit->date();
endTime = mEndTimeEdit->time();
}
// Set up the recurrence according to the type selected
QButton* button = mRuleButtonGroup->selected();
event.setRepeatAtLogin(button == mAtLoginButton);
int frequency = mRule ? mRule->frequency() : 0;
if (button == mSubDailyButton)
{
QDateTime endDateTime(endDate, endTime);
event.setRecurMinutely(frequency, repeatCount, endDateTime);
}
else if (button == mDailyButton)
{
event.setRecurDaily(frequency, mDailyRule->days(), repeatCount, endDate);
}
else if (button == mWeeklyButton)
{
event.setRecurWeekly(frequency, mWeeklyRule->days(), repeatCount, endDate);
}
else if (button == mMonthlyButton)
{
if (mMonthlyRule->type() == MonthlyRule::POS)
{
// It's by position
KAEvent::MonthPos pos;
pos.days.fill(false);
pos.days.setBit(mMonthlyRule->dayOfWeek() - 1);
pos.weeknum = mMonthlyRule->week();
QValueList<KAEvent::MonthPos> poses;
poses.append(pos);
event.setRecurMonthlyByPos(frequency, poses, repeatCount, endDate);
}
else
{
// It's by day
int daynum = mMonthlyRule->date();
QValueList<int> daynums;
daynums.append(daynum);
event.setRecurMonthlyByDate(frequency, daynums, repeatCount, endDate);
}
}
else if (button == mYearlyButton)
{
QValueList<int> months = mYearlyRule->months();
if (mYearlyRule->type() == YearlyRule::POS)
{
// It's by position
KAEvent::MonthPos pos;
pos.days.fill(false);
pos.days.setBit(mYearlyRule->dayOfWeek() - 1);
pos.weeknum = mYearlyRule->week();
QValueList<KAEvent::MonthPos> poses;
poses.append(pos);
event.setRecurAnnualByPos(frequency, poses, months, repeatCount, endDate);
}
else
{
// It's by date in month
event.setRecurAnnualByDate(frequency, months, mYearlyRule->date(),
mYearlyRule->feb29Type(), repeatCount, endDate);
}
}
else
{
event.setNoRecur();
return;
}
if (!event.recurs())
return; // an error occurred setting up the recurrence
if (adjustStart)
event.setFirstRecurrence();
// Set up repetition within the recurrence.
// N.B. This requires the main recurrence to be set up first.
int count = mSubRepetition->count();
if (mRuleButtonType < SUBDAILY)
count = 0;
event.setRepetition(mSubRepetition->interval(), count);
// Set up exceptions
event.recurrence()->setExDates(mExceptionDates);
event.setUpdated();
}
/******************************************************************************
* Save the state of all controls.
*/
void RecurrenceEdit::saveState()
{
mSavedRuleButton = mRuleButtonGroup->selected();
if (mRule)
mRule->saveState();
mSavedRangeButton = mRangeButtonGroup->selected();
if (mSavedRangeButton == mRepeatCountButton)
mSavedRecurCount = mRepeatCountEntry->value();
else if (mSavedRangeButton == mEndDateButton)
mSavedEndDateTime.set(QDateTime(mEndDateEdit->date(), mEndTimeEdit->time()), mEndAnyTimeCheckBox->isChecked());
mSavedExceptionDates = mExceptionDates;
mSavedRepeatInterval = mSubRepetition->interval();
mSavedRepeatCount = mSubRepetition->count();
}
/******************************************************************************
* Check whether any of the controls have changed state since initialisation.
*/
bool RecurrenceEdit::stateChanged() const
{
if (mSavedRuleButton != mRuleButtonGroup->selected()
|| mSavedRangeButton != mRangeButtonGroup->selected()
|| mRule && mRule->stateChanged())
return true;
if (mSavedRangeButton == mRepeatCountButton
&& mSavedRecurCount != mRepeatCountEntry->value())
return true;
if (mSavedRangeButton == mEndDateButton
&& mSavedEndDateTime != DateTime(QDateTime(mEndDateEdit->date(), mEndTimeEdit->time()), mEndAnyTimeCheckBox->isChecked()))
return true;
if (mSavedExceptionDates != mExceptionDates
|| mSavedRepeatInterval != mSubRepetition->interval()
|| mSavedRepeatCount != mSubRepetition->count())
return true;
return false;
}
/*=============================================================================
= Class Rule
= Base class for rule widgets, including recurrence frequency.
=============================================================================*/
Rule::Rule(const QString& freqText, const QString& freqWhatsThis, bool time, bool readOnly, QWidget* parent, const char* name)
: NoRule(parent, name)
{
mLayout = new QVBoxLayout(this, 0, KDialog::spacingHint());
QHBox* freqBox = new QHBox(this);
mLayout->addWidget(freqBox);
QHBox* box = new QHBox(freqBox); // this is to control the QWhatsThis text display area
box->setSpacing(KDialog::spacingHint());
QLabel* label = new QLabel(i18n("Recur e&very"), box);
label->setFixedSize(label->sizeHint());
if (time)
{
mIntSpinBox = 0;
mSpinBox = mTimeSpinBox = new TimeSpinBox(1, 5999, box);
mTimeSpinBox->setFixedSize(mTimeSpinBox->sizeHint());
mTimeSpinBox->setReadOnly(readOnly);
}
else
{
mTimeSpinBox = 0;
mSpinBox = mIntSpinBox = new SpinBox(1, 999, 1, box);
mIntSpinBox->setFixedSize(mIntSpinBox->sizeHint());
mIntSpinBox->setReadOnly(readOnly);
}
connect(mSpinBox, SIGNAL(valueChanged(int)), SIGNAL(frequencyChanged()));
label->setBuddy(mSpinBox);
label = new QLabel(freqText, box);
label->setFixedSize(label->sizeHint());
box->setFixedSize(sizeHint());
QWhatsThis::add(box, freqWhatsThis);
new QWidget(freqBox); // left adjust the visible widgets
freqBox->setFixedHeight(freqBox->sizeHint().height());
freqBox->setFocusProxy(mSpinBox);
}
int Rule::frequency() const
{
if (mIntSpinBox)
return mIntSpinBox->value();
if (mTimeSpinBox)
return mTimeSpinBox->value();
return 0;
}
void Rule::setFrequency(int n)
{
if (mIntSpinBox)
mIntSpinBox->setValue(n);
if (mTimeSpinBox)
mTimeSpinBox->setValue(n);
}
/******************************************************************************
* Save the state of all controls.
*/
void Rule::saveState()
{
mSavedFrequency = frequency();
}
/******************************************************************************
* Check whether any of the controls have changed state since initialisation.
*/
bool Rule::stateChanged() const
{
return (mSavedFrequency != frequency());
}
/*=============================================================================
= Class SubDailyRule
= Sub-daily rule widget.
=============================================================================*/
SubDailyRule::SubDailyRule(bool readOnly, QWidget* parent, const char* name)
: Rule(i18n("hours:minutes"),
i18n("Enter the number of hours and minutes between repetitions of the alarm"),
true, readOnly, parent, name)
{ }
/*=============================================================================
= Class DayWeekRule
= Daily/weekly rule widget base class.
=============================================================================*/
DayWeekRule::DayWeekRule(const QString& freqText, const QString& freqWhatsThis, const QString& daysWhatsThis,
bool readOnly, QWidget* parent, const char* name)
: Rule(freqText, freqWhatsThis, false, readOnly, parent, name),
mSavedDays(7)
{
QGridLayout* grid = new QGridLayout(layout(), 1, 4, KDialog::spacingHint());
grid->setRowStretch(0, 1);
QLabel* label = new QLabel(i18n("On: Tuesday", "O&n:"), this);
label->setFixedSize(label->sizeHint());
grid->addWidget(label, 0, 0, Qt::AlignRight | Qt::AlignTop);
grid->addColSpacing(1, KDialog::spacingHint());
// List the days of the week starting at the user's start day of the week.
// Save the first day of the week, just in case it changes while the dialog is open.
QWidget* box = new QWidget(this); // this is to control the QWhatsThis text display area
QGridLayout* dgrid = new QGridLayout(box, 4, 2, 0, KDialog::spacingHint());
const KCalendarSystem* calendar = KGlobal::locale()->calendar();
for (int i = 0; i < 7; ++i)
{
int day = KAlarm::localeDayInWeek_to_weekDay(i);
mDayBox[i] = new CheckBox(calendar->weekDayName(day), box);
mDayBox[i]->setFixedSize(mDayBox[i]->sizeHint());
mDayBox[i]->setReadOnly(readOnly);
dgrid->addWidget(mDayBox[i], i%4, i/4, Qt::AlignAuto);
}
box->setFixedSize(box->sizeHint());
QWhatsThis::add(box, daysWhatsThis);
grid->addWidget(box, 0, 2, Qt::AlignAuto);
label->setBuddy(mDayBox[0]);
grid->setColStretch(3, 1);
}
/******************************************************************************
* Fetch which days of the week have been ticked.
*/
QBitArray DayWeekRule::days() const
{
QBitArray ds(7);
ds.fill(false);
for (int i = 0; i < 7; ++i)
if (mDayBox[i]->isChecked())
ds.setBit(KAlarm::localeDayInWeek_to_weekDay(i) - 1, 1);
return ds;
}
/******************************************************************************
* Tick/untick every day of the week.
*/
void DayWeekRule::setDays(bool tick)
{
for (int i = 0; i < 7; ++i)
mDayBox[i]->setChecked(tick);
}
/******************************************************************************
* Tick/untick each day of the week according to the specified bits.
*/
void DayWeekRule::setDays(const QBitArray& days)
{
for (int i = 0; i < 7; ++i)
{
bool x = days.testBit(KAlarm::localeDayInWeek_to_weekDay(i) - 1);
mDayBox[i]->setChecked(x);
}
}
/******************************************************************************
* Tick the specified day of the week, and untick all other days.
*/
void DayWeekRule::setDay(int dayOfWeek)
{
for (int i = 0; i < 7; ++i)
mDayBox[i]->setChecked(false);
if (dayOfWeek > 0 && dayOfWeek <= 7)
mDayBox[KAlarm::weekDay_to_localeDayInWeek(dayOfWeek)]->setChecked(true);
}
/******************************************************************************
* Validate: check that at least one day is selected.
*/
QWidget* DayWeekRule::validate(QString& errorMessage)
{
for (int i = 0; i < 7; ++i)
if (mDayBox[i]->isChecked())
return 0;
errorMessage = i18n("No day selected");
return mDayBox[0];
}
/******************************************************************************
* Save the state of all controls.
*/
void DayWeekRule::saveState()
{
Rule::saveState();
mSavedDays = days();
}
/******************************************************************************
* Check whether any of the controls have changed state since initialisation.
*/
bool DayWeekRule::stateChanged() const
{
return (Rule::stateChanged()
|| mSavedDays != days());
}
/*=============================================================================
= Class DailyRule
= Daily rule widget.
=============================================================================*/
DailyRule::DailyRule(bool readOnly, QWidget* parent, const char* name)
: DayWeekRule(i18n("day(s)"),
i18n("Enter the number of days between repetitions of the alarm"),
i18n("Select the days of the week on which the alarm is allowed to occur"),
readOnly, parent, name)
{ }
/*=============================================================================
= Class WeeklyRule
= Weekly rule widget.
=============================================================================*/
WeeklyRule::WeeklyRule(bool readOnly, QWidget* parent, const char* name)
: DayWeekRule(i18n("week(s)"),
i18n("Enter the number of weeks between repetitions of the alarm"),
i18n("Select the days of the week on which to repeat the alarm"),
readOnly, parent, name)
{ }
/*=============================================================================
= Class MonthYearRule
= Monthly/yearly rule widget base class.
=============================================================================*/
MonthYearRule::MonthYearRule(const QString& freqText, const QString& freqWhatsThis, bool allowEveryWeek,
bool readOnly, QWidget* parent, const char* name)
: Rule(freqText, freqWhatsThis, false, readOnly, parent, name),
mEveryWeek(allowEveryWeek)
{
mButtonGroup = new ButtonGroup(this);
mButtonGroup->hide();
// Month day selector
QHBox* box = new QHBox(this);
box->setSpacing(KDialog::spacingHint());
layout()->addWidget(box);
mDayButton = new RadioButton(i18n("On day number in the month", "O&n day"), box);
mDayButton->setFixedSize(mDayButton->sizeHint());
mDayButton->setReadOnly(readOnly);
mDayButtonId = mButtonGroup->insert(mDayButton);
QWhatsThis::add(mDayButton, i18n("Repeat the alarm on the selected day of the month"));
mDayCombo = new ComboBox(false, box);
mDayCombo->setSizeLimit(11);
for (int i = 0; i < 31; ++i)
mDayCombo->insertItem(QString::number(i + 1));
mDayCombo->insertItem(i18n("Last day of month", "Last"));
mDayCombo->setFixedSize(mDayCombo->sizeHint());
mDayCombo->setReadOnly(readOnly);
QWhatsThis::add(mDayCombo, i18n("Select the day of the month on which to repeat the alarm"));
mDayButton->setFocusWidget(mDayCombo);
connect(mDayCombo, SIGNAL(activated(int)), SLOT(slotDaySelected(int)));
box->setStretchFactor(new QWidget(box), 1); // left adjust the controls
box->setFixedHeight(box->sizeHint().height());
// Month position selector
box = new QHBox(this);
box->setSpacing(KDialog::spacingHint());
layout()->addWidget(box);
mPosButton = new RadioButton(i18n("On the 1st Tuesday", "On t&he"), box);
mPosButton->setFixedSize(mPosButton->sizeHint());
mPosButton->setReadOnly(readOnly);
mPosButtonId = mButtonGroup->insert(mPosButton);
QWhatsThis::add(mPosButton,
i18n("Repeat the alarm on one day of the week, in the selected week of the month"));
mWeekCombo = new ComboBox(false, box);
mWeekCombo->insertItem(i18n("1st"));
mWeekCombo->insertItem(i18n("2nd"));
mWeekCombo->insertItem(i18n("3rd"));
mWeekCombo->insertItem(i18n("4th"));
mWeekCombo->insertItem(i18n("5th"));
mWeekCombo->insertItem(i18n("Last Monday in March", "Last"));
mWeekCombo->insertItem(i18n("2nd Last"));
mWeekCombo->insertItem(i18n("3rd Last"));
mWeekCombo->insertItem(i18n("4th Last"));
mWeekCombo->insertItem(i18n("5th Last"));
if (mEveryWeek)
{
mWeekCombo->insertItem(i18n("Every (Monday...) in month", "Every"));
mWeekCombo->setSizeLimit(11);
}
QWhatsThis::add(mWeekCombo, i18n("Select the week of the month in which to repeat the alarm"));
mWeekCombo->setFixedSize(mWeekCombo->sizeHint());
mWeekCombo->setReadOnly(readOnly);
mPosButton->setFocusWidget(mWeekCombo);
mDayOfWeekCombo = new ComboBox(false, box);
const KCalendarSystem* calendar = KGlobal::locale()->calendar();
for (int i = 0; i < 7; ++i)
{
int day = KAlarm::localeDayInWeek_to_weekDay(i);
mDayOfWeekCombo->insertItem(calendar->weekDayName(day));
}
mDayOfWeekCombo->setReadOnly(readOnly);
QWhatsThis::add(mDayOfWeekCombo, i18n("Select the day of the week on which to repeat the alarm"));
box->setStretchFactor(new QWidget(box), 1); // left adjust the controls
box->setFixedHeight(box->sizeHint().height());
connect(mButtonGroup, SIGNAL(buttonSet(int)), SLOT(clicked(int)));
}
MonthYearRule::DayPosType MonthYearRule::type() const
{
return (mButtonGroup->selectedId() == mDayButtonId) ? DATE : POS;
}
void MonthYearRule::setType(MonthYearRule::DayPosType type)
{
mButtonGroup->setButton(type == DATE ? mDayButtonId : mPosButtonId);
}
void MonthYearRule::setDefaultValues(int dayOfMonth, int dayOfWeek)
{
--dayOfMonth;
mDayCombo->setCurrentItem(dayOfMonth);
mWeekCombo->setCurrentItem(dayOfMonth / 7);
mDayOfWeekCombo->setCurrentItem(KAlarm::weekDay_to_localeDayInWeek(dayOfWeek));
}
int MonthYearRule::date() const
{
int daynum = mDayCombo->currentItem() + 1;
return (daynum <= 31) ? daynum : 31 - daynum;
}
int MonthYearRule::week() const
{
int weeknum = mWeekCombo->currentItem() + 1;
return (weeknum <= 5) ? weeknum : (weeknum == 11) ? 0 : 5 - weeknum;
}
int MonthYearRule::dayOfWeek() const
{
return KAlarm::localeDayInWeek_to_weekDay(mDayOfWeekCombo->currentItem());
}
void MonthYearRule::setDate(int dayOfMonth)
{
mButtonGroup->setButton(mDayButtonId);
mDayCombo->setCurrentItem(dayOfMonth > 0 ? dayOfMonth - 1 : dayOfMonth < 0 ? 30 - dayOfMonth : 0); // day 0 shouldn't ever occur
}
void MonthYearRule::setPosition(int week, int dayOfWeek)
{
mButtonGroup->setButton(mPosButtonId);
mWeekCombo->setCurrentItem((week > 0) ? week - 1 : (week < 0) ? 4 - week : mEveryWeek ? 10 : 0);
mDayOfWeekCombo->setCurrentItem(KAlarm::weekDay_to_localeDayInWeek(dayOfWeek));
}
void MonthYearRule::enableSelection(DayPosType type)
{
bool date = (type == DATE);
mDayCombo->setEnabled(date);
mWeekCombo->setEnabled(!date);
mDayOfWeekCombo->setEnabled(!date);
}
void MonthYearRule::clicked(int id)
{
enableSelection(id == mDayButtonId ? DATE : POS);
}
void MonthYearRule::slotDaySelected(int index)
{
daySelected(index <= 30 ? index + 1 : 30 - index);
}
/******************************************************************************
* Save the state of all controls.
*/
void MonthYearRule::saveState()
{
Rule::saveState();
mSavedType = type();
if (mSavedType == DATE)
mSavedDay = date();
else
{
mSavedWeek = week();
mSavedWeekDay = dayOfWeek();
}
}
/******************************************************************************
* Check whether any of the controls have changed state since initialisation.
*/
bool MonthYearRule::stateChanged() const
{
if (Rule::stateChanged()
|| mSavedType != type())
return true;
if (mSavedType == DATE)
{
if (mSavedDay != date())
return true;
}
else
{
if (mSavedWeek != week()
|| mSavedWeekDay != dayOfWeek())
return true;
}
return false;
}
/*=============================================================================
= Class MonthlyRule
= Monthly rule widget.
=============================================================================*/
MonthlyRule::MonthlyRule(bool readOnly, QWidget* parent, const char* name)
: MonthYearRule(i18n("month(s)"),
i18n("Enter the number of months between repetitions of the alarm"),
false, readOnly, parent, name)
{ }
/*=============================================================================
= Class YearlyRule
= Yearly rule widget.
=============================================================================*/
YearlyRule::YearlyRule(bool readOnly, QWidget* parent, const char* name)
: MonthYearRule(i18n("year(s)"),
i18n("Enter the number of years between repetitions of the alarm"),
true, readOnly, parent, name)
{
// Set up the month selection widgets
QBoxLayout* hlayout = new QHBoxLayout(layout(), KDialog::spacingHint());
QLabel* label = new QLabel(i18n("List of months to select", "Months:"), this);
label->setFixedSize(label->sizeHint());
hlayout->addWidget(label, 0, Qt::AlignAuto | Qt::AlignTop);
// List the months of the year.
QWidget* w = new QWidget(this); // this is to control the QWhatsThis text display area
hlayout->addWidget(w, 1, Qt::AlignAuto);
QGridLayout* grid = new QGridLayout(w, 4, 3, 0, KDialog::spacingHint());
const KCalendarSystem* calendar = KGlobal::locale()->calendar();
int year = QDate::currentDate().year();
for (int i = 0; i < 12; ++i)
{
mMonthBox[i] = new CheckBox(calendar->monthName(i + 1, year, true), w);
mMonthBox[i]->setFixedSize(mMonthBox[i]->sizeHint());
mMonthBox[i]->setReadOnly(readOnly);
grid->addWidget(mMonthBox[i], i%3, i/3, Qt::AlignAuto);
}
connect(mMonthBox[1], SIGNAL(toggled(bool)), SLOT(enableFeb29()));
w->setFixedHeight(w->sizeHint().height());
QWhatsThis::add(w, i18n("Select the months of the year in which to repeat the alarm"));
// February 29th handling option
QHBox* f29box = new QHBox(this);
layout()->addWidget(f29box);
QHBox* box = new QHBox(f29box); // this is to control the QWhatsThis text display area
box->setSpacing(KDialog::spacingHint());
mFeb29Label = new QLabel(i18n("February 2&9th alarm in non-leap years:"), box);
mFeb29Label->setFixedSize(mFeb29Label->sizeHint());
mFeb29Combo = new ComboBox(false, box);
mFeb29Combo->insertItem(i18n("No date", "None"));
mFeb29Combo->insertItem(i18n("1st March (short form)", "1 Mar"));
mFeb29Combo->insertItem(i18n("28th February (short form)", "28 Feb"));
mFeb29Combo->setFixedSize(mFeb29Combo->sizeHint());
mFeb29Combo->setReadOnly(readOnly);
mFeb29Label->setBuddy(mFeb29Combo);
box->setFixedSize(box->sizeHint());
QWhatsThis::add(box,
i18n("Select which date, if any, the February 29th alarm should trigger in non-leap years"));
new QWidget(f29box); // left adjust the visible widgets
f29box->setFixedHeight(f29box->sizeHint().height());
}
void YearlyRule::setDefaultValues(int dayOfMonth, int dayOfWeek, int month)
{
MonthYearRule::setDefaultValues(dayOfMonth, dayOfWeek);
--month;
for (int i = 0; i < 12; ++i)
mMonthBox[i]->setChecked(i == month);
setFeb29Type(Preferences::defaultFeb29Type());
daySelected(dayOfMonth); // enable/disable month checkboxes as appropriate
}
/******************************************************************************
* Fetch which months have been checked (1 - 12).
* Reply = true if February has been checked.
*/
QValueList<int> YearlyRule::months() const
{
QValueList<int> mnths;
for (int i = 0; i < 12; ++i)
if (mMonthBox[i]->isChecked() && mMonthBox[i]->isEnabled())
mnths.append(i + 1);
return mnths;
}
/******************************************************************************
* Check/uncheck each month of the year according to the specified list.
*/
void YearlyRule::setMonths(const QValueList<int>& mnths)
{
bool checked[12];
for (int i = 0; i < 12; ++i)
checked[i] = false;
for (QValueListConstIterator<int> it = mnths.begin(); it != mnths.end(); ++it)
checked[(*it) - 1] = true;
for (int i = 0; i < 12; ++i)
mMonthBox[i]->setChecked(checked[i]);
enableFeb29();
}
/******************************************************************************
* Return the date for February 29th alarms in non-leap years.
*/
KARecurrence::Feb29Type YearlyRule::feb29Type() const
{
if (mFeb29Combo->isEnabled())
{
switch (mFeb29Combo->currentItem())
{
case 1: return KARecurrence::FEB29_MAR1;
case 2: return KARecurrence::FEB29_FEB28;
default: break;
}
}
return KARecurrence::FEB29_FEB29;
}
/******************************************************************************
* Set the date for February 29th alarms to trigger in non-leap years.
*/
void YearlyRule::setFeb29Type(KARecurrence::Feb29Type type)
{
int index;
switch (type)
{
default:
case KARecurrence::FEB29_FEB29: index = 0; break;
case KARecurrence::FEB29_MAR1: index = 1; break;
case KARecurrence::FEB29_FEB28: index = 2; break;
}
mFeb29Combo->setCurrentItem(index);
}
/******************************************************************************
* Validate: check that at least one month is selected.
*/
QWidget* YearlyRule::validate(QString& errorMessage)
{
for (int i = 0; i < 12; ++i)
if (mMonthBox[i]->isChecked() && mMonthBox[i]->isEnabled())
return 0;
errorMessage = i18n("No month selected");
return mMonthBox[0];
}
/******************************************************************************
* Called when a yearly recurrence type radio button is clicked,
* to enable/disable month checkboxes as appropriate for the date selected.
*/
void YearlyRule::clicked(int id)
{
MonthYearRule::clicked(id);
daySelected(buttonType(id) == DATE ? date() : 1);
}
/******************************************************************************
* Called when a day of the month is selected in a yearly recurrence, to
* disable months for which the day is out of range.
*/
void YearlyRule::daySelected(int day)
{
mMonthBox[1]->setEnabled(day <= 29); // February
bool enable = (day != 31);
mMonthBox[3]->setEnabled(enable); // April
mMonthBox[5]->setEnabled(enable); // June
mMonthBox[8]->setEnabled(enable); // September
mMonthBox[10]->setEnabled(enable); // November
enableFeb29();
}
/******************************************************************************
* Enable/disable the February 29th combo box depending on whether February
* 29th is selected.
*/
void YearlyRule::enableFeb29()
{
bool enable = (type() == DATE && date() == 29 && mMonthBox[1]->isChecked() && mMonthBox[1]->isEnabled());
mFeb29Label->setEnabled(enable);
mFeb29Combo->setEnabled(enable);
}
/******************************************************************************
* Save the state of all controls.
*/
void YearlyRule::saveState()
{
MonthYearRule::saveState();
mSavedMonths = months();
mSavedFeb29Type = feb29Type();
}
/******************************************************************************
* Check whether any of the controls have changed state since initialisation.
*/
bool YearlyRule::stateChanged() const
{
return (MonthYearRule::stateChanged()
|| mSavedMonths != months()
|| mSavedFeb29Type != feb29Type());
}