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.
557 lines
18 KiB
557 lines
18 KiB
/*
|
|
* alarmtimewidget.cpp - alarm date/time entry widget
|
|
* Program: kalarm
|
|
* Copyright © 2001-2007 by David Jarvie <software@astrojar.org.uk>
|
|
*
|
|
* 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 <tqlayout.h>
|
|
#include <tqgroupbox.h>
|
|
#include <tqhbox.h>
|
|
#include <tqpushbutton.h>
|
|
#include <tqwhatsthis.h>
|
|
|
|
#include <kdialog.h>
|
|
#include <tdemessagebox.h>
|
|
#include <tdelocale.h>
|
|
|
|
#include "checkbox.h"
|
|
#include "dateedit.h"
|
|
#include "datetime.h"
|
|
#include "radiobutton.h"
|
|
#include "synchtimer.h"
|
|
#include "timeedit.h"
|
|
#include "timespinbox.h"
|
|
#include "alarmtimewidget.moc"
|
|
|
|
static const TQTime time_23_59(23, 59);
|
|
|
|
|
|
const int AlarmTimeWidget::maxDelayTime = 999*60 + 59; // < 1000 hours
|
|
|
|
TQString AlarmTimeWidget::i18n_w_TimeFromNow() { return i18n("Time from no&w:"); }
|
|
TQString AlarmTimeWidget::i18n_TimeAfterPeriod()
|
|
{
|
|
return i18n("Enter the length of time (in hours and minutes) after "
|
|
"the current time to schedule the alarm.");
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
* Construct a widget with a group box and title.
|
|
*/
|
|
AlarmTimeWidget::AlarmTimeWidget(const TQString& groupBoxTitle, int mode, TQWidget* parent, const char* name)
|
|
: ButtonGroup(groupBoxTitle, parent, name),
|
|
mMinDateTimeIsNow(false),
|
|
mPastMax(false),
|
|
mMinMaxTimeSet(false)
|
|
{
|
|
init(mode);
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Construct a widget without a group box or title.
|
|
*/
|
|
AlarmTimeWidget::AlarmTimeWidget(int mode, TQWidget* parent, const char* name)
|
|
: ButtonGroup(parent, name),
|
|
mMinDateTimeIsNow(false),
|
|
mPastMax(false),
|
|
mMinMaxTimeSet(false)
|
|
{
|
|
setFrameStyle(TQFrame::NoFrame);
|
|
init(mode);
|
|
}
|
|
|
|
void AlarmTimeWidget::init(int mode)
|
|
{
|
|
static const TQString recurText = i18n("For a simple repetition, enter the date/time of the first occurrence.\n"
|
|
"If a recurrence is configured, the start date/time will be adjusted "
|
|
"to the first recurrence on or after the entered date/time.");
|
|
|
|
connect(this, TQ_SIGNAL(buttonSet(int)), TQ_SLOT(slotButtonSet(int)));
|
|
TQBoxLayout* topLayout = new TQVBoxLayout(this, 0, KDialog::spacingHint());
|
|
if (!title().isEmpty())
|
|
{
|
|
topLayout->setMargin(KDialog::marginHint());
|
|
topLayout->addSpacing(fontMetrics().lineSpacing()/2);
|
|
}
|
|
|
|
// At time radio button/label
|
|
mAtTimeRadio = new RadioButton(((mode & DEFER_TIME) ? i18n("&Defer to date/time:") : i18n("At &date/time:")), this, "atTimeRadio");
|
|
mAtTimeRadio->setFixedSize(mAtTimeRadio->sizeHint());
|
|
TQWhatsThis::add(mAtTimeRadio,
|
|
((mode & DEFER_TIME) ? i18n("Reschedule the alarm to the specified date and time.")
|
|
: i18n("Schedule the alarm at the specified date and time.")));
|
|
|
|
// Date edit box
|
|
mDateEdit = new DateEdit(this);
|
|
mDateEdit->setFixedSize(mDateEdit->sizeHint());
|
|
connect(mDateEdit, TQ_SIGNAL(dateEntered(const TQDate&)), TQ_SLOT(dateTimeChanged()));
|
|
static const TQString enterDateText = i18n("Enter the date to schedule the alarm.");
|
|
TQWhatsThis::add(mDateEdit, ((mode & DEFER_TIME) ? enterDateText
|
|
: TQString("%1\n%2").arg(enterDateText).arg(recurText)));
|
|
mAtTimeRadio->setFocusWidget(mDateEdit);
|
|
|
|
// Time edit box and Any time checkbox
|
|
TQHBox* timeBox = new TQHBox(this);
|
|
timeBox->setSpacing(2*KDialog::spacingHint());
|
|
mTimeEdit = new TimeEdit(timeBox);
|
|
mTimeEdit->setFixedSize(mTimeEdit->sizeHint());
|
|
connect(mTimeEdit, TQ_SIGNAL(valueChanged(int)), TQ_SLOT(dateTimeChanged()));
|
|
static const TQString enterTimeText = i18n("Enter the time to schedule the alarm.");
|
|
TQWhatsThis::add(mTimeEdit,
|
|
((mode & DEFER_TIME) ? TQString("%1\n\n%2").arg(enterTimeText).arg(TimeSpinBox::shiftWhatsThis())
|
|
: TQString("%1\n%2\n\n%3").arg(enterTimeText).arg(recurText).arg(TimeSpinBox::shiftWhatsThis())));
|
|
|
|
mAnyTime = -1; // current status is uninitialised
|
|
if (mode & DEFER_TIME)
|
|
{
|
|
mAnyTimeAllowed = false;
|
|
mAnyTimeCheckBox = 0;
|
|
}
|
|
else
|
|
{
|
|
mAnyTimeAllowed = true;
|
|
mAnyTimeCheckBox = new CheckBox(i18n("An&y time"), timeBox);
|
|
mAnyTimeCheckBox->setFixedSize(mAnyTimeCheckBox->sizeHint());
|
|
connect(mAnyTimeCheckBox, TQ_SIGNAL(toggled(bool)), TQ_SLOT(slotAnyTimeToggled(bool)));
|
|
TQWhatsThis::add(mAnyTimeCheckBox, i18n("Schedule the alarm for any time during the day"));
|
|
}
|
|
|
|
// 'Time from now' radio button/label
|
|
mAfterTimeRadio = new RadioButton(((mode & DEFER_TIME) ? i18n("Defer for time &interval:") : i18n_w_TimeFromNow()),
|
|
this, "afterTimeRadio");
|
|
mAfterTimeRadio->setFixedSize(mAfterTimeRadio->sizeHint());
|
|
TQWhatsThis::add(mAfterTimeRadio,
|
|
((mode & DEFER_TIME) ? i18n("Reschedule the alarm for the specified time interval after now.")
|
|
: i18n("Schedule the alarm after the specified time interval from now.")));
|
|
|
|
// Delay time spin box
|
|
mDelayTimeEdit = new TimeSpinBox(1, maxDelayTime, this);
|
|
mDelayTimeEdit->setValue(maxDelayTime);
|
|
mDelayTimeEdit->setFixedSize(mDelayTimeEdit->sizeHint());
|
|
connect(mDelayTimeEdit, TQ_SIGNAL(valueChanged(int)), TQ_SLOT(delayTimeChanged(int)));
|
|
TQWhatsThis::add(mDelayTimeEdit,
|
|
((mode & DEFER_TIME) ? TQString("%1\n\n%2").arg(i18n_TimeAfterPeriod()).arg(TimeSpinBox::shiftWhatsThis())
|
|
: TQString("%1\n%2\n\n%3").arg(i18n_TimeAfterPeriod()).arg(recurText).arg(TimeSpinBox::shiftWhatsThis())));
|
|
mAfterTimeRadio->setFocusWidget(mDelayTimeEdit);
|
|
|
|
// Set up the layout, either narrow or wide
|
|
if (mode & NARROW)
|
|
{
|
|
TQGridLayout* grid = new TQGridLayout(topLayout, 2, 2, KDialog::spacingHint());
|
|
grid->addWidget(mAtTimeRadio, 0, 0);
|
|
grid->addWidget(mDateEdit, 0, 1, TQt::AlignAuto);
|
|
grid->addWidget(timeBox, 1, 1, TQt::AlignAuto);
|
|
grid->setColStretch(2, 1);
|
|
topLayout->addStretch();
|
|
TQBoxLayout* layout = new TQHBoxLayout(topLayout, KDialog::spacingHint());
|
|
layout->addWidget(mAfterTimeRadio);
|
|
layout->addWidget(mDelayTimeEdit);
|
|
layout->addStretch();
|
|
}
|
|
else
|
|
{
|
|
TQGridLayout* grid = new TQGridLayout(topLayout, 2, 3, KDialog::spacingHint());
|
|
grid->addWidget(mAtTimeRadio, 0, 0, TQt::AlignAuto);
|
|
grid->addWidget(mDateEdit, 0, 1, TQt::AlignAuto);
|
|
grid->addWidget(timeBox, 0, 2, TQt::AlignAuto);
|
|
grid->setRowStretch(0, 1);
|
|
grid->addWidget(mAfterTimeRadio, 1, 0, TQt::AlignAuto);
|
|
grid->addWidget(mDelayTimeEdit, 1, 1, TQt::AlignAuto);
|
|
grid->setColStretch(3, 1);
|
|
topLayout->addStretch();
|
|
}
|
|
|
|
// Initialise the radio button statuses
|
|
setButton(id(mAtTimeRadio));
|
|
|
|
// Timeout every minute to update alarm time fields.
|
|
MinuteTimer::connect(this, TQ_SLOT(slotTimer()));
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Set or clear read-only status for the controls
|
|
*/
|
|
void AlarmTimeWidget::setReadOnly(bool ro)
|
|
{
|
|
mAtTimeRadio->setReadOnly(ro);
|
|
mDateEdit->setReadOnly(ro);
|
|
mTimeEdit->setReadOnly(ro);
|
|
if (mAnyTimeCheckBox)
|
|
mAnyTimeCheckBox->setReadOnly(ro);
|
|
mAfterTimeRadio->setReadOnly(ro);
|
|
mDelayTimeEdit->setReadOnly(ro);
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Select the "Time from now" radio button.
|
|
*/
|
|
void AlarmTimeWidget::selectTimeFromNow(int minutes)
|
|
{
|
|
mAfterTimeRadio->setChecked(true);
|
|
slotButtonSet(1);
|
|
if (minutes > 0)
|
|
mDelayTimeEdit->setValue(minutes);
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Fetch the entered date/time.
|
|
* If 'checkExpired' is true and the entered value <= current time, an error occurs.
|
|
* If 'minsFromNow' is non-null, it is set to the number of minutes' delay selected,
|
|
* or to zero if a date/time was entered.
|
|
* In this case, if 'showErrorMessage' is true, output an error message.
|
|
* 'errorWidget' if non-null, is set to point to the widget containing the error.
|
|
* Reply = invalid date/time if error.
|
|
*/
|
|
DateTime AlarmTimeWidget::getDateTime(int* minsFromNow, bool checkExpired, bool showErrorMessage, TQWidget** errorWidget) const
|
|
{
|
|
if (minsFromNow)
|
|
*minsFromNow = 0;
|
|
if (errorWidget)
|
|
*errorWidget = 0;
|
|
TQTime nowt = TQTime::currentTime();
|
|
TQDateTime now(TQDate::currentDate(), TQTime(nowt.hour(), nowt.minute()));
|
|
if (mAtTimeRadio->isOn())
|
|
{
|
|
bool anyTime = mAnyTimeAllowed && mAnyTimeCheckBox && mAnyTimeCheckBox->isChecked();
|
|
if (!mDateEdit->isValid() || !mTimeEdit->isValid())
|
|
{
|
|
// The date and/or time is invalid
|
|
if (!mDateEdit->isValid())
|
|
{
|
|
if (showErrorMessage)
|
|
KMessageBox::sorry(const_cast<AlarmTimeWidget*>(this), i18n("Invalid date"));
|
|
if (errorWidget)
|
|
*errorWidget = mDateEdit;
|
|
}
|
|
else
|
|
{
|
|
if (showErrorMessage)
|
|
KMessageBox::sorry(const_cast<AlarmTimeWidget*>(this), i18n("Invalid time"));
|
|
if (errorWidget)
|
|
*errorWidget = mTimeEdit;
|
|
}
|
|
return DateTime();
|
|
}
|
|
|
|
DateTime result;
|
|
if (anyTime)
|
|
{
|
|
result = mDateEdit->date();
|
|
if (checkExpired && result.date() < now.date())
|
|
{
|
|
if (showErrorMessage)
|
|
KMessageBox::sorry(const_cast<AlarmTimeWidget*>(this), i18n("Alarm date has already expired"));
|
|
if (errorWidget)
|
|
*errorWidget = mDateEdit;
|
|
return DateTime();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
result.set(mDateEdit->date(), mTimeEdit->time());
|
|
if (checkExpired && result <= TQDateTime(now.addSecs(1)))
|
|
{
|
|
if (showErrorMessage)
|
|
KMessageBox::sorry(const_cast<AlarmTimeWidget*>(this), i18n("Alarm time has already expired"));
|
|
if (errorWidget)
|
|
*errorWidget = mTimeEdit;
|
|
return DateTime();
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
else
|
|
{
|
|
if (!mDelayTimeEdit->isValid())
|
|
{
|
|
if (showErrorMessage)
|
|
KMessageBox::sorry(const_cast<AlarmTimeWidget*>(this), i18n("Invalid time"));
|
|
if (errorWidget)
|
|
*errorWidget = mDelayTimeEdit;
|
|
return DateTime();
|
|
}
|
|
int delayMins = mDelayTimeEdit->value();
|
|
if (minsFromNow)
|
|
*minsFromNow = delayMins;
|
|
return TQDateTime(now.addSecs(delayMins * 60));
|
|
}
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Set the date/time.
|
|
*/
|
|
void AlarmTimeWidget::setDateTime(const DateTime& dt)
|
|
{
|
|
if (dt.date().isValid())
|
|
{
|
|
mTimeEdit->setValue(dt.time());
|
|
mDateEdit->setDate(dt.date());
|
|
dateTimeChanged(); // update the delay time edit box
|
|
}
|
|
else
|
|
{
|
|
mTimeEdit->setValid(false);
|
|
mDateEdit->setInvalid();
|
|
mDelayTimeEdit->setValid(false);
|
|
}
|
|
if (mAnyTimeCheckBox)
|
|
{
|
|
bool anyTime = dt.isDateOnly();
|
|
if (anyTime)
|
|
mAnyTimeAllowed = true;
|
|
mAnyTimeCheckBox->setChecked(anyTime);
|
|
setAnyTime();
|
|
}
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Set the minimum date/time to track the current time.
|
|
*/
|
|
void AlarmTimeWidget::setMinDateTimeIsCurrent()
|
|
{
|
|
mMinDateTimeIsNow = true;
|
|
mMinDateTime = TQDateTime();
|
|
TQDateTime now = TQDateTime::currentDateTime();
|
|
mDateEdit->setMinDate(now.date());
|
|
setMaxMinTimeIf(now);
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Set the minimum date/time, adjusting the entered date/time if necessary.
|
|
* If 'dt' is invalid, any current minimum date/time is cleared.
|
|
*/
|
|
void AlarmTimeWidget::setMinDateTime(const TQDateTime& dt)
|
|
{
|
|
mMinDateTimeIsNow = false;
|
|
mMinDateTime = dt;
|
|
mDateEdit->setMinDate(dt.date());
|
|
setMaxMinTimeIf(TQDateTime::currentDateTime());
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Set the maximum date/time, adjusting the entered date/time if necessary.
|
|
* If 'dt' is invalid, any current maximum date/time is cleared.
|
|
*/
|
|
void AlarmTimeWidget::setMaxDateTime(const DateTime& dt)
|
|
{
|
|
mPastMax = false;
|
|
if (dt.isValid() && dt.isDateOnly())
|
|
mMaxDateTime = dt.dateTime().addSecs(24*3600 - 60);
|
|
else
|
|
mMaxDateTime = dt.dateTime();
|
|
mDateEdit->setMaxDate(mMaxDateTime.date());
|
|
TQDateTime now = TQDateTime::currentDateTime();
|
|
setMaxMinTimeIf(now);
|
|
setMaxDelayTime(now);
|
|
}
|
|
|
|
/******************************************************************************
|
|
* If the minimum and maximum date/times fall on the same date, set the minimum
|
|
* and maximum times in the time edit box.
|
|
*/
|
|
void AlarmTimeWidget::setMaxMinTimeIf(const TQDateTime& now)
|
|
{
|
|
int mint = 0;
|
|
TQTime maxt = time_23_59;
|
|
mMinMaxTimeSet = false;
|
|
if (mMaxDateTime.isValid())
|
|
{
|
|
bool set = true;
|
|
TQDateTime minDT;
|
|
if (mMinDateTimeIsNow)
|
|
minDT = now.addSecs(60);
|
|
else if (mMinDateTime.isValid())
|
|
minDT = mMinDateTime;
|
|
else
|
|
set = false;
|
|
if (set && mMaxDateTime.date() == minDT.date())
|
|
{
|
|
// The minimum and maximum times are on the same date, so
|
|
// constrain the time value.
|
|
mint = minDT.time().hour()*60 + minDT.time().minute();
|
|
maxt = mMaxDateTime.time();
|
|
mMinMaxTimeSet = true;
|
|
}
|
|
}
|
|
mTimeEdit->setMinValue(mint);
|
|
mTimeEdit->setMaxValue(maxt);
|
|
mTimeEdit->setWrapping(!mint && maxt == time_23_59);
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Set the maximum value for the delay time edit box, depending on the maximum
|
|
* value for the date/time.
|
|
*/
|
|
void AlarmTimeWidget::setMaxDelayTime(const TQDateTime& now)
|
|
{
|
|
int maxVal = maxDelayTime;
|
|
if (mMaxDateTime.isValid())
|
|
{
|
|
if (now.date().daysTo(mMaxDateTime.date()) < 100) // avoid possible 32-bit overflow on secsTo()
|
|
{
|
|
TQDateTime dt(now.date(), TQTime(now.time().hour(), now.time().minute(), 0)); // round down to nearest minute
|
|
maxVal = dt.secsTo(mMaxDateTime) / 60;
|
|
if (maxVal > maxDelayTime)
|
|
maxVal = maxDelayTime;
|
|
}
|
|
}
|
|
mDelayTimeEdit->setMaxValue(maxVal);
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Set the status for whether a time is specified, or just a date.
|
|
*/
|
|
void AlarmTimeWidget::setAnyTime()
|
|
{
|
|
int old = mAnyTime;
|
|
mAnyTime = (mAtTimeRadio->isOn() && mAnyTimeAllowed && mAnyTimeCheckBox && mAnyTimeCheckBox->isChecked()) ? 1 : 0;
|
|
if (mAnyTime != old)
|
|
emit anyTimeToggled(mAnyTime);
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Enable/disable the "any time" checkbox.
|
|
*/
|
|
void AlarmTimeWidget::enableAnyTime(bool enable)
|
|
{
|
|
if (mAnyTimeCheckBox)
|
|
{
|
|
mAnyTimeAllowed = enable;
|
|
bool at = mAtTimeRadio->isOn();
|
|
mAnyTimeCheckBox->setEnabled(enable && at);
|
|
if (at)
|
|
mTimeEdit->setEnabled(!enable || !mAnyTimeCheckBox->isChecked());
|
|
setAnyTime();
|
|
}
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Called every minute to update the alarm time data entry fields.
|
|
* If the maximum date/time has been reached, a 'pastMax()' signal is emitted.
|
|
*/
|
|
void AlarmTimeWidget::slotTimer()
|
|
{
|
|
TQDateTime now;
|
|
if (mMinDateTimeIsNow)
|
|
{
|
|
// Make sure that the minimum date is updated when the day changes
|
|
now = TQDateTime::currentDateTime();
|
|
mDateEdit->setMinDate(now.date());
|
|
}
|
|
if (mMaxDateTime.isValid())
|
|
{
|
|
if (!now.isValid())
|
|
now = TQDateTime::currentDateTime();
|
|
if (!mPastMax)
|
|
{
|
|
// Check whether the maximum date/time has now been reached
|
|
if (now.date() >= mMaxDateTime.date())
|
|
{
|
|
// The current date has reached or has passed the maximum date
|
|
if (now.date() > mMaxDateTime.date()
|
|
|| (!mAnyTime && now.time() > mTimeEdit->maxTime()))
|
|
{
|
|
mPastMax = true;
|
|
emit pastMax();
|
|
}
|
|
else if (mMinDateTimeIsNow && !mMinMaxTimeSet)
|
|
{
|
|
// The minimum date/time tracks the clock, so set the minimum
|
|
// and maximum times
|
|
setMaxMinTimeIf(now);
|
|
}
|
|
}
|
|
}
|
|
setMaxDelayTime(now);
|
|
}
|
|
|
|
if (mAtTimeRadio->isOn())
|
|
dateTimeChanged();
|
|
else
|
|
delayTimeChanged(mDelayTimeEdit->value());
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
* Called when the At or After time radio button states have been set.
|
|
* Updates the appropriate edit box.
|
|
*/
|
|
void AlarmTimeWidget::slotButtonSet(int)
|
|
{
|
|
bool at = mAtTimeRadio->isOn();
|
|
mDateEdit->setEnabled(at);
|
|
mTimeEdit->setEnabled(at && (!mAnyTimeAllowed || !mAnyTimeCheckBox || !mAnyTimeCheckBox->isChecked()));
|
|
if (mAnyTimeCheckBox)
|
|
mAnyTimeCheckBox->setEnabled(at && mAnyTimeAllowed);
|
|
// Ensure that the value of the delay edit box is > 0.
|
|
TQDateTime dt(mDateEdit->date(), mTimeEdit->time());
|
|
int minutes = (TQDateTime::currentDateTime().secsTo(dt) + 59) / 60;
|
|
if (minutes <= 0)
|
|
mDelayTimeEdit->setValid(true);
|
|
mDelayTimeEdit->setEnabled(!at);
|
|
setAnyTime();
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Called after the mAnyTimeCheckBox checkbox has been toggled.
|
|
*/
|
|
void AlarmTimeWidget::slotAnyTimeToggled(bool on)
|
|
{
|
|
mTimeEdit->setEnabled((!mAnyTimeAllowed || !on) && mAtTimeRadio->isOn());
|
|
setAnyTime();
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Called when the date or time edit box values have changed.
|
|
* Updates the time delay edit box accordingly.
|
|
*/
|
|
void AlarmTimeWidget::dateTimeChanged()
|
|
{
|
|
TQDateTime dt(mDateEdit->date(), mTimeEdit->time());
|
|
int minutes = (TQDateTime::currentDateTime().secsTo(dt) + 59) / 60;
|
|
bool blocked = mDelayTimeEdit->signalsBlocked();
|
|
mDelayTimeEdit->blockSignals(true); // prevent infinite recursion between here and delayTimeChanged()
|
|
if (minutes <= 0 || minutes > mDelayTimeEdit->maxValue())
|
|
mDelayTimeEdit->setValid(false);
|
|
else
|
|
mDelayTimeEdit->setValue(minutes);
|
|
mDelayTimeEdit->blockSignals(blocked);
|
|
}
|
|
|
|
/******************************************************************************
|
|
* Called when the delay time edit box value has changed.
|
|
* Updates the Date and Time edit boxes accordingly.
|
|
*/
|
|
void AlarmTimeWidget::delayTimeChanged(int minutes)
|
|
{
|
|
if (mDelayTimeEdit->isValid())
|
|
{
|
|
TQDateTime dt = TQDateTime::currentDateTime().addSecs(minutes * 60);
|
|
bool blockedT = mTimeEdit->signalsBlocked();
|
|
bool blockedD = mDateEdit->signalsBlocked();
|
|
mTimeEdit->blockSignals(true); // prevent infinite recursion between here and dateTimeChanged()
|
|
mDateEdit->blockSignals(true);
|
|
mTimeEdit->setValue(dt.time());
|
|
mDateEdit->setDate(dt.date());
|
|
mTimeEdit->blockSignals(blockedT);
|
|
mDateEdit->blockSignals(blockedD);
|
|
}
|
|
}
|