summaryrefslogtreecommitdiff
path: root/qmake/tools/qdatetime.cpp
authorkergoth <kergoth>2002-11-01 00:10:42 (UTC)
committer kergoth <kergoth>2002-11-01 00:10:42 (UTC)
commit5042e3cf0d3514552769e441f5aad590c8eaf967 (patch) (side-by-side diff)
tree4a5ea45f3519d981a172ab5275bf38c6fa778dec /qmake/tools/qdatetime.cpp
parent108c1c753e74e989cc13923086996791428c9af4 (diff)
downloadopie-5042e3cf0d3514552769e441f5aad590c8eaf967.zip
opie-5042e3cf0d3514552769e441f5aad590c8eaf967.tar.gz
opie-5042e3cf0d3514552769e441f5aad590c8eaf967.tar.bz2
Adding qmake in preperation for new build system
Diffstat (limited to 'qmake/tools/qdatetime.cpp') (more/less context) (ignore whitespace changes)
-rw-r--r--qmake/tools/qdatetime.cpp2490
1 files changed, 2490 insertions, 0 deletions
diff --git a/qmake/tools/qdatetime.cpp b/qmake/tools/qdatetime.cpp
new file mode 100644
index 0000000..93e40a8
--- a/dev/null
+++ b/qmake/tools/qdatetime.cpp
@@ -0,0 +1,2490 @@
+/****************************************************************************
+** $Id$
+**
+** Implementation of date and time classes
+**
+** Created : 940124
+**
+** Copyright (C) 1992-2000 Trolltech AS. All rights reserved.
+**
+** This file is part of the tools module of the Qt GUI Toolkit.
+**
+** This file may be distributed under the terms of the Q Public License
+** as defined by Trolltech AS of Norway and appearing in the file
+** LICENSE.QPL included in the packaging of this file.
+**
+** This file may be distributed and/or modified under the terms of the
+** GNU General Public License version 2 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.
+**
+** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
+** licenses may use this file in accordance with the Qt Commercial License
+** Agreement provided with the Software.
+**
+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+**
+** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
+** information about Qt Commercial License Agreements.
+** See http://www.trolltech.com/qpl/ for QPL licensing information.
+** See http://www.trolltech.com/gpl/ for GPL licensing information.
+**
+** Contact info@trolltech.com if any conditions of this licensing are
+** not clear to you.
+**
+**********************************************************************/
+
+// Get the system specific includes and defines
+#include "qplatformdefs.h"
+
+#include "qdatetime.h"
+#include "qdatastream.h"
+#include "qregexp.h"
+
+#include <stdio.h>
+#ifndef Q_OS_TEMP
+#include <time.h>
+#endif
+
+#if defined(Q_OS_WIN32)
+#include <windows.h>
+#endif
+
+static const uint FIRST_DAY = 2361222; // Julian day for 1752-09-14
+static const int FIRST_YEAR = 1752; // ### wrong for many countries
+static const uint SECS_PER_DAY = 86400;
+static const uint MSECS_PER_DAY = 86400000;
+static const uint SECS_PER_HOUR = 3600;
+static const uint MSECS_PER_HOUR= 3600000;
+static const uint SECS_PER_MIN = 60;
+static const uint MSECS_PER_MIN = 60000;
+
+static const short monthDays[] = {
+ 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
+
+static const char * const qt_shortMonthNames[] = {
+ "Jan", "Feb", "Mar", "Apr", "May", "Jun",
+ "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
+
+#ifndef QT_NO_DATESTRING
+/*****************************************************************************
+ Some static function used by QDate, QTime and QDateTime
+ *****************************************************************************/
+
+// Replaces tokens by their value. See QDateTime::toString() for a list of valid tokens
+static QString getFmtString( const QString& f, const QTime* dt = 0, const QDate* dd = 0, bool am_pm = FALSE )
+{
+ if ( f.isEmpty() )
+ return QString::null;
+
+ QString buf = f;
+
+ if ( dt ) {
+ if ( f == "h" ) {
+ if ( ( am_pm ) && ( dt->hour() > 12 ) )
+ buf = QString::number( dt->hour() - 12 );
+ else if ( ( am_pm ) && ( dt->hour() == 0 ) )
+ buf = "12";
+ else
+ buf = QString::number( dt->hour() );
+ } else if ( f == "hh" ) {
+ if ( ( am_pm ) && ( dt->hour() > 12 ) )
+ buf = QString::number( dt->hour() - 12 ).rightJustify( 2, '0', TRUE );
+ else if ( ( am_pm ) && ( dt->hour() == 0 ) )
+ buf = "12";
+ else
+ buf = QString::number( dt->hour() ).rightJustify( 2, '0', TRUE );
+ } else if ( f == "m" ) {
+ buf = QString::number( dt->minute() );
+ } else if ( f == "mm" ) {
+ buf = QString::number( dt->minute() ).rightJustify( 2, '0', TRUE );
+ } else if ( f == "s" ) {
+ buf = QString::number( dt->second() );
+ } else if ( f == "ss" ) {
+ buf = QString::number( dt->second() ).rightJustify( 2, '0', TRUE );
+ } else if ( f == "z" ) {
+ buf = QString::number( dt->msec() );
+ } else if ( f == "zzz" ) {
+ buf = QString::number( dt->msec() ).rightJustify( 3, '0', TRUE );
+ } else if ( f == "ap" ) {
+ buf = dt->hour() < 12 ? "am" : "pm";
+ } else if ( f == "AP" ) {
+ buf = dt->hour() < 12 ? "AM" : "PM";
+ }
+ }
+
+ if ( dd ) {
+ if ( f == "d" ) {
+ buf = QString::number( dd->day() );
+ } else if ( f == "dd" ) {
+ buf = QString::number( dd->day() ).rightJustify( 2, '0', TRUE );
+ } else if ( f == "M" ) {
+ buf = QString::number( dd->month() );
+ } else if ( f == "MM" ) {
+ buf = QString::number( dd->month() ).rightJustify( 2, '0', TRUE );
+#ifndef QT_NO_TEXTDATE
+ } else if ( f == "ddd" ) {
+ buf = dd->shortDayName( dd->dayOfWeek() );
+ } else if ( f == "dddd" ) {
+ buf = dd->longDayName( dd->dayOfWeek() );
+ } else if ( f == "MMM" ) {
+ buf = dd->shortMonthName( dd->month() );
+ } else if ( f == "MMMM" ) {
+ buf = dd->longMonthName( dd->month() );
+#endif
+ } else if ( f == "yy" ) {
+ buf = QString::number( dd->year() ).right( 2 );
+ } else if ( f == "yyyy" ) {
+ buf = QString::number( dd->year() );
+ }
+ }
+
+ return buf;
+}
+
+// Parses the format string and uses getFmtString to get the values for the tokens. Ret
+static QString fmtDateTime( const QString& f, const QTime* dt = 0, const QDate* dd = 0 )
+{
+ if ( f.isEmpty() ) {
+ return QString::null;
+ }
+
+ bool ap = ( f.contains( "AP" ) || f.contains( "ap" ) );
+
+ QString buf;
+ QString frm;
+ QChar status = '0';
+
+ for ( int i = 0; i < (int)f.length(); ++i ) {
+
+ if ( f[ i ] == status ) {
+ if ( ( ap ) && ( ( f[ i ] == 'P' ) || ( f[ i ] == 'p' ) ) )
+ status = '0';
+ frm += f[ i ];
+ } else {
+ buf += getFmtString( frm, dt, dd, ap );
+ frm = QString::null;
+ if ( ( f[ i ] == 'h' ) || ( f[ i ] == 'm' ) || ( f[ i ] == 's' ) || ( f[ i ] == 'z' ) ) {
+ status = f[ i ];
+ frm += f[ i ];
+ } else if ( ( f[ i ] == 'd' ) || ( f[ i ] == 'M' ) || ( f[ i ] == 'y' ) ) {
+ status = f[ i ];
+ frm += f[ i ];
+ } else if ( ( ap ) && ( f[ i ] == 'A' ) ) {
+ status = 'P';
+ frm += f[ i ];
+ } else if( ( ap ) && ( f[ i ] == 'a' ) ) {
+ status = 'p';
+ frm += f[ i ];
+ } else {
+ buf += f[ i ];
+ status = '0';
+ }
+ }
+ }
+
+ buf += getFmtString( frm, dt, dd, ap );
+
+ return buf;
+}
+#endif // QT_NO_DATESTRING
+
+/*****************************************************************************
+ QDate member functions
+ *****************************************************************************/
+
+/*!
+ \class QDate qdatetime.h
+ \reentrant
+ \brief The QDate class provides date functions.
+
+ \ingroup time
+ \mainclass
+
+ A QDate object contains a calendar date, i.e. year, month, and day
+ numbers, in the modern Western (Gregorian) calendar. It can read
+ the current date from the system clock. It provides functions for
+ comparing dates and for manipulating dates, e.g. by adding a
+ number of days or months or years.
+
+ A QDate object is typically created either by giving the year,
+ month and day numbers explicitly, or by using the static function
+ currentDate(), which creates a QDate object containing the system
+ clock's date. An explicit date can also be set using setYMD(). The
+ fromString() function returns a QDate given a string and a date
+ format which is used to interpret the date within the string.
+
+ The year(), month(), and day() functions provide access to the
+ year, month, and day numbers. Also, dayOfWeek() and dayOfYear()
+ functions are provided. The same information is provided in
+ textual format by the toString(), shortDayName(), longDayName(),
+ shortMonthName() and longMonthName() functions.
+
+ QDate provides a full set of operators to compare two QDate
+ objects where smaller means earlier and larger means later.
+
+ You can increment (or decrement) a date by a given number of days
+ using addDays(). Similarly you can use addMonths() and addYears().
+ The daysTo() function returns the number of days between two
+ dates.
+
+ The daysInMonth() and daysInYear() functions return how many days
+ there are in this date's month and year, respectively. The
+ leapYear() function indicates whether this date is in a leap year.
+
+ Note that QDate should not be used for date calculations for dates
+ prior to the introduction of the Gregorian calendar. This calendar
+ was adopted by England from the 14<sup><small>th</small></sup>
+ September 1752 (hence this is the earliest valid QDate), and
+ subsequently by most other Western countries, until 1923.
+
+ The end of time is reached around the year 8000, by which time we
+ expect Qt to be obsolete.
+
+ \sa QTime QDateTime QDateEdit QDateTimeEdit
+*/
+
+/*!
+ \enum Qt::DateFormat
+
+ \value TextDate (default) Qt format
+ \value ISODate ISO 8601 extended format (YYYY-MM-DD, or with time,
+ YYYY-MM-DDTHH:MM:SS)
+ \value LocalDate locale dependent format
+*/
+
+
+/*!
+ \enum Qt::TimeSpec
+
+ \value LocalTime Locale dependent time (Timezones and Daylight Savings Time)
+ \value UTC Coordinated Universal Time, replaces Greenwich Time
+*/
+
+/*!
+ \fn QDate::QDate()
+
+ Constructs a null date. Null dates are invalid.
+
+ \sa isNull(), isValid()
+*/
+
+
+/*!
+ Constructs a date with year \a y, month \a m and day \a d.
+
+ \a y must be in the range 1752..8000, \a m must be in the range
+ 1..12, and \a d must be in the range 1..31.
+
+ \warning If \a y is in the range 0..99, it is interpreted as
+ 1900..1999.
+
+ \sa isValid()
+*/
+
+QDate::QDate( int y, int m, int d )
+{
+ jd = 0;
+ setYMD( y, m, d );
+}
+
+
+/*!
+ \fn bool QDate::isNull() const
+
+ Returns TRUE if the date is null; otherwise returns FALSE. A null
+ date is invalid.
+
+ \sa isValid()
+*/
+
+
+/*!
+ Returns TRUE if this date is valid; otherwise returns FALSE.
+
+ \sa isNull()
+*/
+
+bool QDate::isValid() const
+{
+ return jd >= FIRST_DAY;
+}
+
+
+/*!
+ Returns the year (1752..8000) of this date.
+
+ \sa month(), day()
+*/
+
+int QDate::year() const
+{
+ int y, m, d;
+ julianToGregorian( jd, y, m, d );
+ return y;
+}
+
+/*!
+ Returns the month (January=1..December=12) of this date.
+
+ \sa year(), day()
+*/
+
+int QDate::month() const
+{
+ int y, m, d;
+ julianToGregorian( jd, y, m, d );
+ return m;
+}
+
+/*!
+ Returns the day of the month (1..31) of this date.
+
+ \sa year(), month(), dayOfWeek()
+*/
+
+int QDate::day() const
+{
+ int y, m, d;
+ julianToGregorian( jd, y, m, d );
+ return d;
+}
+
+/*!
+ Returns the weekday (Monday=1..Sunday=7) for this date.
+
+ \sa day(), dayOfYear()
+*/
+
+int QDate::dayOfWeek() const
+{
+ return ( jd % 7 ) + 1;
+}
+
+/*!
+ Returns the day of the year (1..365) for this date.
+
+ \sa day(), dayOfWeek()
+*/
+
+int QDate::dayOfYear() const
+{
+ return jd - gregorianToJulian(year(), 1, 1) + 1;
+}
+
+/*!
+ Returns the number of days in the month (28..31) for this date.
+
+ \sa day(), daysInYear()
+*/
+
+int QDate::daysInMonth() const
+{
+ int y, m, d;
+ julianToGregorian( jd, y, m, d );
+ if ( m == 2 && leapYear(y) )
+ return 29;
+ else
+ return monthDays[m];
+}
+
+/*!
+ Returns the number of days in the year (365 or 366) for this date.
+
+ \sa day(), daysInMonth()
+*/
+
+int QDate::daysInYear() const
+{
+ int y, m, d;
+ julianToGregorian( jd, y, m, d );
+ return leapYear( y ) ? 366 : 365;
+}
+
+/*!
+ Returns the week number (1 to 53), and stores the year in \a
+ *yearNumber unless \a yearNumber is null (the default).
+
+ Returns 0 if the date is invalid.
+
+ In accordance with ISO 8601, weeks start on Monday and the first
+ Thursday of a year is always in week 1 of that year. Most years
+ have 52 weeks, but some have 53.
+
+ \a *yearNumber is not always the same as year(). For example, 1
+ January 2000 has week number 52 in the year 1999, and 31 December
+ 2002 has week number 1 in the year 2003.
+
+ \sa isValid()
+*/
+
+int QDate::weekNumber( int *yearNumber ) const
+{
+ if ( !isValid() )
+ return 0;
+
+ int dow = dayOfWeek();
+ int doy = dayOfYear();
+ int currYear = year();
+ int jan1WeekDay = QDate( currYear, 1, 1 ).dayOfWeek();
+ int yearNum;
+ int weekNum;
+
+ if ( doy <= (8 - jan1WeekDay) && jan1WeekDay > 4 ) {
+ yearNum = currYear - 1;
+ weekNum = 52;
+ if ( jan1WeekDay == 5 ||
+ (jan1WeekDay == 6 && QDate::leapYear(yearNum)) )
+ weekNum++;
+ } else {
+ int totalDays = 365;
+ if ( QDate::leapYear(currYear) )
+ totalDays++;
+
+ if ( (totalDays - doy < 4 - dow)
+ || (jan1WeekDay == 7 && totalDays - doy < 3) ) {
+ yearNum = currYear + 1;
+ weekNum = 1;
+ } else {
+ int j = doy + ( 7 - dow ) + ( jan1WeekDay - 1 );
+ yearNum = currYear;
+ weekNum = j / 7;
+ if ( jan1WeekDay > 4 )
+ weekNum--;
+ }
+ }
+ if ( yearNumber )
+ *yearNumber = yearNum;
+ return weekNum;
+}
+
+/*!
+ \fn QString QDate::monthName( int month )
+ \obsolete
+
+ Use shortMonthName() instead.
+*/
+#ifndef QT_NO_TEXTDATE
+/*!
+ Returns the name of the \a month.
+
+ 1 = "Jan", 2 = "Feb", ... 12 = "Dec"
+
+ The month names will be localized according to the system's locale
+ settings.
+
+ \sa toString(), longMonthName(), shortDayName(), longDayName()
+*/
+
+QString QDate::shortMonthName( int month )
+{
+#if defined(QT_CHECK_RANGE)
+ if ( month < 1 || month > 12 ) {
+ qWarning( "QDate::shortMonthName: Parameter out ouf range." );
+ month = 1;
+ }
+#endif
+#ifndef Q_WS_WIN
+ char buffer[255];
+ tm tt;
+ memset( &tt, 0, sizeof( tm ) );
+ tt.tm_mon = month - 1;
+ if ( strftime( buffer, sizeof( buffer ), "%b", &tt ) )
+ return QString::fromLocal8Bit( buffer );
+#else
+ SYSTEMTIME st;
+ memset( &st, 0, sizeof(SYSTEMTIME) );
+ st.wYear = 2000;
+ st.wMonth = month;
+ st.wDay = 1;
+ const wchar_t mmm_t[] = L"MMM"; // workaround for Borland
+ QT_WA( {
+ TCHAR buf[255];
+ if ( GetDateFormat( LOCALE_USER_DEFAULT, 0, &st, mmm_t, buf, 255 ) )
+ return QString::fromUcs2( (ushort*)buf );
+ } , {
+ char buf[255];
+ if ( GetDateFormatA( LOCALE_USER_DEFAULT, 0, &st, "MMM", (char*)&buf, 255 ) )
+ return QString::fromLocal8Bit( buf );
+ } );
+#endif
+ return QString::null;
+}
+
+/*!
+ Returns the long name of the \a month.
+
+ 1 = "January", 2 = "February", ... 12 = "December"
+
+ The month names will be localized according to the system's locale
+ settings.
+
+ \sa toString(), shortMonthName(), shortDayName(), longDayName()
+*/
+
+QString QDate::longMonthName( int month )
+{
+#if defined(QT_CHECK_RANGE)
+ if ( month < 1 || month > 12 ) {
+ qWarning( "QDate::longMonthName: Parameter out ouf range." );
+ month = 1;
+ }
+#endif
+#ifndef Q_WS_WIN
+ char buffer[255];
+ tm tt;
+ memset( &tt, 0, sizeof( tm ) );
+ tt.tm_mon = month - 1;
+ if ( strftime( buffer, sizeof( buffer ), "%B", &tt ) )
+ return QString::fromLocal8Bit( buffer );
+#else
+ SYSTEMTIME st;
+ memset( &st, 0, sizeof(SYSTEMTIME) );
+ st.wYear = 2000;
+ st.wMonth = month;
+ st.wDay = 1 ;
+ const wchar_t mmmm_t[] = L"MMMM"; // workaround for Borland
+ QT_WA( {
+ TCHAR buf[255];
+ if ( GetDateFormat( LOCALE_USER_DEFAULT, 0, &st, mmmm_t, buf, 255 ) )
+ return QString::fromUcs2( (ushort*)buf );
+ } , {
+ char buf[255];
+ if ( GetDateFormatA( LOCALE_USER_DEFAULT, 0, &st, "MMMM", (char*)&buf, 255 ) )
+ return QString::fromLocal8Bit( buf );
+ } )
+#endif
+
+ return QString::null;
+}
+
+/*!
+ \fn QString QDate::dayName( int weekday )
+ \obsolete
+
+ Use shortDayName() instead.
+*/
+
+/*!
+ Returns the name of the \a weekday.
+
+ 1 = "Mon", 2 = "Tue", ... 7 = "Sun"
+
+ The day names will be localized according to the system's locale
+ settings.
+
+ \sa toString(), shortMonthName(), longMonthName(), longDayName()
+*/
+
+QString QDate::shortDayName( int weekday )
+{
+#if defined(QT_CHECK_RANGE)
+ if ( weekday < 1 || weekday > 7 ) {
+ qWarning( "QDate::shortDayName: Parameter out of range." );
+ weekday = 1;
+ }
+#endif
+#ifndef Q_WS_WIN
+ char buffer[255];
+ tm tt;
+ memset( &tt, 0, sizeof( tm ) );
+ tt.tm_wday = ( weekday == 7 ) ? 0 : weekday;
+ if ( strftime( buffer, sizeof( buffer ), "%a", &tt ) )
+ return QString::fromLocal8Bit( buffer );
+#else
+ SYSTEMTIME st;
+ memset( &st, 0, sizeof(SYSTEMTIME) );
+ st.wYear = 2001;
+ st.wMonth = 10;
+ st.wDayOfWeek = ( weekday == 7 ) ? 0 : weekday;
+ st.wDay = 21 + st.wDayOfWeek;
+ const wchar_t ddd_t[] = L"ddd"; // workaround for Borland
+ QT_WA( {
+ TCHAR buf[255];
+ if ( GetDateFormat( LOCALE_USER_DEFAULT, 0, &st, ddd_t, buf, 255 ) )
+ return QString::fromUcs2( (ushort*)buf );
+ } , {
+ char buf[255];
+ if ( GetDateFormatA( LOCALE_USER_DEFAULT, 0, &st, "ddd", (char*)&buf, 255 ) )
+ return QString::fromLocal8Bit( buf );
+ } );
+#endif
+
+ return QString::null;
+}
+
+/*!
+ Returns the long name of the \a weekday.
+
+ 1 = "Monday", 2 = "Tuesday", ... 7 = "Sunday"
+
+ The day names will be localized according to the system's locale
+ settings.
+
+ \sa toString(), shortDayName(), shortMonthName(), longMonthName()
+*/
+
+QString QDate::longDayName( int weekday )
+{
+#if defined(QT_CHECK_RANGE)
+ if ( weekday < 1 || weekday > 7 ) {
+ qWarning( "QDate::longDayName: Parameter out of range." );
+ weekday = 1;
+ }
+#endif
+#ifndef Q_WS_WIN
+ char buffer[255];
+ tm tt;
+ memset( &tt, 0, sizeof( tm ) );
+ tt.tm_wday = ( weekday == 7 ) ? 0 : weekday;
+ if ( strftime( buffer, sizeof( buffer ), "%A", &tt ) )
+ return QString::fromLocal8Bit( buffer );
+#else
+ SYSTEMTIME st;
+ memset( &st, 0, sizeof(SYSTEMTIME) );
+ st.wYear = 2001;
+ st.wMonth = 10;
+ st.wDayOfWeek = ( weekday == 7 ) ? 0 : weekday;
+ st.wDay = 21 + st.wDayOfWeek;
+ const wchar_t dddd_t[] = L"dddd"; // workaround for Borland
+ QT_WA( {
+ TCHAR buf[255];
+ if ( GetDateFormat( LOCALE_USER_DEFAULT, 0, &st, dddd_t, buf, 255 ) )
+ return QString::fromUcs2( (ushort*)buf );
+ } , {
+ char buf[255];
+ if ( GetDateFormatA( LOCALE_USER_DEFAULT, 0, &st, "dddd", (char*)&buf, 255 ) )
+ return QString::fromLocal8Bit( buf );
+ } );
+#endif
+
+ return QString::null;
+}
+#endif //QT_NO_TEXTDATE
+
+#ifndef QT_NO_DATESTRING
+
+#if !defined(QT_NO_SPRINTF)
+/*!
+ \overload
+
+ Returns the date as a string. The \a f parameter determines the
+ format of the string.
+
+ If \a f is \c Qt::TextDate, the string format is "Sat May 20 1995"
+ (using the shortDayName() and shortMonthName() functions to
+ generate the string, so the day and month names are locale
+ specific).
+
+ If \a f is \c Qt::ISODate, the string format corresponds to the
+ ISO 8601 specification for representations of dates, which is
+ YYYY-MM-DD where YYYY is the year, MM is the month of the year
+ (between 01 and 12), and DD is the day of the month between 01 and
+ 31.
+
+ If \a f is \c Qt::LocalDate, the string format depends on the
+ locale settings of the system.
+
+ \sa shortDayName(), shortMonthName()
+*/
+QString QDate::toString( Qt::DateFormat f ) const
+{
+ int y, m, d;
+ julianToGregorian( jd, y, m, d );
+ switch ( f ) {
+ case Qt::LocalDate:
+ {
+#ifndef Q_WS_WIN
+ tm tt;
+ memset( &tt, 0, sizeof( tm ) );
+ char buf[255];
+ tt.tm_mday = day();
+ tt.tm_mon = month() - 1;
+ tt.tm_year = year() - 1900;
+
+ static const char * avoidEgcsWarning = "%x";
+ if ( strftime( buf, sizeof(buf), avoidEgcsWarning, &tt ) )
+ return QString::fromLocal8Bit( buf );
+#else
+ SYSTEMTIME st;
+ memset( &st, 0, sizeof(SYSTEMTIME) );
+ st.wYear = year();
+ st.wMonth = month();
+ st.wDay = day();
+ QT_WA( {
+ TCHAR buf[255];
+ if ( GetDateFormat( LOCALE_USER_DEFAULT, 0, &st, 0, buf, 255 ) )
+ return QString::fromUcs2( (ushort*)buf );
+ } , {
+ char buf[255];
+ if ( GetDateFormatA( LOCALE_USER_DEFAULT, 0, &st, 0, (char*)&buf, 255 ) )
+ return QString::fromLocal8Bit( buf );
+ } );
+#endif
+ return QString::null;
+ }
+ default:
+#ifndef QT_NO_TEXTDATE
+ case Qt::TextDate:
+ {
+ QString buf = shortDayName( dayOfWeek() );
+ buf += ' ';
+ buf += shortMonthName( m );
+ QString t;
+ t.sprintf( " %d %d", d, y );
+ buf += t;
+ return buf;
+ }
+#endif
+ case Qt::ISODate:
+ {
+ QString month( QString::number( m ).rightJustify( 2, '0' ) );
+ QString day( QString::number( d ).rightJustify( 2, '0' ) );
+ return QString::number( y ) + "-" + month + "-" + day;
+ }
+ }
+}
+#endif //QT_NO_SPRINTF
+
+/*!
+ Returns the date as a string. The \a format parameter determines
+ the format of the result string.
+
+ These expressions may be used:
+
+ \table
+ \header \i Expression \i Output
+ \row \i d \i the day as number without a leading zero (1-31)
+ \row \i dd \i the day as number with a leading zero (01-31)
+ \row \i ddd
+ \i the abbreviated localized day name (e.g. 'Mon'..'Sun').
+ Uses QDate::shortDayName().
+ \row \i dddd
+ \i the long localized day name (e.g. 'Monday'..'Sunday').
+ Uses QDate::longDayName().
+ \row \i M \i the month as number without a leading zero (1-12)
+ \row \i MM \i the month as number with a leading zero (01-12)
+ \row \i MMM
+ \i the abbreviated localized month name (e.g. 'Jan'..'Dec').
+ Uses QDate::shortMonthName().
+ \row \i MMMM
+ \i the long localized month name (e.g. 'January'..'December').
+ Uses QDate::longMonthName().
+ \row \i yy \i the year as two digit number (00-99)
+ \row \i yyyy \i the year as four digit number (1752-8000)
+ \endtable
+
+ All other input characters will be ignored.
+
+ Example format strings (assuming that the QDate is the
+ 20<sup><small>th</small></sup> July 1969):
+ \table
+ \header \i Format \i Result
+ \row \i dd.MM.yyyy \i11 20.07.1969
+ \row \i ddd MMMM d yy \i11 Sun July 20 69
+ \endtable
+
+ \sa QDate::toString() QTime::toString()
+
+*/
+QString QDate::toString( const QString& format ) const
+{
+ return fmtDateTime( format, 0, this );
+}
+#endif //QT_NO_DATESTRING
+
+/*!
+ Sets the date's year \a y, month \a m and day \a d.
+
+ \a y must be in the range 1752..8000, \a m must be in the range
+ 1..12, and \a d must be in the range 1..31.
+
+ \warning If \a y is in the range 0..99, it is interpreted as
+ 1900..1999.
+
+ Returns TRUE if the date is valid; otherwise returns FALSE.
+*/
+
+bool QDate::setYMD( int y, int m, int d )
+{
+ if ( year() == y && month() == m && day() == d )
+ return isValid();
+ if ( !isValid(y,m,d) ) {
+#if defined(QT_CHECK_RANGE)
+ qWarning( "QDate::setYMD: Invalid date %04d-%02d-%02d", y, m, d );
+#endif
+ return FALSE;
+ }
+ jd = gregorianToJulian( y, m, d );
+ return TRUE;
+}
+
+/*!
+ Returns a QDate object containing a date \a ndays later than the
+ date of this object (or earlier if \a ndays is negative).
+
+ \sa addMonths() addYears() daysTo()
+*/
+
+QDate QDate::addDays( int ndays ) const
+{
+ QDate d;
+ d.jd = jd + ndays;
+ return d;
+}
+
+/*!
+ Returns a QDate object containing a date \a nmonths later than the
+ date of this object (or earlier if \a nmonths is negative).
+
+ \sa addDays() addYears()
+*/
+
+QDate QDate::addMonths( int nmonths ) const
+{
+ int y, m, d;
+ julianToGregorian( jd, y, m, d );
+
+ while ( nmonths != 0 ) {
+ if ( nmonths < 0 && nmonths + 12 <= 0 ) {
+ y--;
+ nmonths+=12;
+ } else if ( nmonths < 0 ) {
+ m+= nmonths;
+ nmonths = 0;
+ if ( m <= 0 ) {
+ --y;
+ m+=12;
+ }
+ } else if ( nmonths - 12 >= 0 ) {
+ y++;
+ nmonths-=12;
+ } else if ( m == 12 ) {
+ y++;
+ m = 0;
+ } else {
+ m+= nmonths;
+ nmonths = 0;
+ if ( m > 12 ) {
+ ++y;
+ m -= 12;
+ }
+ }
+ }
+
+ QDate tmp(y,m,1);
+
+ if( d > tmp.daysInMonth() )
+ d = tmp.daysInMonth();
+
+ QDate date(y, m, d);
+ return date;
+
+}
+
+/*!
+ Returns a QDate object containing a date \a nyears later than the
+ date of this object (or earlier if \a nyears is negative).
+
+ \sa addDays(), addMonths()
+*/
+
+QDate QDate::addYears( int nyears ) const
+{
+ int y, m, d;
+ julianToGregorian( jd, y, m, d );
+ y += nyears;
+ QDate date(y, m, d);
+ return date;
+}
+
+
+
+/*!
+ Returns the number of days from this date to \a d (which is
+ negative if \a d is earlier than this date).
+
+ Example:
+ \code
+ QDate d1( 1995, 5, 17 ); // May 17th 1995
+ QDate d2( 1995, 5, 20 ); // May 20th 1995
+ d1.daysTo( d2 ); // returns 3
+ d2.daysTo( d1 ); // returns -3
+ \endcode
+
+ \sa addDays()
+*/
+
+int QDate::daysTo( const QDate &d ) const
+{
+ return d.jd - jd;
+}
+
+
+/*!
+ \fn bool QDate::operator==( const QDate &d ) const
+
+ Returns TRUE if this date is equal to \a d; otherwise returns FALSE.
+*/
+
+/*!
+ \fn bool QDate::operator!=( const QDate &d ) const
+
+ Returns TRUE if this date is different from \a d; otherwise returns FALSE.
+*/
+
+/*!
+ \fn bool QDate::operator<( const QDate &d ) const
+
+ Returns TRUE if this date is earlier than \a d, otherwise returns FALSE.
+*/
+
+/*!
+ \fn bool QDate::operator<=( const QDate &d ) const
+
+ Returns TRUE if this date is earlier than or equal to \a d,
+ otherwise returns FALSE.
+*/
+
+/*!
+ \fn bool QDate::operator>( const QDate &d ) const
+
+ Returns TRUE if this date is later than \a d, otherwise returns FALSE.
+*/
+
+/*!
+ \fn bool QDate::operator>=( const QDate &d ) const
+
+ Returns TRUE if this date is later than or equal to \a d,
+ otherwise returns FALSE.
+*/
+
+/*!
+ \overload
+ Returns the current date, as reported by the system clock.
+
+ \sa QTime::currentTime(), QDateTime::currentDateTime()
+*/
+
+QDate QDate::currentDate()
+{
+ return currentDate( Qt::LocalTime );
+}
+
+/*!
+ Returns the current date, as reported by the system clock, for the
+ TimeSpec \a ts. The default TimeSpec is LocalTime.
+
+ \sa QTime::currentTime(), QDateTime::currentDateTime(), Qt::TimeSpec
+*/
+QDate QDate::currentDate( Qt::TimeSpec ts )
+{
+ QDate d;
+#if defined(Q_OS_WIN32)
+ SYSTEMTIME t;
+ memset( &t, 0, sizeof(SYSTEMTIME) );
+ if ( ts == Qt::LocalTime )
+ GetLocalTime( &t );
+ else
+ GetSystemTime( &t );
+ d.jd = gregorianToJulian( t.wYear, t.wMonth, t.wDay );
+#else
+ time_t ltime;
+ time( &ltime );
+ tm *t;
+ if ( ts == Qt::LocalTime )
+ t = localtime( &ltime );
+ else
+ t = gmtime( &ltime );
+ d.jd = gregorianToJulian( t->tm_year + 1900, t->tm_mon + 1, t->tm_mday );
+#endif
+ return d;
+}
+
+#ifndef QT_NO_DATESTRING
+/*!
+ Returns the QDate represented by the string \a s, using the format
+ \a f, or an invalid date if the string cannot be parsed.
+
+ Note for \c Qt::TextDate: It is recommended that you use the
+ English short month names (e.g. "Jan"). Although localized month
+ names can also be used, they depend on the user's locale settings.
+
+ \warning \c Qt::LocalDate cannot be used here.
+*/
+QDate QDate::fromString( const QString& s, Qt::DateFormat f )
+{
+ if ( ( s.isEmpty() ) || ( f == Qt::LocalDate ) ) {
+#if defined(QT_CHECK_RANGE)
+ qWarning( "QDate::fromString: Parameter out of range." );
+#endif
+ return QDate();
+ }
+ switch ( f ) {
+ case Qt::ISODate:
+ {
+ int year( s.mid( 0, 4 ).toInt() );
+ int month( s.mid( 5, 2 ).toInt() );
+ int day( s.mid( 8, 2 ).toInt() );
+ if ( year && month && day )
+ return QDate( year, month, day );
+ }
+ break;
+ default:
+#ifndef QT_NO_TEXTDATE
+ case Qt::TextDate:
+ {
+ /*
+ This will fail gracefully if the input string doesn't
+ contain any space.
+ */
+ int monthPos = s.find( ' ' ) + 1;
+ int dayPos = s.find( ' ', monthPos ) + 1;
+
+ QString monthName( s.mid(monthPos, dayPos - monthPos - 1) );
+ int month = -1;
+
+ // try English names first
+ for ( int i = 0; i < 12; i++ ) {
+ if ( monthName == qt_shortMonthNames[i] ) {
+ month = i + 1;
+ break;
+ }
+ }
+
+ // try the localized names
+ if ( month == -1 ) {
+ for ( int i = 0; i < 12; i++ ) {
+ if ( monthName == shortMonthName( i + 1 ) ) {
+ month = i + 1;
+ break;
+ }
+ }
+ }
+#if defined(QT_CHECK_RANGE)
+ if ( month < 1 || month > 12 ) {
+ qWarning( "QDate::fromString: Parameter out of range." );
+ month = 1;
+ }
+#endif
+ int day = s.mid( dayPos, 2 ).stripWhiteSpace().toInt();
+ int year = s.right( 4 ).toInt();
+ return QDate( year, month, day );
+ }
+#else
+ break;
+#endif
+ }
+ return QDate();
+}
+#endif //QT_NO_DATESTRING
+
+/*!
+ \overload
+
+ Returns TRUE if the specified date (year \a y, month \a m and day
+ \a d) is valid; otherwise returns FALSE.
+
+ Example:
+ \code
+ QDate::isValid( 2002, 5, 17 ); // TRUE May 17th 2002 is valid
+ QDate::isValid( 2002, 2, 30 ); // FALSE Feb 30th does not exist
+ QDate::isValid( 2004, 2, 29 ); // TRUE 2004 is a leap year
+ QDate::isValid( 1202, 6, 6 ); // FALSE 1202 is pre-Gregorian
+ \endcode
+
+ \warning A \a y value in the range 00..99 is interpreted as
+ 1900..1999.
+
+ \sa isNull(), setYMD()
+*/
+
+bool QDate::isValid( int y, int m, int d )
+{
+ if ( y >= 0 && y <= 99 )
+ y += 1900;
+ else if ( y < FIRST_YEAR || (y == FIRST_YEAR && (m < 9 ||
+ (m == 9 && d < 14))) )
+ return FALSE;
+ return (d > 0 && m > 0 && m <= 12) &&
+ (d <= monthDays[m] || (d == 29 && m == 2 && leapYear(y)));
+}
+
+/*!
+ Returns TRUE if the specified year \a y is a leap year; otherwise
+ returns FALSE.
+*/
+
+bool QDate::leapYear( int y )
+{
+ return y % 4 == 0 && y % 100 != 0 || y % 400 == 0;
+}
+
+/*!
+ \internal
+ Converts a Gregorian date to a Julian day.
+ This algorithm is taken from Communications of the ACM, Vol 6, No 8.
+ \sa julianToGregorian()
+*/
+
+uint QDate::gregorianToJulian( int y, int m, int d )
+{
+ uint c, ya;
+ if ( y <= 99 )
+ y += 1900;
+ if ( m > 2 ) {
+ m -= 3;
+ } else {
+ m += 9;
+ y--;
+ }
+ c = y; // NOTE: Sym C++ 6.0 bug
+ c /= 100;
+ ya = y - 100*c;
+ return 1721119 + d + (146097*c)/4 + (1461*ya)/4 + (153*m+2)/5;
+}
+
+/*!
+ \internal
+ Converts a Julian day to a Gregorian date.
+ This algorithm is taken from Communications of the ACM, Vol 6, No 8.
+ \sa gregorianToJulian()
+*/
+
+void QDate::julianToGregorian( uint jd, int &y, int &m, int &d )
+{
+ uint x;
+ uint j = jd - 1721119;
+ y = (j*4 - 1)/146097;
+ j = j*4 - 146097*y - 1;
+ x = j/4;
+ j = (x*4 + 3) / 1461;
+ y = 100*y + j;
+ x = (x*4) + 3 - 1461*j;
+ x = (x + 4)/4;
+ m = (5*x - 3)/153;
+ x = 5*x - 3 - 153*m;
+ d = (x + 5)/5;
+ if ( m < 10 ) {
+ m += 3;
+ } else {
+ m -= 9;
+ y++;
+ }
+}
+
+
+/*****************************************************************************
+ QTime member functions
+ *****************************************************************************/
+
+/*!
+ \class QTime qdatetime.h
+ \reentrant
+
+ \brief The QTime class provides clock time functions.
+
+ \ingroup time
+ \mainclass
+
+ A QTime object contains a clock time, i.e. the number of hours,
+ minutes, seconds, and milliseconds since midnight. It can read the
+ current time from the system clock and measure a span of elapsed
+ time. It provides functions for comparing times and for
+ manipulating a time by adding a number of (milli)seconds.
+
+ QTime uses the 24-hour clock format; it has no concept of AM/PM.
+ It operates in local time; it knows nothing about time zones or
+ daylight savings time.
+
+ A QTime object is typically created either by giving the number of
+ hours, minutes, seconds, and milliseconds explicitly, or by using
+ the static function currentTime(), which creates a QTime object
+ that contains the system's clock time. Note that the accuracy
+ depends on the accuracy of the underlying operating system; not
+ all systems provide 1-millisecond accuracy.
+
+ The hour(), minute(), second(), and msec() functions provide
+ access to the number of hours, minutes, seconds, and milliseconds
+ of the time. The same information is provided in textual format by
+ the toString() function.
+
+ QTime provides a full set of operators to compare two QTime
+ objects. One time is considered smaller than another if it is
+ earlier than the other.
+
+ The time a given number of seconds or milliseconds later than a
+ given time can be found using the addSecs() or addMSecs()
+ functions. Correspondingly, the number of (milli)seconds between
+ two times can be found using the secsTo() or msecsTo() functions.
+
+ QTime can be used to measure a span of elapsed time using the
+ start(), restart(), and elapsed() functions.
+
+ \sa QDate, QDateTime
+*/
+
+/*!
+ \fn QTime::QTime()
+
+ Constructs the time 0 hours, minutes, seconds and milliseconds,
+ i.e. 00:00:00.000 (midnight). This is a valid time.
+
+ \sa isValid()
+*/
+
+/*!
+ Constructs a time with hour \a h, minute \a m, seconds \a s and
+ milliseconds \a ms.
+
+ \a h must be in the range 0..23, \a m and \a s must be in the
+ range 0..59, and \a ms must be in the range 0..999.
+
+ \sa isValid()
+*/
+
+QTime::QTime( int h, int m, int s, int ms )
+{
+ setHMS( h, m, s, ms );
+}
+
+
+/*!
+ \fn bool QTime::isNull() const
+
+ Returns TRUE if the time is equal to 00:00:00.000; otherwise
+ returns FALSE. A null time is valid.
+
+ \sa isValid()
+*/
+
+/*!
+ Returns TRUE if the time is valid; otherwise returns FALSE. The
+ time 23:30:55.746 is valid, whereas 24:12:30 is invalid.
+
+ \sa isNull()
+*/
+
+bool QTime::isValid() const
+{
+ return ds < MSECS_PER_DAY;
+}
+
+
+/*!
+ Returns the hour part (0..23) of the time.
+*/
+
+int QTime::hour() const
+{
+ return ds / MSECS_PER_HOUR;
+}
+
+/*!
+ Returns the minute part (0..59) of the time.
+*/
+
+int QTime::minute() const
+{
+ return (ds % MSECS_PER_HOUR)/MSECS_PER_MIN;
+}
+
+/*!
+ Returns the second part (0..59) of the time.
+*/
+
+int QTime::second() const
+{
+ return (ds / 1000)%SECS_PER_MIN;
+}
+
+/*!
+ Returns the millisecond part (0..999) of the time.
+*/
+
+int QTime::msec() const
+{
+ return ds % 1000;
+}
+
+#ifndef QT_NO_DATESTRING
+#ifndef QT_NO_SPRINTF
+/*!
+ \overload
+
+ Returns the time as a string. Milliseconds are not included. The
+ \a f parameter determines the format of the string.
+
+ If \a f is \c Qt::TextDate, the string format is HH:MM:SS; e.g. 1
+ second before midnight would be "23:59:59".
+
+ If \a f is \c Qt::ISODate, the string format corresponds to the
+ ISO 8601 extended specification for representations of dates,
+ which is also HH:MM:SS.
+
+ If \a f is Qt::LocalDate, the string format depends on the locale
+ settings of the system.
+*/
+
+QString QTime::toString( Qt::DateFormat f ) const
+{
+ switch ( f ) {
+ case Qt::LocalDate:
+ {
+#ifndef Q_WS_WIN
+ tm tt;
+ memset( &tt, 0, sizeof( tm ) );
+ char buf[255];
+ tt.tm_sec = second();
+ tt.tm_min = minute();
+ tt.tm_hour = hour();
+ if ( strftime( buf, sizeof(buf), "%X", &tt ) )
+ return QString::fromLocal8Bit( buf );
+#else
+ SYSTEMTIME st;
+ memset( &st, 0, sizeof(SYSTEMTIME) );
+ st.wHour = hour();
+ st.wMinute = minute();
+ st.wSecond = second();
+ st.wMilliseconds = 0;
+ QT_WA( {
+ TCHAR buf[255];
+ if ( GetTimeFormat( LOCALE_USER_DEFAULT, 0, &st, 0, buf, 255 ) )
+ return QString::fromUcs2( (ushort*)buf );
+ } , {
+ char buf[255];
+ if ( GetTimeFormatA( LOCALE_USER_DEFAULT, 0, &st, 0, (char*)&buf, 255 ) )
+ return QString::fromLocal8Bit( buf );
+ } );
+#endif
+ return QString::null;
+ }
+ default:
+ case Qt::ISODate:
+ case Qt::TextDate:
+ QString buf;
+ buf.sprintf( "%.2d:%.2d:%.2d", hour(), minute(), second() );
+ return buf;
+ }
+}
+#endif
+
+/*!
+ Returns the time as a string. The \a format parameter determines
+ the format of the result string.
+
+ These expressions may be used:
+
+ \table
+ \header \i Expression \i Output
+ \row \i h
+ \i the hour without a leading zero (0..23 or 1..12 if AM/PM display)
+ \row \i hh
+ \i the hour with a leading zero (00..23 or 01..12 if AM/PM display)
+ \row \i m \i the minute without a leading zero (0..59)
+ \row \i mm \i the minute with a leading zero (00..59)
+ \row \i s \i the second whithout a leading zero (0..59)
+ \row \i ss \i the second whith a leading zero (00..59)
+ \row \i z \i the milliseconds without leading zeroes (0..999)
+ \row \i zzz \i the milliseconds with leading zeroes (000..999)
+ \row \i AP
+ \i use AM/PM display. \e AP will be replaced by either "AM" or "PM".
+ \row \i ap
+ \i use am/pm display. \e ap will be replaced by either "am" or "pm".
+ \endtable
+
+ All other input characters will be ignored.
+
+ Example format strings (assuming that the QTime is 14:13:09.042)
+
+ \table
+ \header \i Format \i Result
+ \row \i hh:mm:ss.zzz \i11 14:13:09.042
+ \row \i h:m:s ap \i11 2:13:9 pm
+ \endtable
+
+ \sa QDate::toString() QTime::toString()
+*/
+QString QTime::toString( const QString& format ) const
+{
+ return fmtDateTime( format, this, 0 );
+}
+#endif //QT_NO_DATESTRING
+/*!
+ Sets the time to hour \a h, minute \a m, seconds \a s and
+ milliseconds \a ms.
+
+ \a h must be in the range 0..23, \a m and \a s must be in the
+ range 0..59, and \a ms must be in the range 0..999. Returns TRUE
+ if the set time is valid; otherwise returns FALSE.
+
+ \sa isValid()
+*/
+
+bool QTime::setHMS( int h, int m, int s, int ms )
+{
+ if ( !isValid(h,m,s,ms) ) {
+#if defined(QT_CHECK_RANGE)
+ qWarning( "QTime::setHMS Invalid time %02d:%02d:%02d.%03d", h, m, s,
+ ms );
+#endif
+ ds = MSECS_PER_DAY; // make this invalid
+ return FALSE;
+ }
+ ds = (h*SECS_PER_HOUR + m*SECS_PER_MIN + s)*1000 + ms;
+ return TRUE;
+}
+
+/*!
+ Returns a QTime object containing a time \a nsecs seconds later
+ than the time of this object (or earlier if \a nsecs is negative).
+
+ Note that the time will wrap if it passes midnight.
+
+ Example:
+ \code
+ QTime n( 14, 0, 0 ); // n == 14:00:00
+ QTime t;
+ t = n.addSecs( 70 ); // t == 14:01:10
+ t = n.addSecs( -70 ); // t == 13:58:50
+ t = n.addSecs( 10*60*60 + 5 ); // t == 00:00:05
+ t = n.addSecs( -15*60*60 ); // t == 23:00:00
+ \endcode
+
+ \sa addMSecs(), secsTo(), QDateTime::addSecs()
+*/
+
+QTime QTime::addSecs( int nsecs ) const
+{
+ return addMSecs( nsecs * 1000 );
+}
+
+/*!
+ Returns the number of seconds from this time to \a t (which is
+ negative if \a t is earlier than this time).
+
+ Because QTime measures time within a day and there are 86400
+ seconds in a day, the result is always between -86400 and 86400.
+
+ \sa addSecs() QDateTime::secsTo()
+*/
+
+int QTime::secsTo( const QTime &t ) const
+{
+ return ((int)t.ds - (int)ds)/1000;
+}
+
+/*!
+ Returns a QTime object containing a time \a ms milliseconds later
+ than the time of this object (or earlier if \a ms is negative).
+
+ Note that the time will wrap if it passes midnight. See addSecs()
+ for an example.
+
+ \sa addSecs(), msecsTo()
+*/
+
+QTime QTime::addMSecs( int ms ) const
+{
+ QTime t;
+ if ( ms < 0 ) {
+ // % not well-defined for -ve, but / is.
+ int negdays = (MSECS_PER_DAY-ms) / MSECS_PER_DAY;
+ t.ds = ((int)ds + ms + negdays*MSECS_PER_DAY)
+ % MSECS_PER_DAY;
+ } else {
+ t.ds = ((int)ds + ms) % MSECS_PER_DAY;
+ }
+ return t;
+}
+
+/*!
+ Returns the number of milliseconds from this time to \a t (which
+ is negative if \a t is earlier than this time).
+
+ Because QTime measures time within a day and there are 86400
+ seconds in a day, the result is always between -86400 and 86400s.
+
+ \sa secsTo()
+*/
+
+int QTime::msecsTo( const QTime &t ) const
+{
+ return (int)t.ds - (int)ds;
+}
+
+
+/*!
+ \fn bool QTime::operator==( const QTime &t ) const
+
+ Returns TRUE if this time is equal to \a t; otherwise returns FALSE.
+*/
+
+/*!
+ \fn bool QTime::operator!=( const QTime &t ) const
+
+ Returns TRUE if this time is different from \a t; otherwise returns FALSE.
+*/
+
+/*!
+ \fn bool QTime::operator<( const QTime &t ) const
+
+ Returns TRUE if this time is earlier than \a t; otherwise returns FALSE.
+*/
+
+/*!
+ \fn bool QTime::operator<=( const QTime &t ) const
+
+ Returns TRUE if this time is earlier than or equal to \a t;
+ otherwise returns FALSE.
+*/
+
+/*!
+ \fn bool QTime::operator>( const QTime &t ) const
+
+ Returns TRUE if this time is later than \a t; otherwise returns FALSE.
+*/
+
+/*!
+ \fn bool QTime::operator>=( const QTime &t ) const
+
+ Returns TRUE if this time is later than or equal to \a t;
+ otherwise returns FALSE.
+*/
+
+
+
+/*!
+ \overload
+
+ Returns the current time as reported by the system clock.
+
+ Note that the accuracy depends on the accuracy of the underlying
+ operating system; not all systems provide 1-millisecond accuracy.
+*/
+
+QTime QTime::currentTime()
+{
+ return currentTime( Qt::LocalTime );
+}
+
+/*!
+ Returns the current time as reported by the system clock, for the
+ TimeSpec \a ts. The default TimeSpec is LocalTime.
+
+ Note that the accuracy depends on the accuracy of the underlying
+ operating system; not all systems provide 1-millisecond accuracy.
+
+ \sa Qt::TimeSpec
+*/
+QTime QTime::currentTime( Qt::TimeSpec ts )
+{
+ QTime t;
+ currentTime( &t, ts );
+ return t;
+}
+
+#ifndef QT_NO_DATESTRING
+/*!
+ Returns the representation \a s as a QTime using the format \a f,
+ or an invalid time if this is not possible.
+
+ \warning Note that \c Qt::LocalDate cannot be used here.
+*/
+QTime QTime::fromString( const QString& s, Qt::DateFormat f )
+{
+ if ( ( s.isEmpty() ) || ( f == Qt::LocalDate ) ) {
+#if defined(QT_CHECK_RANGE)
+ qWarning( "QTime::fromString: Parameter out of range." );
+#endif
+ return QTime();
+ }
+
+ int hour( s.mid( 0, 2 ).toInt() );
+ int minute( s.mid( 3, 2 ).toInt() );
+ int second( s.mid( 6, 2 ).toInt() );
+ int msec( s.mid( 9, 3 ).toInt() );
+ return QTime( hour, minute, second, msec );
+}
+#endif
+
+/*!
+ \internal
+ \obsolete
+
+ Fetches the current time and returns TRUE if the time is within one
+ minute after midnight, otherwise FALSE. The return value is used by
+ QDateTime::currentDateTime() to ensure that the date there is correct.
+*/
+
+bool QTime::currentTime( QTime *ct )
+{
+ return currentTime( ct, Qt::LocalTime );
+}
+
+
+/*!
+ \internal
+
+ Fetches the current time, for the TimeSpec \a ts, and returns TRUE
+ if the time is within one minute after midnight, otherwise FALSE. The
+ return value is used by QDateTime::currentDateTime() to ensure that
+ the date there is correct. The default TimeSpec is LocalTime.
+
+ \sa Qt::TimeSpec
+*/
+bool QTime::currentTime( QTime *ct, Qt::TimeSpec ts )
+{
+ if ( !ct ) {
+#if defined(QT_CHECK_NULL)
+ qWarning( "QTime::currentTime(QTime *): Null pointer not allowed" );
+#endif
+ return FALSE;
+ }
+
+#if defined(Q_OS_WIN32)
+ SYSTEMTIME t;
+ if ( ts == Qt::LocalTime ) {
+ GetLocalTime( &t );
+ } else {
+ GetSystemTime( &t );
+ }
+ ct->ds = (uint)( MSECS_PER_HOUR*t.wHour + MSECS_PER_MIN*t.wMinute +
+ 1000*t.wSecond + t.wMilliseconds );
+#elif defined(Q_OS_UNIX)
+ struct timeval tv;
+ gettimeofday( &tv, 0 );
+ time_t ltime = tv.tv_sec;
+ tm *t;
+ if ( ts == Qt::LocalTime ) {
+ t = localtime( &ltime );
+ } else {
+ t = gmtime( &ltime );
+ }
+ ct->ds = (uint)( MSECS_PER_HOUR * t->tm_hour + MSECS_PER_MIN * t->tm_min +
+ 1000 * t->tm_sec + tv.tv_usec / 1000 );
+#else
+ time_t ltime; // no millisecond resolution
+ ::time( &ltime );
+ tm *t;
+ if ( ts == Qt::LocalTime )
+ localtime( &ltime );
+ else
+ gmtime( &ltime );
+ ct->ds = (uint) ( MSECS_PER_HOUR * t->tm_hour + MSECS_PER_MIN * t->tm_min +
+ 1000 * t->tm_sec );
+#endif
+ // 00:00.00 to 00:00.59.999 is considered as "midnight or right after"
+ return ct->ds < (uint) MSECS_PER_MIN;
+}
+
+/*!
+ \overload
+
+ Returns TRUE if the specified time is valid; otherwise returns
+ FALSE.
+
+ The time is valid if \a h is in the range 0..23, \a m and \a s are
+ in the range 0..59, and \a ms is in the range 0..999.
+
+ Example:
+ \code
+ QTime::isValid(21, 10, 30); // returns TRUE
+ QTime::isValid(22, 5, 62); // returns FALSE
+ \endcode
+*/
+
+bool QTime::isValid( int h, int m, int s, int ms )
+{
+ return (uint)h < 24 && (uint)m < 60 && (uint)s < 60 && (uint)ms < 1000;
+}
+
+
+/*!
+ Sets this time to the current time. This is practical for timing:
+
+ \code
+ QTime t;
+ t.start(); // start clock
+ ... // some lengthy task
+ qDebug( "%d\n", t.elapsed() ); // prints the number of msecs elapsed
+ \endcode
+
+ \sa restart(), elapsed(), currentTime()
+*/
+
+void QTime::start()
+{
+ *this = currentTime();
+}
+
+/*!
+ Sets this time to the current time and returns the number of
+ milliseconds that have elapsed since the last time start() or
+ restart() was called.
+
+ This function is guaranteed to be atomic and is thus very handy
+ for repeated measurements. Call start() to start the first
+ measurement and then restart() for each later measurement.
+
+ Note that the counter wraps to zero 24 hours after the last call
+ to start() or restart().
+
+ \warning If the system's clock setting has been changed since the
+ last time start() or restart() was called, the result is
+ undefined. This can happen when daylight savings time is turned on
+ or off.
+
+ \sa start(), elapsed(), currentTime()
+*/
+
+int QTime::restart()
+{
+ QTime t = currentTime();
+ int n = msecsTo( t );
+ if ( n < 0 ) // passed midnight
+ n += 86400*1000;
+ *this = t;
+ return n;
+}
+
+/*!
+ Returns the number of milliseconds that have elapsed since the
+ last time start() or restart() was called.
+
+ Note that the counter wraps to zero 24 hours after the last call
+ to start() or restart.
+
+ Note that the accuracy depends on the accuracy of the underlying
+ operating system; not all systems provide 1-millisecond accuracy.
+
+ \warning If the system's clock setting has been changed since the
+ last time start() or restart() was called, the result is
+ undefined. This can happen when daylight savings time is turned on
+ or off.
+
+ \sa start(), restart()
+*/
+
+int QTime::elapsed() const
+{
+ int n = msecsTo( currentTime() );
+ if ( n < 0 ) // passed midnight
+ n += 86400*1000;
+ return n;
+}
+
+
+/*****************************************************************************
+ QDateTime member functions
+ *****************************************************************************/
+
+/*!
+ \class QDateTime qdatetime.h
+ \reentrant
+ \brief The QDateTime class provides date and time functions.
+
+ \ingroup time
+ \mainclass
+
+ A QDateTime object contains a calendar date and a clock time (a
+ "datetime"). It is a combination of the QDate and QTime classes.
+ It can read the current datetime from the system clock. It
+ provides functions for comparing datetimes and for manipulating a
+ datetime by adding a number of seconds, days, months or years.
+
+ A QDateTime object is typically created either by giving a date
+ and time explicitly in the constructor, or by using the static
+ function currentDateTime(), which returns a QDateTime object set
+ to the system clock's time. The date and time can be changed with
+ setDate() and setTime(). A datetime can also be set using the
+ setTime_t() function, which takes a POSIX-standard "number of
+ seconds since 00:00:00 on January 1, 1970" value. The fromString()
+ function returns a QDateTime given a string and a date format
+ which is used to interpret the date within the string.
+
+ The date() and time() functions provide access to the date and
+ time parts of the datetime. The same information is provided in
+ textual format by the toString() function.
+
+ QDateTime provides a full set of operators to compare two
+ QDateTime objects where smaller means earlier and larger means
+ later.
+
+ You can increment (or decrement) a datetime by a given number of
+ seconds using addSecs() or days using addDays(). Similarly you can
+ use addMonths() and addYears(). The daysTo() function returns the
+ number of days between two datetimes, and secsTo() returns the
+ number of seconds between two datetimes.
+
+ The range of a datetime object is constrained to the ranges of the
+ QDate and QTime objects which it embodies.
+
+ \sa QDate QTime QDateTimeEdit
+*/
+
+
+/*!
+ \fn QDateTime::QDateTime()
+
+ Constructs a null datetime (i.e. null date and null time). A null
+ datetime is invalid, since the date is invalid.
+
+ \sa isValid()
+*/
+
+
+/*!
+ Constructs a datetime with date \a date and null (but valid) time
+ (00:00:00.000).
+*/
+
+QDateTime::QDateTime( const QDate &date )
+ : d(date)
+{
+}
+
+/*!
+ Constructs a datetime with date \a date and time \a time.
+*/
+
+QDateTime::QDateTime( const QDate &date, const QTime &time )
+ : d(date), t(time)
+{
+}
+
+
+/*!
+ \fn bool QDateTime::isNull() const
+
+ Returns TRUE if both the date and the time are null; otherwise
+ returns FALSE. A null datetime is invalid.
+
+ \sa QDate::isNull(), QTime::isNull()
+*/
+
+/*!
+ \fn bool QDateTime::isValid() const
+
+ Returns TRUE if both the date and the time are valid; otherwise
+ returns FALSE.
+
+ \sa QDate::isValid(), QTime::isValid()
+*/
+
+/*!
+ \fn QDate QDateTime::date() const
+
+ Returns the date part of the datetime.
+
+ \sa setDate(), time()
+*/
+
+/*!
+ \fn QTime QDateTime::time() const
+
+ Returns the time part of the datetime.
+
+ \sa setTime(), date()
+*/
+
+/*!
+ \fn void QDateTime::setDate( const QDate &date )
+
+ Sets the date part of this datetime to \a date.
+
+ \sa date(), setTime()
+*/
+
+/*!
+ \fn void QDateTime::setTime( const QTime &time )
+
+ Sets the time part of this datetime to \a time.
+
+ \sa time(), setDate()
+*/
+
+
+/*!
+ Returns the datetime as the number of seconds that have passed
+ since 1970-01-01T00:00:00, Coordinated Universal Time (UTC).
+
+ On systems that do not support timezones, this function will
+ behave as if local time were UTC.
+
+ \sa setTime_t()
+*/
+
+uint QDateTime::toTime_t() const
+{
+ tm brokenDown;
+ brokenDown.tm_sec = t.second();
+ brokenDown.tm_min = t.minute();
+ brokenDown.tm_hour = t.hour();
+ brokenDown.tm_mday = d.day();
+ brokenDown.tm_mon = d.month() - 1;
+ brokenDown.tm_year = d.year() - 1900;
+ brokenDown.tm_isdst = -1;
+ int secsSince1Jan1970UTC = (int) mktime( &brokenDown );
+ if ( secsSince1Jan1970UTC < -1 )
+ secsSince1Jan1970UTC = -1;
+ return (uint) secsSince1Jan1970UTC;
+}
+
+/*!
+ \overload
+
+ Convenience function that sets the date and time to local time
+ based on the given UTC time.
+*/
+
+void QDateTime::setTime_t( uint secsSince1Jan1970UTC )
+{
+ setTime_t( secsSince1Jan1970UTC, Qt::LocalTime );
+}
+
+/*!
+ Sets the date and time to \a ts time (\c Qt::LocalTime or \c
+ Qt::UTC) given the number of seconds that have passed since
+ 1970-01-01T00:00:00, Coordinated Universal Time (UTC). On systems
+ that do not support timezones this function will behave as if
+ local time were UTC.
+
+ On Windows, only a subset of \a secsSince1Jan1970UTC values are
+ supported, as Windows starts counting from 1980.
+
+ \sa toTime_t()
+*/
+void QDateTime::setTime_t( uint secsSince1Jan1970UTC, Qt::TimeSpec ts )
+{
+ time_t tmp = (time_t) secsSince1Jan1970UTC;
+ tm *brokenDown = 0;
+ if ( ts == Qt::LocalTime )
+ brokenDown = localtime( &tmp );
+ if ( !brokenDown ) {
+ brokenDown = gmtime( &tmp );
+ if ( !brokenDown ) {
+ d.jd = QDate::gregorianToJulian( 1970, 1, 1 );
+ t.ds = 0;
+ return;
+ }
+ }
+ d.jd = QDate::gregorianToJulian( brokenDown->tm_year + 1900,
+ brokenDown->tm_mon + 1,
+ brokenDown->tm_mday );
+ t.ds = MSECS_PER_HOUR * brokenDown->tm_hour +
+ MSECS_PER_MIN * brokenDown->tm_min +
+ 1000 * brokenDown->tm_sec;
+}
+#ifndef QT_NO_DATESTRING
+#ifndef QT_NO_SPRINTF
+/*!
+ \overload
+
+ Returns the datetime as a string. The \a f parameter determines
+ the format of the string.
+
+ If \a f is \c Qt::TextDate, the string format is "Wed May 20
+ 03:40:13 1998" (using QDate::shortDayName(), QDate::shortMonthName(),
+ and QTime::toString() to generate the string, so the day and month
+ names will have localized names).
+
+ If \a f is \c Qt::ISODate, the string format corresponds to the
+ ISO 8601 extended specification for representations of dates and
+ times, which is YYYY-MM-DDTHH:MM:SS.
+
+ If \a f is \c Qt::LocalDate, the string format depends on the
+ locale settings of the system.
+
+ If the format \a f is invalid, toString() returns a null string.
+
+ \sa QDate::toString() QTime::toString()
+*/
+
+QString QDateTime::toString( Qt::DateFormat f ) const
+{
+ if ( f == Qt::ISODate ) {
+ return d.toString( Qt::ISODate ) + "T" + t.toString( Qt::ISODate );
+ }
+#ifndef QT_NO_TEXTDATE
+ else if ( f == Qt::TextDate ) {
+#ifndef Q_WS_WIN
+ QString buf = d.shortDayName( d.dayOfWeek() );
+ buf += ' ';
+ buf += d.shortMonthName( d.month() );
+ buf += ' ';
+ buf += QString().setNum( d.day() );
+ buf += ' ';
+#else
+ QString buf;
+ QString winstr;
+ QT_WA( {
+ TCHAR out[255];
+ GetLocaleInfo( LOCALE_USER_DEFAULT, LOCALE_ILDATE, out, 255 );
+ winstr = QString::fromUcs2( (ushort*)out );
+ } , {
+ char out[255];
+ GetLocaleInfoA( LOCALE_USER_DEFAULT, LOCALE_ILDATE, (char*)&out, 255 );
+ winstr = QString::fromLocal8Bit( out );
+ } );
+ switch ( winstr.toInt() ) {
+ case 1:
+ buf = d.shortDayName( d.dayOfWeek() ) + " " + QString().setNum( d.day() ) + ". " + d.shortMonthName( d.month() ) + " ";
+ break;
+ default:
+ buf = d.shortDayName( d.dayOfWeek() ) + " " + d.shortMonthName( d.month() ) + " " + QString().setNum( d.day() ) + " ";
+ break;
+ }
+#endif
+ buf += t.toString();
+ buf += ' ';
+ buf += QString().setNum( d.year() );
+ return buf;
+ }
+#endif
+ else if ( f == Qt::LocalDate ) {
+ return d.toString( Qt::LocalDate ) + " " + t.toString( Qt::LocalDate );
+ }
+ return QString::null;
+}
+#endif
+
+/*!
+ Returns the datetime as a string. The \a format parameter
+ determines the format of the result string.
+
+ These expressions may be used for the date:
+
+ \table
+ \header \i Expression \i Output
+ \row \i d \i the day as number without a leading zero (1-31)
+ \row \i dd \i the day as number with a leading zero (01-31)
+ \row \i ddd
+ \i the abbreviated localized day name (e.g. 'Mon'..'Sun').
+ Uses QDate::shortDayName().
+ \row \i dddd
+ \i the long localized day name (e.g. 'Monday'..'Sunday').
+ Uses QDate::longDayName().
+ \row \i M \i the month as number without a leading zero (1-12)
+ \row \i MM \i the month as number with a leading zero (01-12)
+ \row \i MMM
+ \i the abbreviated localized month name (e.g. 'Jan'..'Dec').
+ Uses QDate::shortMonthName().
+ \row \i MMMM
+ \i the long localized month name (e.g. 'January'..'December').
+ Uses QDate::longMonthName().
+ \row \i yy \i the year as two digit number (00-99)
+ \row \i yyyy \i the year as four digit number (1752-8000)
+ \endtable
+
+ These expressions may be used for the time:
+
+ \table
+ \header \i Expression \i Output
+ \row \i h
+ \i the hour without a leading zero (0..23 or 1..12 if AM/PM display)
+ \row \i hh
+ \i the hour with a leading zero (00..23 or 01..12 if AM/PM display)
+ \row \i m \i the minute without a leading zero (0..59)
+ \row \i mm \i the minute with a leading zero (00..59)
+ \row \i s \i the second whithout a leading zero (0..59)
+ \row \i ss \i the second whith a leading zero (00..59)
+ \row \i z \i the milliseconds without leading zeroes (0..999)
+ \row \i zzz \i the milliseconds with leading zeroes (000..999)
+ \row \i AP
+ \i use AM/PM display. \e AP will be replaced by either "AM" or "PM".
+ \row \i ap
+ \i use am/pm display. \e ap will be replaced by either "am" or "pm".
+ \endtable
+
+ All other input characters will be ignored.
+
+ Example format strings (assumed that the QDateTime is
+ 21<small><sup>st</sup></small> May 2001 14:13:09)
+
+ \table
+ \header \i Format \i Result
+ \row \i dd.MM.yyyy \i11 21.05.2001
+ \row \i ddd MMMM d yy \i11 Tue May 21 01
+ \row \i hh:mm:ss.zzz \i11 14:13:09.042
+ \row \i h:m:s ap \i11 2:13:9 pm
+ \endtable
+
+ \sa QDate::toString() QTime::toString()
+*/
+QString QDateTime::toString( const QString& format ) const
+{
+ return fmtDateTime( format, &t, &d );
+}
+#endif //QT_NO_DATESTRING
+
+/*!
+ Returns a QDateTime object containing a datetime \a ndays days
+ later than the datetime of this object (or earlier if \a ndays is
+ negative).
+
+ \sa daysTo(), addMonths(), addYears(), addSecs()
+*/
+
+QDateTime QDateTime::addDays( int ndays ) const
+{
+ return QDateTime( d.addDays(ndays), t );
+}
+
+/*!
+ Returns a QDateTime object containing a datetime \a nmonths months
+ later than the datetime of this object (or earlier if \a nmonths
+ is negative).
+
+ \sa daysTo(), addDays(), addYears(), addSecs()
+*/
+
+QDateTime QDateTime::addMonths( int nmonths ) const
+{
+ return QDateTime( d.addMonths(nmonths), t );
+}
+
+/*!
+ Returns a QDateTime object containing a datetime \a nyears years
+ later than the datetime of this object (or earlier if \a nyears is
+ negative).
+
+ \sa daysTo(), addDays(), addMonths(), addSecs()
+*/
+
+QDateTime QDateTime::addYears( int nyears ) const
+{
+ return QDateTime( d.addYears(nyears), t );
+}
+
+/*!
+ Returns a QDateTime object containing a datetime \a nsecs seconds
+ later than the datetime of this object (or earlier if \a nsecs is
+ negative).
+
+ \sa secsTo(), addDays(), addMonths(), addYears()
+*/
+
+QDateTime QDateTime::addSecs( int nsecs ) const
+{
+ uint dd = d.jd;
+ int tt = t.ds;
+ int sign = 1;
+ if ( nsecs < 0 ) {
+ nsecs = -nsecs;
+ sign = -1;
+ }
+ if ( nsecs >= (int)SECS_PER_DAY ) {
+ dd += sign*(nsecs/SECS_PER_DAY);
+ nsecs %= SECS_PER_DAY;
+ }
+ tt += sign*nsecs*1000;
+ if ( tt < 0 ) {
+ tt = MSECS_PER_DAY - tt - 1;
+ dd -= tt / MSECS_PER_DAY;
+ tt = tt % MSECS_PER_DAY;
+ tt = MSECS_PER_DAY - tt - 1;
+ } else if ( tt >= (int)MSECS_PER_DAY ) {
+ dd += ( tt / MSECS_PER_DAY );
+ tt = tt % MSECS_PER_DAY;
+ }
+ QDateTime ret;
+ ret.t.ds = tt;
+ ret.d.jd = dd;
+ return ret;
+}
+
+/*!
+ Returns the number of days from this datetime to \a dt (which is
+ negative if \a dt is earlier than this datetime).
+
+ \sa addDays(), secsTo()
+*/
+
+int QDateTime::daysTo( const QDateTime &dt ) const
+{
+ return d.daysTo( dt.d );
+}
+
+/*!
+ Returns the number of seconds from this datetime to \a dt (which
+ is negative if \a dt is earlier than this datetime).
+
+ Example:
+ \code
+ QDateTime dt = QDateTime::currentDateTime();
+ QDateTime xmas( QDate(dt.year(),12,24), QTime(17,00) );
+ qDebug( "There are %d seconds to Christmas", dt.secsTo(xmas) );
+ \endcode
+
+ \sa addSecs(), daysTo(), QTime::secsTo()
+*/
+
+int QDateTime::secsTo( const QDateTime &dt ) const
+{
+ return t.secsTo(dt.t) + d.daysTo(dt.d)*SECS_PER_DAY;
+}
+
+
+/*!
+ Returns TRUE if this datetime is equal to \a dt; otherwise returns FALSE.
+
+ \sa operator!=()
+*/
+
+bool QDateTime::operator==( const QDateTime &dt ) const
+{
+ return t == dt.t && d == dt.d;
+}
+
+/*!
+ Returns TRUE if this datetime is different from \a dt; otherwise
+ returns FALSE.
+
+ \sa operator==()
+*/
+
+bool QDateTime::operator!=( const QDateTime &dt ) const
+{
+ return t != dt.t || d != dt.d;
+}
+
+/*!
+ Returns TRUE if this datetime is earlier than \a dt; otherwise
+ returns FALSE.
+*/
+
+bool QDateTime::operator<( const QDateTime &dt ) const
+{
+ if ( d < dt.d )
+ return TRUE;
+ return d == dt.d ? t < dt.t : FALSE;
+}
+
+/*!
+ Returns TRUE if this datetime is earlier than or equal to \a dt;
+ otherwise returns FALSE.
+*/
+
+bool QDateTime::operator<=( const QDateTime &dt ) const
+{
+ if ( d < dt.d )
+ return TRUE;
+ return d == dt.d ? t <= dt.t : FALSE;
+}
+
+/*!
+ Returns TRUE if this datetime is later than \a dt; otherwise
+ returns FALSE.
+*/
+
+bool QDateTime::operator>( const QDateTime &dt ) const
+{
+ if ( d > dt.d )
+ return TRUE;
+ return d == dt.d ? t > dt.t : FALSE;
+}
+
+/*!
+ Returns TRUE if this datetime is later than or equal to \a dt;
+ otherwise returns FALSE.
+*/
+
+bool QDateTime::operator>=( const QDateTime &dt ) const
+{
+ if ( d > dt.d )
+ return TRUE;
+ return d == dt.d ? t >= dt.t : FALSE;
+}
+
+/*!
+ \overload
+
+ Returns the current datetime, as reported by the system clock.
+
+ \sa QDate::currentDate(), QTime::currentTime()
+*/
+
+QDateTime QDateTime::currentDateTime()
+{
+ return currentDateTime( Qt::LocalTime );
+}
+
+/*!
+ Returns the current datetime, as reported by the system clock, for the
+ TimeSpec \a ts. The default TimeSpec is LocalTime.
+
+ \sa QDate::currentDate(), QTime::currentTime(), Qt::TimeSpec
+*/
+
+QDateTime QDateTime::currentDateTime( Qt::TimeSpec ts )
+{
+ QDateTime dt;
+ QTime t;
+ dt.setDate( QDate::currentDate(ts) );
+ if ( QTime::currentTime(&t, ts) ) // midnight or right after?
+ dt.setDate( QDate::currentDate(ts) ); // fetch date again
+ dt.setTime( t );
+ return dt;
+}
+
+#ifndef QT_NO_DATESTRING
+/*!
+ Returns the QDateTime represented by the string \a s, using the
+ format \a f, or an invalid datetime if this is not possible.
+
+ Note for \c Qt::TextDate: It is recommended that you use the
+ English short month names (e.g. "Jan"). Although localized month
+ names can also be used, they depend on the user's locale settings.
+
+ \warning Note that \c Qt::LocalDate cannot be used here.
+*/
+QDateTime QDateTime::fromString( const QString& s, Qt::DateFormat f )
+{
+ if ( ( s.isEmpty() ) || ( f == Qt::LocalDate ) ) {
+#if defined(QT_CHECK_RANGE)
+ qWarning( "QDateTime::fromString: Parameter out of range" );
+#endif
+ return QDateTime();
+ }
+ if ( f == Qt::ISODate ) {
+ return QDateTime( QDate::fromString( s.mid(0,10), Qt::ISODate ),
+ QTime::fromString( s.mid(11), Qt::ISODate ) );
+ }
+#if !defined(QT_NO_REGEXP) && !defined(QT_NO_TEXTDATE)
+ else if ( f == Qt::TextDate ) {
+ QString monthName( s.mid( 4, 3 ) );
+ int month = -1;
+ // Assume that English monthnames are the default
+ for ( int i = 0; i < 12; ++i ) {
+ if ( monthName == qt_shortMonthNames[i] ) {
+ month = i + 1;
+ break;
+ }
+ }
+ // If English names can't be found, search the localized ones
+ if ( month == -1 ) {
+ for ( int i = 1; i <= 12; ++i ) {
+ if ( monthName == QDate::shortMonthName( i ) ) {
+ month = i;
+ break;
+ }
+ }
+ }
+#if defined(QT_CHECK_RANGE)
+ if ( month < 1 || month > 12 ) {
+ qWarning( "QDateTime::fromString: Parameter out of range." );
+ month = 1;
+ }
+#endif
+ int day = s.mid( 8, 2 ).simplifyWhiteSpace().toInt();
+ int year = s.right( 4 ).toInt();
+ QDate date( year, month, day );
+ QTime time;
+ int hour, minute, second;
+ int pivot = s.find( QRegExp("[0-9][0-9]:[0-9][0-9]:[0-9][0-9]") );
+ if ( pivot != -1 ) {
+ hour = s.mid( pivot, 2 ).toInt();
+ minute = s.mid( pivot+3, 2 ).toInt();
+ second = s.mid( pivot+6, 2 ).toInt();
+ time.setHMS( hour, minute, second );
+ }
+ return QDateTime( date, time );
+ }
+#endif //QT_NO_REGEXP
+ return QDateTime();
+}
+#endif //QT_NO_DATESTRING
+
+
+/*****************************************************************************
+ Date/time stream functions
+ *****************************************************************************/
+
+#ifndef QT_NO_DATASTREAM
+/*!
+ \relates QDate
+
+ Writes the date, \a d, to the data stream, \a s.
+
+ \sa \link datastreamformat.html Format of the QDataStream operators \endlink
+*/
+
+QDataStream &operator<<( QDataStream &s, const QDate &d )
+{
+ return s << (Q_UINT32)(d.jd);
+}
+
+/*!
+ \relates QDate
+
+ Reads a date from the stream \a s into \a d.
+
+ \sa \link datastreamformat.html Format of the QDataStream operators \endlink
+*/
+
+QDataStream &operator>>( QDataStream &s, QDate &d )
+{
+ Q_UINT32 jd;
+ s >> jd;
+ d.jd = jd;
+ return s;
+}
+
+/*!
+ \relates QTime
+
+ Writes time \a t to the stream \a s.
+
+ \sa \link datastreamformat.html Format of the QDataStream operators \endlink
+*/
+
+QDataStream &operator<<( QDataStream &s, const QTime &t )
+{
+ return s << (Q_UINT32)(t.ds);
+}
+
+/*!
+ \relates QTime
+
+ Reads a time from the stream \a s into \a t.
+
+ \sa \link datastreamformat.html Format of the QDataStream operators \endlink
+*/
+
+QDataStream &operator>>( QDataStream &s, QTime &t )
+{
+ Q_UINT32 ds;
+ s >> ds;
+ t.ds = ds;
+ return s;
+}
+
+/*!
+ \relates QDateTime
+
+ Writes the datetime \a dt to the stream \a s.
+
+ \sa \link datastreamformat.html Format of the QDataStream operators \endlink
+*/
+
+QDataStream &operator<<( QDataStream &s, const QDateTime &dt )
+{
+ return s << dt.d << dt.t;
+}
+
+/*!
+ \relates QDateTime
+
+ Reads a datetime from the stream \a s into \a dt.
+
+ \sa \link datastreamformat.html Format of the QDataStream operators \endlink
+*/
+
+QDataStream &operator>>( QDataStream &s, QDateTime &dt )
+{
+ s >> dt.d >> dt.t;
+ return s;
+}
+#endif //QT_NO_DATASTREAM