void IncidenceIO::setStartDateTime(const QDate startDateVal, const QTime startTimeVal, QString tzName)
{
qDebug()<<"Inside IncidenceIO::setStartDateTime, startDateVal="<<startDateVal.toString("dd MMM yyyy");
qDebug()<<"Inside IncidenceIO::setStartDateTime, startTimeVal="<<startTimeVal.toString("hh:mm");
if(tzName.isNull()||tzName.isEmpty()) {
//KDateTime::Spec tzSpec(KDateTime::LocalZone);
//this->setStartDateTime(KDateTime(startDateVal,startTimeVal,tzSpec));
KDateTime::Spec tzSpec(KSystemTimeZones::local());
this->setStartDateTime(KDateTime(startDateVal,startTimeVal,tzSpec));
} else {
//KDateTime::Spec tzSpec(KDateTime::LocalZone,gmtOffset);
//this->setStartDateTime(KDateTime(startDateVal,startTimeVal,tzSpec));
KDateTime::Spec tzSpec(KSystemTimeZones::zone(tzName));
this->setStartDateTime(KDateTime(startDateVal,startTimeVal,tzSpec));
}
qDebug()<<"*****************Inside overloaded setStartDateTime startDateTime="<<startDateTime.toString()<<"\n";
}
void KolabObjectTest::dontCrashWithEmptyOrganizer()
{
KCalCore::Event::Ptr event(new KCalCore::Event());
event->setOrganizer(KCalCore::Person::Ptr());
event->setDtStart(KDateTime(QDate(2012,11,11)));
Kolab::KolabObjectWriter::writeEvent(event, Kolab::KolabV2);
QCOMPARE(Kolab::ErrorHandler::instance().error(), Kolab::ErrorHandler::Debug);
Kolab::KolabObjectWriter::writeEvent(event);
qDebug() << Kolab::ErrorHandler::instance().error();
QCOMPARE(Kolab::ErrorHandler::instance().error(), Kolab::ErrorHandler::Debug);
}
void CheckableEditableDate::checkStatusChanged(bool status)
{
if (status) {
enable(true);
edit();
} else {
display();
enable(false);
emit dateChanged(KDateTime());
}
}
void NemoCalendarApi::remove(const QString &uid, const QDateTime &time)
{
mKCal::ExtendedCalendar::Ptr calendar = NemoCalendarDb::calendar();
KCalCore::Event::Ptr event = calendar->event(uid);
if (!event)
return;
if (event->recurs())
event->recurrence()->addExDateTime(KDateTime(time, KDateTime::Spec(KDateTime::LocalZone)));
else
calendar->deleteEvent(event);
// TODO: this sucks
NemoCalendarDb::storage()->save();
}
void ComingUpViewItemModel::updateEvents()
{
modelEventList->clear();
theData.clear();
QList<CalendarEvent*>& eventList = viewManager.GetEvents();
//int eventsLimitedTo = 3, comingUpEventCnt=0;
int cntr = eventList.count();
QDate today = QDate::currentDate();
KDateTime daysLaterDate = KDateTime(today.addDays(7));
for ( int i=0;i<cntr;i++ ) {
CalendarEvent* event = eventList.at(i);
bool addEvent = false;
//Bug#7244 Author: [email protected]
//Fixed the issue with display of "coming up" "Later" event list
if ( restrictEventCount == true ) {
if ( today == event->StartDate().date() )
{
addEvent = true;
}
} else {
if(event->StartDate().date() > daysLaterDate.date()) {
break;
} else if ( event->StartDate().date() > today )
{
addEvent = true;
}
}
if ( addEvent ) {
modelEventList->append(event);
QString dateString;
//Bug#7320 Author: [email protected]
//This piece of code fixes the issue with display of event
//If today: Display time followed by event
//Else Display Date-time followed by event
if(today == event->StartDate().date()) {
dateString = event->StartDate().toString ( "hh:mm AP" );
} else {
dateString = event->StartDate().toString ( "ddd dd hh:mm AP" );
}
QString alarmsString("alarmOFF");
if ( event->Alarm() ) {
alarmsString = "alarmON";
}
theData.append( QStringList() << dateString << event->Description() << alarmsString );
}
}
}
void KStars::readConfig() {
//Load config file values into Options object
Options::self()->readConfig();
applyConfig();
//Reset date, if one was stored
if ( data()->StoredDate.isValid() ) {
data()->changeDateTime( data()->geo()->LTtoUT( data()->StoredDate ) );
data()->StoredDate = KDateTime(); //invalidate StoredDate
}
map()->forceUpdate();
}
KDateTime KFileItemPrivate::time( KFileItem::FileTimes mappedWhich ) const
{
if ( !m_time[mappedWhich].isNull() )
return m_time[mappedWhich];
// Extract it from the KIO::UDSEntry
long long fieldVal = -1;
switch ( mappedWhich ) {
case KFileItem::ModificationTime:
fieldVal = m_entry.numberValue( KIO::UDSEntry::UDS_MODIFICATION_TIME, -1 );
break;
case KFileItem::AccessTime:
fieldVal = m_entry.numberValue( KIO::UDSEntry::UDS_ACCESS_TIME, -1 );
break;
case KFileItem::CreationTime:
fieldVal = m_entry.numberValue( KIO::UDSEntry::UDS_CREATION_TIME, -1 );
break;
}
if ( fieldVal != -1 ) {
setTime(mappedWhich, fieldVal);
return m_time[mappedWhich];
}
// If not in the KIO::UDSEntry, or if UDSEntry empty, use stat() [if local URL]
if ( m_bIsLocalUrl )
{
KDE_struct_stat buf;
if ( KDE::stat( m_url.toLocalFile(KUrl::RemoveTrailingSlash), &buf ) == 0 )
{
setTime(KFileItem::ModificationTime, buf.st_mtime);
setTime(KFileItem::AccessTime, buf.st_atime);
m_time[KFileItem::CreationTime] = KDateTime();
return m_time[mappedWhich];
}
}
return KDateTime();
}
void NemoCalendarEventQuery::refresh()
{
if (!mIsComplete)
return;
mKCal::ExtendedCalendar::Ptr calendar = NemoCalendarDb::calendar();
KCalCore::Event::Ptr event = mUid.isEmpty()?KCalCore::Event::Ptr():calendar->event(mUid);
if (event) {
if (mOccurrence) {
delete mOccurrence;
mOccurrence = 0;
}
mKCal::ExtendedCalendar::ExpandedIncidenceValidity eiv = {
event->dtStart().toLocalZone().dateTime(),
event->dtEnd().toLocalZone().dateTime()
};
if (!mStartTime.isNull() && event->recurs()) {
KDateTime startTime = KDateTime(mStartTime, KDateTime::Spec(KDateTime::LocalZone));
KCalCore::Recurrence *recurrence = event->recurrence();
if (recurrence->recursAt(startTime)) {
eiv.dtStart = startTime.toLocalZone().dateTime();
eiv.dtEnd = KCalCore::Duration(event->dtStart(), event->dtEnd()).end(startTime).toLocalZone().dateTime();
} else {
KDateTime match = recurrence->getNextDateTime(startTime);
if (match.isNull())
match = recurrence->getPreviousDateTime(startTime);
if (!match.isNull()) {
eiv.dtStart = match.toLocalZone().dateTime();
eiv.dtEnd = KCalCore::Duration(event->dtStart(), event->dtEnd()).end(match).toLocalZone().dateTime();
}
}
}
mOccurrence = new NemoCalendarEventOccurrence(qMakePair(eiv, event.dynamicCast<KCalCore::Incidence>()),
this);
emit occurrenceChanged();
emit eventChanged();
} else {
if (mOccurrence) {
delete mOccurrence;
mOccurrence = 0;
emit occurrenceChanged();
emit eventChanged();
}
}
}
void tst_storage::tst_alldayRecurrence()
{
auto event = KCalCore::Event::Ptr(new KCalCore::Event);
QDate startDate(2013, 12, 1);
event->setDtStart(KDateTime(startDate, QTime(), KDateTime::ClockTime));
event->setAllDay(true);
KCalCore::Recurrence *recurrence = event->recurrence();
recurrence->setWeekly(1);
recurrence->setStartDateTime(event->dtStart());
m_calendar->addEvent(event, NotebookId);
m_storage->save();
QString uid = event->uid();
reloadDb();
auto fetchEvent = m_calendar->event(uid);
QVERIFY(fetchEvent);
KCalCore::Recurrence *fetchRecurrence = fetchEvent->recurrence();
QVERIFY(fetchRecurrence);
KDateTime match = recurrence->getNextDateTime(KDateTime(startDate));
QCOMPARE(match, KDateTime(startDate.addDays(7), QTime(), KDateTime::ClockTime));
}
/******************************************************************************
* Called when the date or time edit box values have changed.
* Updates the time delay edit box accordingly.
*/
void AlarmTimeWidget::dateTimeChanged()
{
KDateTime dt(mDateEdit->date(), mTimeEdit->time(), mTimeSpec);
int minutes = (KDateTime::currentUtcDateTime().secsTo(dt) + 59) / 60;
bool blocked = mDelayTimeEdit->signalsBlocked();
mDelayTimeEdit->blockSignals(true); // prevent infinite recursion between here and delayTimeChanged()
if (minutes <= 0 || minutes > mDelayTimeEdit->maximum())
mDelayTimeEdit->setValid(false);
else
mDelayTimeEdit->setValue(minutes);
mDelayTimeEdit->blockSignals(blocked);
if (mAnyTimeAllowed && mAnyTimeCheckBox && mAnyTimeCheckBox->isChecked())
emit changed(KDateTime(dt.date(), mTimeSpec));
else
emit changed(dt);
}
/******************************************************************************
* 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())
{
QDateTime dt = KDateTime::currentUtcDateTime().addSecs(minutes * 60).toTimeSpec(mTimeSpec).dateTime();
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);
emit changed(KDateTime(dt.date(), dt.time(), mTimeSpec));
}
}
DateTime DateTime::fromString( const QString dts, const KDateTime::Spec &spec )
{
if (dts.isEmpty()) {
return DateTime();
}
KDateTime dt = KDateTime::fromString(dts);
if ( ! dt.isValid() ) {
// try to parse in qt default format (used in early version)
dt = KDateTime( QDateTime::fromString(dts), spec ).toLocalZone();
return dt.dateTime();
}
if ( dt.isClockTime() ) {
// timezone offset missing, set to spec
return DateTime( dt.toLocalZone().dateTime() );
}
DateTime t = DateTime( dt.toTimeSpec( spec ).toLocalZone().dateTime() );
return t;
}
void TimeListModel::loadCurrentDayModel()
{
beginResetModel();
clearData();
CalendarController controller;
QList<IncidenceIO> list = controller.getEventsFromDB(EDayList,KDateTime(dateVal));
int eventsCount=0;
for(int i=0;i<list.count();i++) {
IncidenceIO ioObject = list.at(i);
if(!ioObject.isAllDay()) {
eventsList << new CalendarDataItem(eventsCount,ioObject);
eventsCount++;
}
}
assignDisplayValues();
loadValues();
endResetModel();
return;
}
StyleGetter::StyleGetter( const int blogid, QObject *parent ): QObject( parent )
{
kDebug();
BilboBlog tempBlog = DBMan::self()->blog( blogid );
if ( tempBlog.isError() ) {
KMessageBox::detailedError( mParent, i18n( "Cannot fetch the selected blog style."),
DBMan::self()->lastErrorText() );
return;
}
// sets cachePath to ~/.kde4/share/apps/bilbo/blog_host_name/
// QString blogDir = DBMan::self()->getBlogInfo( blogid ).url().host();
// QString blogDir = tempBlog.url().host();
// kDebug() << blogDir;
// mCachePath = KStandardDirs::locateLocal( "data", "bilbo/" + blogDir + '/' , true );
QString url = QString( "blogilo/%1/" ).arg( blogid );
mCachePath = KStandardDirs::locateLocal( "data", url , true );
generateRandomPostStrings();
mParent = qobject_cast< QWidget* >( parent );
Q_ASSERT( mParent );
// create temp post
mTempPost = new BilboPost();
mTempPost->setTitle( mPostTitle );
mTempPost->setContent( mPostContent );
mTempPost->setPrivate( false );
if ( ( tempBlog.api() == BilboBlog::MOVABLETYPE_API ) ||
( tempBlog.api() == BilboBlog::WORDPRESSBUGGY_API ) ) {
mTempPost->setCreationDateTime( KDateTime( QDate(2000, 1, 1), QTime(0, 0), KDateTime::UTC ) );
}
b = new Backend( blogid );
connect( b, SIGNAL( sigPostPublished( int, BilboPost* ) ), this,
SLOT( sltTempPostPublished( int, BilboPost* ) ) );
connect( b, SIGNAL( sigError( const QString& ) ), this, SLOT( sltError( const QString& ) ) );
Q_EMIT sigGetStyleProgress( 10 );
b->publishPost( *mTempPost );
}
void DayViewModel::loadCurrentDayValues()
{
CalendarController controller;
QList<IncidenceIO> list = controller.getEventsFromDB(EDayList,KDateTime(dateVal));
beginResetModel();
clearData();
int eventsCount=0;
if(modelType == UtilMethods::EAllEvents ) {
for(int i=0;i<list.count();i++) {
IncidenceIO ioObject = list.at(i);
if(ioObject.isAllDay()) {
itemsList << new CalendarDataItem(eventsCount,ioObject);
eventsCount++;
}
}
for(int i=0;i<list.count();i++) {
IncidenceIO ioObject = list.at(i);
if(!ioObject.isAllDay()) {
itemsList << new CalendarDataItem(eventsCount,ioObject);
eventsCount++;
}
}
} else {
for(int i=0;i<list.count();i++) {
IncidenceIO ioObject = list.at(i);
if((modelType == UtilMethods::EAllDay) && (ioObject.isAllDay())) {
itemsList << new CalendarDataItem(i,ioObject);
ioObject.printIncidence();
} else if((modelType == UtilMethods::ENotAllDay) && (!ioObject.isAllDay())) {
itemsList << new CalendarDataItem(i,ioObject);
ioObject.printIncidence();
}
}
assignDisplayValues();
}
endResetModel();
}
void DateTimeParserTest::testSimpleKeywords() {
QVERIFY( KDateTime::currentLocalDateTime() == parser.parse("now") );
QVERIFY( KDateTime( KDateTime::currentLocalDate() ) == parser.parse("today") );
QVERIFY( KDateTime( KDateTime::currentLocalDate().addDays( 1 ) ) == parser.parse("tomorrow") );
QVERIFY( KDateTime( KDateTime::currentLocalDate().addDays( -1 ) ) == parser.parse("yesterday") );
}
void CalendarTester::testTimezone()
{
Calendar t("Test");
QDate wdate(2006,1,2);
DateTime before = DateTime(wdate.addDays(-1), QTime());
DateTime after = DateTime(wdate.addDays(1), QTime());
QTime t1(8,0,0);
QTime t2(10,0,0);
DateTime wdt1(wdate, t1);
DateTime wdt2(wdate, t2);
int length = t1.msecsTo( t2 );
CalendarDay *day = new CalendarDay(wdate, CalendarDay::Working);
day->addInterval(TimeInterval(t1, length));
t.addDay(day);
Debug::print( &t, "Time zone testing" );
QVERIFY(t.findDay(wdate) == day);
// local zone: Europe/Berlin ( 1 hours from London )
KTimeZone lo = KSystemTimeZones::zone("Europe/London");
QVERIFY( lo.isValid() );
KDateTime dt1 = KDateTime( wdate, t1, lo ).addSecs( -2 * 3600 );
KDateTime dt2 = KDateTime( wdate, t2, lo ).addSecs( 0 * 3600 );
qDebug()<<KDateTime( wdt1 )<<KDateTime( wdt2 );
qDebug()<<dt1<<dt2<<"("<<dt1.toLocalZone()<<dt2.toLocalZone()<<")";
QCOMPARE(t.firstAvailableAfter( DateTime( dt1 ), after ), wdt1 );
QCOMPARE(t.firstAvailableBefore( DateTime( dt2 ), before ), wdt2 );
Duration e(0, 2, 0);
QCOMPARE( t.effort( DateTime( dt1 ), DateTime( dt2 ) ).toString(), e.toString() );
// local zone: Europe/Berlin ( 9 hours from America/Los_Angeles )
KTimeZone la = KSystemTimeZones::zone("America/Los_Angeles");
QVERIFY( la.isValid() );
KDateTime dt3 = KDateTime( wdate, t1, la ).addSecs( -10 * 3600 );
KDateTime dt4 = KDateTime( wdate, t2, la ).addSecs( -8 * 3600 );
qDebug()<<KDateTime( wdt1 )<<KDateTime( wdt2 );
qDebug()<<dt3<<dt4<<"("<<dt3.toLocalZone()<<dt4.toLocalZone()<<")";
QCOMPARE(t.firstAvailableAfter( DateTime( dt3 ), after ), wdt1 );
QCOMPARE(t.firstAvailableBefore( DateTime( dt4 ), before ), wdt2 );
QCOMPARE( t.effort( DateTime( dt3 ), DateTime( dt4 ) ).toString(), e.toString() );
QString s = "Test Cairo:";
qDebug()<<s;
// local zone: Europe/Berlin ( 1 hour from cairo )
KTimeZone ca = KSystemTimeZones::zone("Africa/Cairo");
KDateTime dt5 = KDateTime( wdate, t1, ca ).addSecs( 0 * 3600 );
KDateTime dt6 = KDateTime( wdate, t2, ca ).addSecs( 2 * 3600 );
qDebug()<<KDateTime( wdt1 )<<KDateTime( wdt2 );
qDebug()<<dt5<<dt6<<"("<<dt5.toLocalZone()<<dt6.toLocalZone()<<")";
QCOMPARE(t.firstAvailableAfter( DateTime( dt5 ), after ), wdt1 );
QCOMPARE(t.firstAvailableBefore( DateTime( dt6 ), before ), wdt2 );
QCOMPARE( t.effort( DateTime( dt5 ), DateTime( dt6 ) ).toString(), e.toString() );
}
void EditableDate::display()
{
m_label->setText(DateStringBuilder::getFullDate(KDateTime(m_dateTimeWidget->date())));
AbstractEditableWidget::display();
}
KDateTime EditableDate::dateTime()
{
return KDateTime( m_dateTimeWidget->date());
}
void DateTimeParserTest::testRelativeKeywords() {
QVERIFY( KDateTime( KDateTime::currentLocalDate().addDays( 5 ) ) == parser.parse("in 5 days") );
QVERIFY( KDateTime( KDateTime::currentLocalDate().addMonths( 2 ) ) == parser.parse("in 2 months") );
QVERIFY( KDateTime( KDateTime::currentLocalDate().addYears( 3 ) ) == parser.parse("in 3 years") );
QVERIFY( KDateTime( KDateTime::currentLocalDate().addDays( -1 ).addYears( 3 ) ) == parser.parse("in 3 years after yesterday") );
}
void SummaryEventTester::test_Multiday()
{
QDate today = QDate::currentDate();
QString multidayWithTimeInProgress = "Multiday, time specified, in progress";
KCal::CalendarLocal *cal = new KCal::CalendarLocal( KDateTime().timeSpec() );
KCal::Event *event = new KCal::Event();
event->setDtStart( KDateTime( today.addDays( -1 ) ) );
event->setDtEnd( KDateTime( today.addDays( 5 ) ) );
event->setSummary( "Multiday, allday, in progress (day 2/6)" );
QVERIFY( cal->addEvent( event ) );
event = new KCal::Event();
event->setDtStart( KDateTime( today.addDays( -1 ), QTime::fromString("12:00","hh:mm") ) );
event->setDtEnd( KDateTime( today.addDays( 5 ), QTime::fromString("12:00","hh:mm") ) );
event->setSummary( multidayWithTimeInProgress );
QVERIFY( cal->addEvent( event ) );
for ( int i = 0; i < 5; i++ ) {
SummaryEventInfo::List events4 = SummaryEventInfo::eventsForDate( today.addDays( i ), cal );
QCOMPARE( 1, events4.size() );
SummaryEventInfo *ev4 = events4.at(0);
QCOMPARE( ev4->summaryText, QString(multidayWithTimeInProgress + " (%1/7)").arg(i+2));
QCOMPARE( ev4->timeRange, QString("00:00 - 23:59") );
// QCOMPARE( ev4->startDate, KGlobal::locale()->formatDate( QDate( today.addDays( i ) ), KLocale::FancyLongDate ) );
QCOMPARE( ev4->makeBold, i == 0 );
qDeleteAll( events4 );
}
// Test date a multiday event in the future has to correct DaysTo set
QString multiDayWithTimeFuture = "Multiday, with time, in the future";
event = new KCal::Event();
event->setDtStart( KDateTime( today.addDays( 100 ), QTime::fromString("12:00","hh:mm") ) );
event->setDtEnd( KDateTime( today.addDays( 106 ), QTime::fromString("12:00","hh:mm") ) );
event->setSummary( multiDayWithTimeFuture );
QVERIFY( cal->addEvent( event ) );
for ( int i = 100; i <= 106; i++ ) {
SummaryEventInfo::List events5 = SummaryEventInfo::eventsForDate( today.addDays( i ), cal );
QCOMPARE( 1, events5.size() );
SummaryEventInfo *ev5 = events5.at(0);
/*qDebug() << ev5->summaryText;
qDebug() << ev5->daysToGo;
qDebug() << i;*/
QCOMPARE( ev5->summaryText, QString(multiDayWithTimeFuture + " (%1/7)").arg(i-100+1));
QCOMPARE( ev5->daysToGo, QString("in %1 days").arg(i) );
qDeleteAll( events5 );
}
QString multiDayAllDayInFuture = "Multiday, allday, in future";
int multiDayFuture = 30;
event = new KCal::Event();
event->setDtStart( KDateTime( today.addDays( multiDayFuture ) ) );
event->setDtEnd( KDateTime( today.addDays( multiDayFuture + 5 ) ) );
event->setSummary( multiDayAllDayInFuture );
QVERIFY( cal->addEvent( event ) );
event = new KCal::Event();
event->setDtStart( KDateTime( today.addDays( 2 ), QTime::fromString("12:00","hh:mm") ) );
event->setDtEnd( KDateTime( today.addDays( 5 ), QTime::fromString("12:00","hh:mm") ) );
event->setSummary( "Multiday, time specified, in future" );
QVERIFY( cal->addEvent( event ) );
QString multiDayAllDayStartingToday = "Multiday, allday, starting today";
event = new KCal::Event();
event->setDtStart( KDateTime( today ) );
event->setDtEnd( KDateTime( today.addDays( 5 ) ) );
event->setSummary( multiDayAllDayStartingToday );
QVERIFY( cal->addEvent( event ) );
event = new KCal::Event();
event->setDtStart( KDateTime( today.addDays(-10), QTime::fromString("12:00","hh:mm") ) );
event->setDtEnd( KDateTime( today.addDays( -5 ), QTime::fromString("10:00","hh:mm") ) );
event->setSummary( "Some event in the past" );
QVERIFY( cal->addEvent( event ) );
SummaryEventInfo::List eventsToday = SummaryEventInfo::eventsForDate( today, cal );
QCOMPARE( 2, eventsToday.size() );
foreach( const SummaryEventInfo *ev, eventsToday ) {
if ( ev->summaryText == multidayWithTimeInProgress + " (2/7)" ) {
QCOMPARE( ev->timeRange, QString("00:00 - 23:59") );
QCOMPARE( ev->startDate, QString("Today") );
QCOMPARE( ev->daysToGo, QString("now") );
QCOMPARE( ev->makeBold, true );
}
else if ( ev->summaryText == multiDayAllDayStartingToday ) {
QVERIFY( ev->timeRange.isEmpty() );
QCOMPARE( ev->startDate, QString("Today") );
QCOMPARE( ev->daysToGo, QString("all day") );
QCOMPARE( ev->makeBold, true );
}
else
Q_ASSERT( false ); // unexpected event!
}
SummaryEventInfo::List events2 = SummaryEventInfo::eventsForDate( today.addDays( multiDayFuture ), cal );
QCOMPARE( 1, events2.size() );
SummaryEventInfo *ev1 = events2.at( 0 );
QCOMPARE( ev1->summaryText, multiDayAllDayInFuture );
QVERIFY( ev1->timeRange.isEmpty() );
QCOMPARE( ev1->startDate, KGlobal::locale()->formatDate( QDate( today.addDays( multiDayFuture ) ) ) );
QCOMPARE( ev1->daysToGo, QString("in %1 days").arg(multiDayFuture) );
QCOMPARE( ev1->makeBold, false );
// Make sure multiday is only displayed once
for ( int i = 1; i < 30; i++ ) {
SummaryEventInfo::List events3 = SummaryEventInfo::eventsForDate( today.addDays( multiDayFuture + i ), cal );
foreach(SummaryEventInfo *ev, events3 ) {
QVERIFY( ev->summaryText.contains( multiDayAllDayInFuture ) );
}
qDeleteAll( events3 );
}
void DateTimeParserTest::testPreciseSpecs() {
QVERIFY( KDateTime( QDate::fromString( "21.10.2009", "d.M.yyyy" ) ) == parser.parse("21.10.2009") );
}
KDateTime VirtualItem::date(PimItem::DateRole) const
{
return KDateTime();
}
DateTime::DateTime( const QDateTime &dt, const KDateTime::Spec &spec )
: QDateTime( KDateTime( dt, spec ).toLocalZone().dateTime() )
{
}
/******************************************************************************
* 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.
*/
KDateTime AlarmTimeWidget::getDateTime(int* minsFromNow, bool checkExpired, bool showErrorMessage, QWidget** errorWidget) const
{
if (minsFromNow)
*minsFromNow = 0;
if (errorWidget)
*errorWidget = 0;
KDateTime now = KDateTime::currentUtcDateTime();
now.setTime(QTime(now.time().hour(), now.time().minute(), 0));
if (!mAtTimeRadio->isChecked())
{
if (!mDelayTimeEdit->isValid())
{
if (showErrorMessage)
KMessageBox::sorry(const_cast<AlarmTimeWidget*>(this), i18nc("@info", "Invalid time"));
if (errorWidget)
*errorWidget = mDelayTimeEdit;
return KDateTime();
}
int delayMins = mDelayTimeEdit->value();
if (minsFromNow)
*minsFromNow = delayMins;
return now.addSecs(delayMins * 60).toTimeSpec(mTimeSpec);
}
else
{
bool dateOnly = 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), i18nc("@info", "Invalid date"));
if (errorWidget)
*errorWidget = mDateEdit;
}
else
{
if (showErrorMessage)
KMessageBox::sorry(const_cast<AlarmTimeWidget*>(this), i18nc("@info", "Invalid time"));
if (errorWidget)
*errorWidget = mTimeEdit;
}
return KDateTime();
}
KDateTime result;
if (dateOnly)
{
result = KDateTime(mDateEdit->date(), mTimeSpec);
if (checkExpired && result.date() < now.date())
{
if (showErrorMessage)
KMessageBox::sorry(const_cast<AlarmTimeWidget*>(this), i18nc("@info", "Alarm date has already expired"));
if (errorWidget)
*errorWidget = mDateEdit;
return KDateTime();
}
}
else
{
result = KDateTime(mDateEdit->date(), mTimeEdit->time(), mTimeSpec);
if (checkExpired && result <= now.addSecs(1))
{
if (showErrorMessage)
KMessageBox::sorry(const_cast<AlarmTimeWidget*>(this), i18nc("@info", "Alarm time has already expired"));
if (errorWidget)
*errorWidget = mTimeEdit;
return KDateTime();
}
}
return result;
}
}
