qdatetime.cpp

Go to the documentation of this file.

/****************************************************************************
** $Id: qdatetime.cpp,v 1.2 2003/07/10 02:40:11 llornkcor Exp $
**
** Implementation of date and time classes
**
** Created : 940124
**
** Copyright (C) 1992-2002 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.
**
**********************************************************************/

#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
 *****************************************************************************/

QDate::QDate( int y, int m, int d )
{
    jd = 0;
    setYMD( y, m, d );
}


bool QDate::isValid() const
{
    return jd >= FIRST_DAY;
}


int QDate::year() const
{
    int y, m, d;
    julianToGregorian( jd, y, m, d );
    return y;
}

int QDate::month() const
{
    int y, m, d;
    julianToGregorian( jd, y, m, d );
    return m;
}

int QDate::day() const
{
    int y, m, d;
    julianToGregorian( jd, y, m, d );
    return d;
}

int QDate::dayOfWeek() const
{
    return ( jd % 7 ) + 1;
}

int QDate::dayOfYear() const
{
    return jd - gregorianToJulian(year(), 1, 1) + 1;
}

int QDate::daysInMonth() const
{
    int y, m, d;
    julianToGregorian( jd, y, m, d );
    if ( m == 2 && leapYear(y) )
        return 29;
    else
        return monthDays[m];
}

int QDate::daysInYear() const
{
    int y, m, d;
    julianToGregorian( jd, y, m, d );
    return leapYear( y ) ? 366 : 365;
}

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;
}

#ifndef QT_NO_TEXTDATE

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;
}

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;
}

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;
}

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)

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

QString QDate::toString( const QString& format ) const
{
    return fmtDateTime( format, 0, this );
}
#endif //QT_NO_DATESTRING

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;
}

QDate QDate::addDays( int ndays ) const
{
    QDate d;
    d.jd = jd + ndays;
    return d;
}

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;

}

QDate QDate::addYears( int nyears ) const
{
    int y, m, d;
    julianToGregorian( jd, y, m, d );
    y += nyears;

    QDate tmp(y,m,1);
    
    if( d > tmp.daysInMonth() )
        d = tmp.daysInMonth();

    QDate date(y, m, d);
    return date;
}



int QDate::daysTo( const QDate &d ) const
{
    return d.jd - jd;
}


QDate QDate::currentDate()
{
    return currentDate( Qt::LocalTime );
}

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
    // posix compliant system
    time_t ltime;
    time( &ltime );
    tm *t;

#  if defined(QT_THREAD_SUPPORT) && defined(_POSIX_THREAD_SAFE_FUNCTIONS)
    // use the reentrant versions of localtime() and gmtime() where available
    tm res;
    if ( ts == Qt::LocalTime )
        t = localtime_r( &ltime, &res );
    else
        t = gmtime_r( &ltime, &res );
#  else
    if ( ts == Qt::LocalTime )
        t = localtime( &ltime );
    else
        t = gmtime( &ltime );
#  endif // QT_THREAD_SUPPORT && _POSIX_THREAD_SAFE_FUNCTIONS

    d.jd = gregorianToJulian( t->tm_year + 1900, t->tm_mon + 1, t->tm_mday );
#endif
    return d;
}

#ifndef QT_NO_DATESTRING

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

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)));
}

bool QDate::leapYear( int y )
{
    return y % 4 == 0 && y % 100 != 0 || y % 400 == 0;
}

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;
}

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
 *****************************************************************************/

QTime::QTime( int h, int m, int s, int ms )
{
    setHMS( h, m, s, ms );
}


bool QTime::isValid() const
{
    return ds < MSECS_PER_DAY;
}


int QTime::hour() const
{
    return ds / MSECS_PER_HOUR;
}

int QTime::minute() const
{
    return (ds % MSECS_PER_HOUR)/MSECS_PER_MIN;
}

int QTime::second() const
{
    return (ds / 1000)%SECS_PER_MIN;
}

int QTime::msec() const
{
    return ds % 1000;
}

#ifndef QT_NO_DATESTRING
#ifndef QT_NO_SPRINTF

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

QString QTime::toString( const QString& format ) const
{
    return fmtDateTime( format, this, 0 );
}
#endif //QT_NO_DATESTRING

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;
}

QTime QTime::addSecs( int nsecs ) const
{
    return addMSecs( nsecs * 1000 );
}

int QTime::secsTo( const QTime &t ) const
{
    return ((int)t.ds - (int)ds)/1000;
}

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;
}

int QTime::msecsTo( const QTime &t ) const
{
    return (int)t.ds - (int)ds;
}


QTime QTime::currentTime()
{
    return currentTime( Qt::LocalTime );
}

QTime QTime::currentTime( Qt::TimeSpec ts )
{
    QTime t;
    currentTime( &t, ts );
    return t;
}

#ifndef QT_NO_DATESTRING

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

bool QTime::currentTime( QTime *ct )
{
    return currentTime( ct, Qt::LocalTime );
}


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)
    // posix compliant system
    struct timeval tv;
    gettimeofday( &tv, 0 );
    time_t ltime = tv.tv_sec;
    tm *t;

#  if defined(QT_THREAD_SUPPORT) && defined(_POSIX_THREAD_SAFE_FUNCTIONS)
    // use the reentrant versions of localtime() and gmtime() where available
    tm res;
    if ( ts == Qt::LocalTime )
        t = localtime_r( &ltime, &res );
    else
        t = gmtime_r( &ltime, &res );
#  else
    if ( ts == Qt::LocalTime )
        t = localtime( &ltime );
    else
        t = gmtime( &ltime );
#  endif // QT_THREAD_SUPPORT && _POSIX_THREAD_SAFE_FUNCTIONS

    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;
}

bool QTime::isValid( int h, int m, int s, int ms )
{
    return (uint)h < 24 && (uint)m < 60 && (uint)s < 60 && (uint)ms < 1000;
}


void QTime::start()
{
    *this = currentTime();
}

int QTime::restart()
{
    QTime t = currentTime();
    int n = msecsTo( t );
    if ( n < 0 )                                // passed midnight
        n += 86400*1000;
    *this = t;
    return n;
}

int QTime::elapsed() const
{
    int n = msecsTo( currentTime() );
    if ( n < 0 )                                // passed midnight
        n += 86400*1000;
    return n;
}


/*****************************************************************************
  QDateTime member functions
 *****************************************************************************/

QDateTime::QDateTime( const QDate &date )
    : d(date)
{
}

QDateTime::QDateTime( const QDate &date, const QTime &time )
    : d(date), t(time)
{
}


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;
}

void QDateTime::setTime_t( uint secsSince1Jan1970UTC )
{
    setTime_t( secsSince1Jan1970UTC, Qt::LocalTime );
}

void QDateTime::setTime_t( uint secsSince1Jan1970UTC, Qt::TimeSpec ts )
{
    time_t tmp = (time_t) secsSince1Jan1970UTC;
    tm *brokenDown = 0;

#if defined(Q_OS_UNIX) && defined(QT_THREAD_SUPPORT) && defined(_POSIX_THREAD_SAFE_FUNCTIONS)
    // posix compliant system
    // use the reentrant versions of localtime() and gmtime() where available
    tm res;
    if ( ts == Qt::LocalTime )
        brokenDown = localtime_r( &tmp, &res );
    if ( !brokenDown ) {
        brokenDown = gmtime_r( &tmp, &res );
        if ( !brokenDown ) {
            d.jd = QDate::gregorianToJulian( 1970, 1, 1 );
            t.ds = 0;
            return;
        }
    }
#else
    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;
        }
    }
#endif

    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

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

QString QDateTime::toString( const QString& format ) const
{
    return fmtDateTime( format, &t, &d );
}
#endif //QT_NO_DATESTRING

QDateTime QDateTime::addDays( int ndays ) const
{
    return QDateTime( d.addDays(ndays), t );
}

QDateTime QDateTime::addMonths( int nmonths ) const
{
    return QDateTime( d.addMonths(nmonths), t );
}

QDateTime QDateTime::addYears( int nyears ) const
{
    return QDateTime( d.addYears(nyears), t );
}

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;
}

int QDateTime::daysTo( const QDateTime &dt ) const
{
    return d.daysTo( dt.d );
}

int QDateTime::secsTo( const QDateTime &dt ) const
{
    return t.secsTo(dt.t) + d.daysTo(dt.d)*SECS_PER_DAY;
}


bool QDateTime::operator==( const QDateTime &dt ) const
{
    return  t == dt.t && d == dt.d;
}

bool QDateTime::operator!=( const QDateTime &dt ) const
{
    return  t != dt.t || d != dt.d;
}

bool QDateTime::operator<( const QDateTime &dt ) const
{
    if ( d < dt.d )
        return TRUE;
    return d == dt.d ? t < dt.t : FALSE;
}

bool QDateTime::operator<=( const QDateTime &dt ) const
{
    if ( d < dt.d )
        return TRUE;
    return d == dt.d ? t <= dt.t : FALSE;
}

bool QDateTime::operator>( const QDateTime &dt ) const
{
    if ( d > dt.d )
        return TRUE;
    return d == dt.d ? t > dt.t : FALSE;
}

bool QDateTime::operator>=( const QDateTime &dt ) const
{
    if ( d > dt.d )
        return TRUE;
    return d == dt.d ? t >= dt.t : FALSE;
}

QDateTime QDateTime::currentDateTime()
{
    return currentDateTime( Qt::LocalTime );
}

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

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

QDataStream &operator<<( QDataStream &s, const QDate &d )
{
    return s << (Q_UINT32)(d.jd);
}

QDataStream &operator>>( QDataStream &s, QDate &d )
{
    Q_UINT32 jd;
    s >> jd;
    d.jd = jd;
    return s;
}

QDataStream &operator<<( QDataStream &s, const QTime &t )
{
    return s << (Q_UINT32)(t.ds);
}

QDataStream &operator>>( QDataStream &s, QTime &t )
{
    Q_UINT32 ds;
    s >> ds;
    t.ds = ds;
    return s;
}

QDataStream &operator<<( QDataStream &s, const QDateTime &dt )
{
    return s << dt.d << dt.t;
}

QDataStream &operator>>( QDataStream &s, QDateTime &dt )
{
    s >> dt.d >> dt.t;
    return s;
}
#endif //QT_NO_DATASTREAM

---