1 /****************************************************************************

     2 ** 

     3 **

     4 ** Implementation of date and time classes

     5 **

     6 ** Created : 940124

     7 **

     8 ** Copyright (C) 1992-2000 Trolltech AS.  All rights reserved.

     9 **

    10 ** This file is part of the tools module of the Qt GUI Toolkit.

    11 **

    12 ** This file may be distributed under the terms of the Q Public License

    13 ** as defined by Trolltech AS of Norway and appearing in the file

    14 ** LICENSE.QPL included in the packaging of this file.

    15 **

    16 ** This file may be distributed and/or modified under the terms of the

    17 ** GNU General Public License version 2 as published by the Free Software

    18 ** Foundation and appearing in the file LICENSE.GPL included in the

    19 ** packaging of this file.

    20 **

    21 ** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition

    22 ** licenses may use this file in accordance with the Qt Commercial License

    23 ** Agreement provided with the Software.

    24 **

    25 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE

    26 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.

    27 **

    28 ** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for

    29 **   information about Qt Commercial License Agreements.

    30 ** See http://www.trolltech.com/qpl/ for QPL licensing information.

    31 ** See http://www.trolltech.com/gpl/ for GPL licensing information.

    32 **

    33 ** Contact info@trolltech.com if any conditions of this licensing are

    34 ** not clear to you.

    35 **

    36 **********************************************************************/

    37 

    38 #define gettimeofday	__hide_gettimeofday

    39 #include "qdatetime.h"

    40 #include "qdatastream.h"

    41 #include <stdio.h>

    42 #include <time.h>

    43 #if defined(_OS_WIN32_)

    44 #if defined(_CC_BOOL_DEF_)

    45 #undef	bool

    46 #include <windows.h>

    47 #define bool int

    48 #else

    49 #include <windows.h>

    50 #endif

    51 #elif defined(_OS_MSDOS_)

    52 #include <dos.h>

    53 #elif defined(_OS_OS2_)

    54 #include <os2.h>

    55 #elif defined(_OS_UNIX_)

    56 #include <sys/time.h>

    57 #include <unistd.h>

    58 #undef	gettimeofday

    59 extern "C" int gettimeofday( struct timeval *, struct timezone * );

    60 #endif

    61 

    62 static const uint FIRST_DAY	= 2361222;	// Julian day for 1752/09/14

    63 static const int  FIRST_YEAR	= 1752;		// ### wrong for many countries

    64 static const uint SECS_PER_DAY	= 86400;

    65 static const uint MSECS_PER_DAY = 86400000;

    66 static const uint SECS_PER_HOUR = 3600;

    67 static const uint MSECS_PER_HOUR= 3600000;

    68 static const uint SECS_PER_MIN	= 60;

    69 static const uint MSECS_PER_MIN = 60000;

    70 

    71 static const short monthDays[] ={0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};

    72 

    73 // ##### Localize.

    74 

    75 const char * const QDate::monthNames[] = {

    76     "Jan", "Feb", "Mar", "Apr", "May", "Jun",

    77     "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };

    78 

    79 const char * const QDate::weekdayNames[] ={

    80     "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun" };

    81 

    82 

    83 /*****************************************************************************

    84   QDate member functions

    85  *****************************************************************************/

    86 

    87 // REVISED: aavit

    88 

    89 /*!

    90   \class QDate qdatetime.h

    91   \brief The QDate class provides date functions.

    92 

    93   \ingroup time

    94 

    95   A QDate object contains a calendar date, i.e. year, month, and day

    96   numbers in the modern western (Gregorian) calendar. It can read the

    97   current date from the system clock. It provides functions for

    98   comparing dates and for manipulating a date by adding a number of

    99   days.

   100 

   101   A QDate object is typically created either by giving the year, month

   102   and day numbers explicitly, or by using the static function

   103   currentDate(), which makes a QDate object which contains the

   104   system's clock date. An explicit date can also be set using

   105   setYMD().

   106 

   107   The year(), month(), and day() functions provide access to the year,

   108   month, and day numbers. Also, dayOfWeek() and dayOfYear() functions

   109   are provided. The same information is provided in textual format by

   110   the toString(), dayName(), and monthName() functions.

   111 

   112   QDate provides a full set of operators to compare two QDate

   113   objects. A date is considered smaller than another if it is earlier

   114   than the other.

   115 

   116   The date a given number of days later than a given date can be found

   117   using the addDays() function. Correspondingly, the number of days

   118   between two dates can be found using the daysTo() function.

   119 

   120   The daysInMonth() and daysInYear() functions tell how many days

   121   there are in this date's month and year, respectively. The

   122   isLeapYear() function tells whether this date is in a leap year.

   123 

   124   Note that QDate may not be used for date calculations for dates in

   125   the remote past, i.e. prior to the introduction of the Gregorian

   126   calendar. This calendar was adopted by England Sep. 14. 1752 (hence

   127   this is the earliest valid QDate), and subsequently by most other

   128   western countries, until 1923.

   129 

   130   The end of time is reached around 8000AD, by which time we expect Qt

   131   to be obsolete.

   132 

   133   \sa QTime, QDateTime

   134 */

   135 

   136 

   137 /*!

   138   \fn QDate::QDate()

   139   Constructs a null date. Null dates are invalid.

   140 

   141   \sa isNull(), isValid()

   142 */

   143 

   144 

   145 /*!

   146   Constructs a date with the year \a y, month \a m and day \a d.

   147 

   148   \a y must be in the range 1752-ca. 8000, \a m must be in the range

   149   1-12, and \a d must be in the range 1-31. Exception: if \a y is in

   150   the range 0-99, it is interpreted as 1900-1999.

   151 

   152   \sa isValid()

   153 */

   154 

   155 QDate::QDate( int y, int m, int d )

   156 {

   157     jd = 0;

   158     setYMD( y, m, d );

   159 }

   160 

   161 

   162 /*!

   163   \fn bool QDate::isNull() const

   164 

   165   Returns TRUE if the date is null.  A null date is invalid.

   166 

   167   \sa isValid()

   168 */

   169 

   170 

   171 /*!

   172   Returns TRUE if this date is valid.

   173 

   174   \sa isNull()

   175 */

   176 

   177 bool QDate::isValid() const

   178 {

   179     return jd >= FIRST_DAY;

   180 }

   181 

   182 

   183 /*!

   184   Returns the year (>= 1752) of this date.

   185 

   186   \sa month(), day()

   187 */

   188 

   189 int QDate::year() const

   190 {

   191     int y, m, d;

   192     jul2greg( jd, y, m, d );

   193     return y;

   194 }

   195 

   196 /*!

   197   Returns the month (January=1 .. December=12) of this date.

   198 

   199   \sa year(), day()

   200 */

   201 

   202 int QDate::month() const

   203 {

   204     int y, m, d;

   205     jul2greg( jd, y, m, d );

   206     return m;

   207 }

   208 

   209 /*!

   210   Returns the day of the month (1..31) of this date.

   211 

   212   \sa year(), month(), dayOfWeek()

   213 */

   214 

   215 int QDate::day() const

   216 {

   217     int y, m, d;

   218     jul2greg( jd, y, m, d );

   219     return d;

   220 }

   221 

   222 /*!

   223   Returns the weekday (Monday=1 .. Sunday=7) for this date.

   224 

   225   \sa day(), dayOfYear()

   226 */

   227 

   228 int QDate::dayOfWeek() const

   229 {

   230     return (((jd+1) % 7) + 6)%7 + 1;

   231 }

   232 

   233 /*!

   234   Returns the day of the year (1..365) for this date.

   235 

   236   \sa day(), dayOfWeek()

   237 */

   238 

   239 int QDate::dayOfYear() const

   240 {

   241     return jd - greg2jul(year(), 1, 1) + 1;

   242 }

   243 

   244 /*!

   245   Returns the number of days in the month (28..31) for this date.

   246 

   247   \sa day(), daysInYear()

   248 */

   249 

   250 int QDate::daysInMonth() const

   251 {

   252     int y, m, d;

   253     jul2greg( jd, y, m, d );

   254     if ( m == 2 && leapYear(y) )

   255 	return 29;

   256     else

   257 	return monthDays[m];

   258 }

   259 

   260 /*!

   261   Returns the number of days in the year (365 or 366) for this date.

   262 

   263   \sa day(), daysInMonth()

   264 */

   265 

   266 int QDate::daysInYear() const

   267 {

   268     int y, m, d;

   269     jul2greg( jd, y, m, d );

   270     return leapYear(y) ? 366 : 365;

   271 }

   272 

   273 

   274 /*!

   275   Returns the name of the \a month.

   276 

   277   Month 1 == "Jan", month 2 == "Feb" etc.

   278 

   279   \sa toString(), dayName()

   280 */

   281 

   282 QString QDate::monthName( int month ) const

   283 {

   284 #if defined(CHECK_RANGE)

   285     if ( month < 1 || month > 12 ) {

   286 	qWarning( "QDate::monthName: Parameter out ouf range." );

   287 	month = 1;

   288     }

   289 #endif

   290     // ### Remove the fromLatin1 during localization

   291     return QString::fromLatin1(monthNames[month-1]);

   292 }

   293 

   294 /*!

   295   Returns the name of the \a weekday.

   296 

   297   Weekday 1 == "Mon", day 2 == "Tue" etc.

   298 

   299   \sa toString(), monthName()

   300 */

   301 

   302 QString QDate::dayName( int weekday ) const

   303 {

   304 #if defined(CHECK_RANGE)

   305     if ( weekday < 1 || weekday > 7 ) {

   306 	qWarning( "QDate::dayName: Parameter out of range." );

   307 	weekday = 1;

   308     }

   309 #endif

   310     // ### Remove the fromLatin1 during localization

   311     return QString::fromLatin1(weekdayNames[weekday-1]);

   312 }

   313 

   314 

   315 /*!

   316   Returns the date as a string.

   317 

   318   The string format is "Sat May 20 1995". This function uses the

   319   dayName() and monthName() functions to generate the string.

   320 

   321   \sa dayName(), monthName()

   322 */

   323 

   324 QString QDate::toString() const

   325 {

   326     int y, m, d;

   327     jul2greg( jd, y, m, d );

   328     QString buf = dayName(dayOfWeek());

   329     buf += ' ';

   330     buf += monthName(m);

   331     QString t;

   332     t.sprintf( " %d %d", d, y);

   333     buf += t;

   334     return buf;

   335 }

   336 

   337 

   338 /*!

   339   Sets the year \a y, month \a m and day \a d.

   340 

   341   \a y must be in the range 1752-ca. 8000, \a m must be in the range

   342   1-12, and \a d must be in the range 1-31. Exception: if \a y is in

   343   the range 0-99, it is interpreted as 1900-1999.

   344 

   345   Returns TRUE if the date is valid, otherwise FALSE.

   346 */

   347 

   348 bool QDate::setYMD( int y, int m, int d )

   349 {

   350     if ( !isValid(y,m,d) ) {

   351 #if defined(CHECK_RANGE)

   352 	 qWarning( "QDate::setYMD: Invalid date %04d/%02d/%02d", y, m, d );

   353 #endif

   354 	 return FALSE;

   355     }

   356     jd = greg2jul( y, m, d );

   357 #if defined(DEBUG)

   358     ASSERT( year() == (y > 99 ? y : 1900+y) && month() == m && day() == d );

   359 #endif

   360     return TRUE;

   361 }

   362 

   363 /*!

   364   Returns a QDate object containing a date \a ndays later than the

   365   date of this object (or earlier if \a ndays is negative).

   366 

   367   \sa daysTo()

   368 */

   369 

   370 QDate QDate::addDays( int ndays ) const

   371 {

   372     QDate d;

   373     d.jd = jd + ndays;

   374     return d;

   375 }

   376 

   377 /*!

   378   Returns the number of days from this date to \a d (which is negative

   379   if \a d is earlier than this date).

   380 

   381   Example:

   382   \code

   383     QDate d1( 1995, 5, 17 );		// May 17th 1995

   384     QDate d2( 1995, 5, 20 );		// May 20th 1995

   385     d1.daysTo( d2 );			// returns 3

   386     d2.daysTo( d1 );			// returns -3

   387   \endcode

   388 

   389   \sa addDays()

   390 */

   391 

   392 int QDate::daysTo( const QDate &d ) const

   393 {

   394     return d.jd - jd;

   395 }

   396 

   397 

   398 /*!

   399   \fn bool QDate::operator==( const QDate &d ) const

   400   Returns TRUE if this date is equal to \a d, or FALSE if

   401   they are different.

   402 */

   403 

   404 /*!

   405   \fn bool QDate::operator!=( const QDate &d ) const

   406   Returns TRUE if this date is different from \a d, or FALSE if

   407   they are equal.

   408 */

   409 

   410 /*!

   411   \fn bool QDate::operator<( const QDate &d ) const

   412   Returns TRUE if this date is earlier than \a d, otherwise FALSE.

   413 */

   414 

   415 /*!

   416   \fn bool QDate::operator<=( const QDate &d ) const

   417   Returns TRUE if this date is earlier than or equal to \a d, otherwise FALSE.

   418 */

   419 

   420 /*!

   421   \fn bool QDate::operator>( const QDate &d ) const

   422   Returns TRUE if this date is later than \a d, otherwise FALSE.

   423 */

   424 

   425 /*!

   426   \fn bool QDate::operator>=( const QDate &d ) const

   427   Returns TRUE if this date is later than or equal to \a d, otherwise FALSE.

   428 */

   429 

   430 

   431 /*!

   432   Returns the current date, as reported by the system clock.

   433 

   434   \sa QTime::currentTime(), QDateTime::currentDateTime()

   435 */

   436 

   437 QDate QDate::currentDate()

   438 {

   439 #if defined(_OS_WIN32_)

   440 

   441     SYSTEMTIME t;

   442     GetLocalTime( &t );

   443     QDate d;

   444     d.jd = greg2jul( t.wYear, t.wMonth, t.wDay );

   445     return d;

   446 

   447 #else

   448 

   449     time_t ltime;

   450     time( &ltime );

   451     tm *t = localtime( &ltime );

   452     QDate d;

   453     d.jd = greg2jul( t->tm_year + 1900, t->tm_mon + 1, t->tm_mday );

   454     return d;

   455 

   456 #endif

   457 }

   458 

   459 /*!

   460   Returns TRUE if the specified date (year \a y, month \a m and day \a

   461   d) is valid.

   462 

   463   Example:

   464   \code

   465     QDate::isValid( 2002, 5, 17 );	// TRUE;  May 17th 2002 is OK.

   466     QDate::isValid( 2002, 2, 30 );	// FALSE; Feb 30th does not exist

   467     QDate::isValid( 2004, 2, 29 );	// TRUE; 2004 is a leap year

   468     QDate::isValid( 1202, 6, 6 );	// FALSE; 1202 is pre-Gregorian

   469   \endcode

   470 

   471   Note that a \a y value in the range 00-99 is interpreted as

   472   1900-1999.

   473 

   474   \sa isNull(), setYMD()

   475 */

   476 

   477 bool QDate::isValid( int y, int m, int d )

   478 {

   479     if ( y >= 0 && y <= 99 )

   480 	y += 1900;

   481     else if ( y < FIRST_YEAR || (y == FIRST_YEAR && (m < 9 ||

   482 						    (m == 9 && d < 14))) )

   483 	return FALSE;

   484     return (d > 0 && m > 0 && m <= 12) &&

   485 	   (d <= monthDays[m] || (d == 29 && m == 2 && leapYear(y)));

   486 }

   487 

   488 /*!

   489   Returns TRUE if the specified year \a y is a leap year.

   490 */

   491 

   492 bool QDate::leapYear( int y )

   493 {

   494     return y % 4 == 0 && y % 100 != 0 || y % 400 == 0;

   495 }

   496 

   497 /*!

   498   \internal

   499   Converts a Gregorian date to a Julian day.

   500   This algorithm is taken from Communications of the ACM, Vol 6, No 8.

   501   \sa jul2greg()

   502 */

   503 

   504 uint QDate::greg2jul( int y, int m, int d )

   505 {

   506     uint c, ya;

   507     if ( y <= 99 )

   508 	y += 1900;

   509     if ( m > 2 ) {

   510 	m -= 3;

   511     } else {

   512 	m += 9;

   513 	y--;

   514     }

   515     c = y;					// NOTE: Sym C++ 6.0 bug

   516     c /= 100;

   517     ya = y - 100*c;

   518     return 1721119 + d + (146097*c)/4 + (1461*ya)/4 + (153*m+2)/5;

   519 }

   520 

   521 /*!

   522   \internal

   523   Converts a Julian day to a Gregorian date.

   524   This algorithm is taken from Communications of the ACM, Vol 6, No 8.

   525   \sa greg2jul()

   526 */

   527 

   528 void QDate::jul2greg( uint jd, int &y, int &m, int &d )

   529 {

   530     uint x;

   531     uint j = jd - 1721119;

   532     y = (j*4 - 1)/146097;

   533     j = j*4 - 146097*y - 1;

   534     x = j/4;

   535     j = (x*4 + 3) / 1461;

   536     y = 100*y + j;

   537     x = (x*4) + 3 - 1461*j;

   538     x = (x + 4)/4;

   539     m = (5*x - 3)/153;

   540     x = 5*x - 3 - 153*m;

   541     d = (x + 5)/5;

   542     if ( m < 10 ) {

   543 	m += 3;

   544     } else {

   545 	m -= 9;

   546 	y++;

   547     }

   548 }

   549 

   550 

   551 /*****************************************************************************

   552   QTime member functions

   553  *****************************************************************************/

   554 

   555 /*!

   556   \class QTime qdatetime.h

   557 

   558   \brief The QTime class provides clock time functions.

   559 

   560   \ingroup time

   561 

   562   A QTime object contains a clock time, i.e. a number of hours,

   563   minutes, seconds and milliseconds since midnight. It can read the

   564   current time from the system clock, and measure a span of elapsed

   565   time. It provides functions for comparing times and for manipulating

   566   a time by adding a number of (milli)seconds.

   567 

   568   QTime operates with 24-hour clock format; it has no concept of

   569   AM/PM. It operates with local time; it does not know anything about

   570   time zones or daylight savings time.

   571 

   572   A QTime object is typically created either by giving the number of

   573   hours, minutes, seconds, and milliseconds explicitly, or by using

   574   the static function currentTime(), which makes a QTime object which

   575   contains the system's clock time. Note that the accuracy depends on

   576   the accuracy of the underlying operating system; not all systems

   577   provide 1-millisecond accuracy.

   578 

   579   The hour(), minute(), second(), and msec() functions provide access

   580   to the number of hours, minutes, seconds, and milliseconds of the

   581   time. The same information is provided in textual format by the

   582   toString() function.

   583 

   584   QTime provides a full set of operators to compare two QTime

   585   objects. A time is considered smaller than another if it is earlier

   586   than the other.

   587 

   588   The time a given number of seconds or milliseconds later than a

   589   given time can be found using the addSecs() or addMSecs()

   590   functions. Correspondingly, the number of (milli)seconds between two

   591   times can be found using the secsTo() or msecsTo() functions.

   592 

   593   QTime can be used to measure a span of elapsed time using the

   594   start(), restart(), and elapsed() functions.

   595 

   596   \sa QDate, QDateTime

   597 */

   598 

   599 /*!

   600   \fn QTime::QTime()

   601 

   602   Constructs the time 0 hours, minutes, seconds and milliseconds,

   603   i.e. 00:00:00.000 (midnight). This is a valid time.

   604 

   605   \sa isValid()

   606 */

   607 

   608 /*!

   609   Constructs a time with hour \a h, minute \a m, seconds \a s and

   610   milliseconds \a ms.

   611 

   612   \a h must be in the range 0-23, \a m and \a s must be in the range

   613   0-59, and \a ms must be in the range 0-999.

   614 

   615   \sa isValid()

   616 */

   617 

   618 QTime::QTime( int h, int m, int s, int ms )

   619 {

   620     setHMS( h, m, s, ms );

   621 }

   622 

   623 

   624 /*!

   625   \fn bool QTime::isNull() const

   626   Returns TRUE if the time is equal to 00:00:00.000. A null time is valid.

   627 

   628   \sa isValid()

   629 */

   630 

   631 /*!

   632   Returns TRUE if the time is valid, or FALSE if the time is invalid.

   633   The time 23:30:55.746 is valid, while 24:12:30 is invalid.

   634 

   635   \sa isNull()

   636 */

   637 

   638 bool QTime::isValid() const

   639 {

   640     return ds < MSECS_PER_DAY;

   641 }

   642 

   643 

   644 /*!

   645   Returns the hour part (0..23) of the time.

   646 */

   647 

   648 int QTime::hour() const

   649 {

   650     return ds / MSECS_PER_HOUR;

   651 }

   652 

   653 /*!

   654   Returns the minute part (0..59) of the time.

   655 */

   656 

   657 int QTime::minute() const

   658 {

   659     return (ds % MSECS_PER_HOUR)/MSECS_PER_MIN;

   660 }

   661 

   662 /*!

   663   Returns the second part (0..59) of the time.

   664 */

   665 

   666 int QTime::second() const

   667 {

   668     return (ds / 1000)%SECS_PER_MIN;

   669 }

   670 

   671 /*!

   672   Returns the millisecond part (0..999) of the time.

   673 */

   674 

   675 int QTime::msec() const

   676 {

   677     return ds % 1000;

   678 }

   679 

   680 

   681 /*!

   682   Returns the time of this object in a textual format. Milliseconds

   683   are not included. The string format is HH:MM:SS, e.g. 1 second

   684   before midnight would be "23:59:59".

   685 */

   686 

   687 QString QTime::toString() const

   688 {

   689     QString buf;

   690     buf.sprintf( "%.2d:%.2d:%.2d", hour(), minute(), second() );

   691     return buf;

   692 }

   693 

   694 

   695 /*!

   696   Sets the time to hour \a h, minute \a m, seconds \a s and

   697   milliseconds \a ms.

   698 

   699   \a h must be in the range 0-23, \a m and \a s must be in the range

   700   0-59, and \a ms must be in the range 0-999. Returns TRUE if the set

   701   time is valid, otherwise FALSE.

   702 

   703   \sa isValid()

   704 */

   705 

   706 bool QTime::setHMS( int h, int m, int s, int ms )

   707 {

   708     if ( !isValid(h,m,s,ms) ) {

   709 #if defined(CHECK_RANGE)

   710 	qWarning( "QTime::setHMS Invalid time %02d:%02d:%02d.%03d", h, m, s,

   711 		 ms );

   712 #endif

   713 	ds = MSECS_PER_DAY;		// make this invalid

   714 	return FALSE;

   715     }

   716     ds = (h*SECS_PER_HOUR + m*SECS_PER_MIN + s)*1000 + ms;

   717     return TRUE;

   718 }

   719 

   720 /*!

   721   Returns a QTime object containing a time \a nsecs seconds later than

   722   the time of this object (or earlier if \a ms is negative).

   723 

   724   Note that the time will wrap if it passes midnight.

   725 

   726   Example:

   727   \code

   728     QTime n( 14, 0, 0 );                // n == 14:00:00

   729     QTime t;

   730     t = n.addSecs( 70 );                // t == 14:01:10

   731     t = n.addSecs( -70 );               // t == 13:58:50

   732     t = n.addSecs( 10*60*60 + 5 );      // t == 00:00:05

   733     t = n.addSecs( -15*60*60 );         // t == 23:00:00

   734   \endcode

   735 

   736   \sa addMSecs(), secsTo(), QDateTime::addSecs()

   737 */

   738 

   739 QTime QTime::addSecs( int nsecs ) const

   740 {

   741     return addMSecs(nsecs*1000);

   742 }

   743 

   744 /*!

   745   Returns the number of seconds from this time to \a t (which is

   746   negative if \a t is earlier than this time).

   747 

   748   Since QTime measures time within a day and there are 86400 seconds

   749   in a day, the result is between -86400 and 86400.

   750 

   751   \sa addSecs() QDateTime::secsTo()

   752 */

   753 

   754 int QTime::secsTo( const QTime &t ) const

   755 {

   756     return ((int)t.ds - (int)ds)/1000;

   757 }

   758 

   759 /*!

   760   Returns a QTime object containing a time \a ms milliseconds later than

   761   the time of this object (or earlier if \a ms is negative).

   762 

   763   Note that the time will wrap if it passes midnight. See addSecs()

   764   for an example.

   765 

   766   \sa addSecs(), msecsTo()

   767 */

   768 

   769 QTime QTime::addMSecs( int ms ) const

   770 {

   771     QTime t;

   772     if ( ms < 0 ) {

   773 	// % not well-defined for -ve, but / is.

   774 	int negdays = (MSECS_PER_DAY-ms) / MSECS_PER_DAY;

   775 	t.ds = ((int)ds + ms + negdays*MSECS_PER_DAY)

   776 		% MSECS_PER_DAY;

   777     } else {

   778 	t.ds = ((int)ds + ms) % MSECS_PER_DAY;

   779     }

   780     return t;

   781 }

   782 

   783 /*!

   784   Returns the number of milliseconds from this time to \a t (which is

   785   negative if \a t is earlier than this time).

   786 

   787   Since QTime measures time within a day and there are 86400000

   788   milliseconds in a day, the result is between -86400000 and 86400000.

   789 

   790   \sa secsTo()

   791 */

   792 

   793 int QTime::msecsTo( const QTime &t ) const

   794 {

   795     return (int)t.ds - (int)ds;

   796 }

   797 

   798 

   799 /*!

   800   \fn bool QTime::operator==( const QTime &t ) const

   801 

   802   Returns TRUE if this time is equal to \a t, or FALSE if they are

   803   different.

   804 */

   805 

   806 /*!

   807   \fn bool QTime::operator!=( const QTime &t ) const

   808 

   809   Returns TRUE if this time is different from \a t, or FALSE if they

   810   are equal.

   811 */

   812 

   813 /*!

   814   \fn bool QTime::operator<( const QTime &t ) const

   815 

   816   Returns TRUE if this time is earlier than \a t, otherwise FALSE.

   817 */

   818 

   819 /*!

   820   \fn bool QTime::operator<=( const QTime &t ) const

   821 

   822   Returns TRUE if this time is earlier than or equal to \a t,

   823   otherwise FALSE.

   824 */

   825 

   826 /*!

   827   \fn bool QTime::operator>( const QTime &t ) const

   828 

   829   Returns TRUE if this time is later than \a t, otherwise FALSE.

   830 */

   831 

   832 /*!

   833   \fn bool QTime::operator>=( const QTime &t ) const

   834 

   835   Returns TRUE if this time is later than or equal to \a t, otherwise

   836   FALSE.

   837 */

   838 

   839 

   840 

   841 /*!

   842   Returns the current time, as reported by the system clock.

   843 

   844   Note that the accuracy depends on the accuracy of the underlying

   845   operating system; not all systems provide 1-millisecond accuracy.

   846 */

   847 

   848 QTime QTime::currentTime()

   849 {

   850     QTime ct;

   851     currentTime( &ct );

   852     return ct;

   853 }

   854 

   855 /*!

   856   \internal

   857 

   858   Fetches the current time and returns TRUE if the time is within one

   859   minute after midnight, otherwise FALSE. The return value is used by

   860   QDateTime::currentDateTime() to ensure that the date there is correct.

   861 */

   862 

   863 bool QTime::currentTime( QTime *ct )

   864 {

   865     if ( !ct ) {

   866 #if defined(CHECK_NULL)

   867 	qWarning( "QTime::currentTime(QTime *): Null pointer not allowed" );

   868 #endif

   869 	return FALSE;

   870     }

   871 

   872 #if defined(_OS_WIN32_)

   873 

   874     SYSTEMTIME t;

   875     GetLocalTime( &t );

   876     ct->ds = MSECS_PER_HOUR*t.wHour + MSECS_PER_MIN*t.wMinute +

   877 	     1000*t.wSecond + t.wMilliseconds;

   878     return (t.wHour == 0 && t.wMinute == 0);

   879 

   880 #elif defined(_OS_OS2_)

   881 

   882     DATETIME t;

   883     DosGetDateTime( &t );

   884     ct->ds = MSECS_PER_HOUR*t.hours + MSECS_PER_MIN*t.minutes +

   885 	     1000*t.seconds + 10*t.hundredths;

   886     return (t.hours == 0 && t.minutes == 0);

   887 

   888 #elif defined(_OS_MSDOS_)

   889 

   890     _dostime_t t;

   891     _dos_gettime( &t );

   892     ct->ds = MSECS_PER_HOUR*t.hour + MSECS_PER_MIN*t.minute +

   893 	     t.second*1000 + t.hsecond*10;

   894     return (t.hour== 0 && t.minute == 0);

   895 

   896 #elif defined(_OS_UNIX_)

   897 

   898     struct timeval tv;

   899     gettimeofday( &tv, 0 );

   900     time_t ltime = tv.tv_sec;

   901     tm *t = localtime( &ltime );

   902     ct->ds = (uint)( MSECS_PER_HOUR*t->tm_hour + MSECS_PER_MIN*t->tm_min +

   903 		     1000*t->tm_sec + tv.tv_usec/1000 );

   904     return (t->tm_hour== 0 && t->tm_min == 0);

   905 

   906 #else

   907 

   908     time_t ltime;			// no millisecond resolution!!

   909     ::time( &ltime );

   910     tm *t = localtime( &ltime );

   911     ct->ds = MSECS_PER_HOUR*t->tm_hour + MSECS_PER_MIN*t->tm_min +

   912 	     1000*t->tm_sec;

   913     return (t->tm_hour== 0 && t->tm_min == 0);

   914 #endif

   915 }

   916 

   917 /*!

   918   Returns TRUE if the specified time is valid, otherwise FALSE.

   919 

   920   The time is valid if \a h is in the range 0-23, \a m and \a s are in

   921   the range 0-59, and \a ms is in the range 0-999.

   922 

   923   Example:

   924   \code

   925     QTime::isValid(21, 10, 30);		// returns TRUE

   926     QTime::isValid(22, 5,  62);		// returns FALSE

   927   \endcode

   928 */

   929 

   930 bool QTime::isValid( int h, int m, int s, int ms )

   931 {

   932     return (uint)h < 24 && (uint)m < 60 && (uint)s < 60 && (uint)ms < 1000;

   933 }

   934 

   935 

   936 /*!

   937   Sets this time to the current time. This is practical for timing:

   938 

   939   \code

   940     QTime t;

   941     t.start();				// start clock

   942     ... // some lengthy task

   943     qDebug( "%d\n", t.elapsed() );	// prints # msecs elapsed

   944   \endcode

   945 

   946   \sa restart(), elapsed(), currentTime()

   947 */

   948 

   949 void QTime::start()

   950 {

   951     *this = currentTime();

   952 }

   953 

   954 /*!

   955   Sets this time to the current time, and returns the number of

   956   milliseconds that have elapsed since the last time start() or

   957   restart() was called.

   958 

   959   This function is guaranteed to be atomic, and is thus very handy for

   960   repeated measurements: call start() to start the first measurement,

   961   then restart() for each later measurement.

   962 

   963   Note that the counter wraps to zero 24 hours after the last call to

   964   start() or restart().

   965 

   966   \warning If the system's clock setting has been changed since the

   967   last time start() or restart() was called, the result is undefined.

   968   This can happen e.g. when daylight saving is turned on or off.

   969 

   970   \sa start(), elapsed(), currentTime()

   971 */

   972 

   973 int QTime::restart()

   974 {

   975     QTime t = currentTime();

   976     int n = msecsTo( t );

   977     if ( n < 0 )				// passed midnight

   978 	n += 86400*1000;

   979     *this = t;

   980     return n;

   981 }

   982 

   983 /*!

   984   Returns the number of milliseconds that have elapsed since the last

   985   time start() or restart() was called.

   986 

   987   Note that the counter wraps to zero 24 hours after the last call to

   988   start() or restart.

   989 

   990   Note that the accuracy depends on the accuracy of the underlying

   991   operating system; not all systems provide 1-millisecond accuracy.

   992 

   993   \warning If the system's clock setting has been changed since the

   994   last time start() or restart() was called, the result is undefined.

   995   This can happen e.g. when daylight saving is turned on or off.

   996 

   997   \sa start(), restart()

   998 */

   999 

  1000 int QTime::elapsed()

  1001 {

  1002     int n = msecsTo( currentTime() );

  1003     if ( n < 0 )				// passed midnight

  1004 	n += 86400*1000;

  1005     return n;

  1006 }

  1007 

  1008 

  1009 /*****************************************************************************

  1010   QDateTime member functions

  1011  *****************************************************************************/

  1012 

  1013 /*!

  1014   \class QDateTime qdatetime.h

  1015   \brief The QDateTime class provides date and time functions.

  1016 

  1017   \ingroup time

  1018 

  1019   A QDateTime object contains a calendar date and a clock time (a

  1020   "datetime"). It is a combination of the QDate and QTime classes. It

  1021   can read the current datetime from the system clock. It provides

  1022   functions for comparing datetimes and for manipulating a datetime by

  1023   adding a number of seconds or days.

  1024 

  1025   A QDateTime object is typically created either by giving a date and

  1026   time explicitly, or by using the static function currentTime(),

  1027   which makes a QDateTime object which contains the system's clock

  1028   time.

  1029 

  1030   The date() and time() functions provide access to the date and time

  1031   parts of the datetime. The same information is provided in textual

  1032   format by the toString() function.

  1033 

  1034   QDateTime provides a full set of operators to compare two QDateTime

  1035   objects. A datetime is considered smaller than another if it is

  1036   earlier than the other.

  1037 

  1038   The datetime a given number of days or seconds later than a given

  1039   datetime can be found using the addDays() and addSecs()

  1040   functions. Correspondingly, the number of days or seconds between

  1041   two times can be found using the daysTo() or secsTo() functions.

  1042 

  1043   A datetime can also be set using the setTime_t() function, which

  1044   takes a POSIX-standard "number of seconds since 00:00:00 on January

  1045   1, 1970" value.

  1046 

  1047   The limitations regarding range and resolution mentioned in the

  1048   QDate and QTime documentation apply for QDateTime also.

  1049 

  1050   \sa QDate, QTime

  1051 */

  1052 

  1053 

  1054 /*!

  1055   \fn QDateTime::QDateTime()

  1056 

  1057   Constructs a null datetime (i.e. null date and null time).  A null

  1058   datetime is invalid, since the date is invalid.

  1059 

  1060   \sa isValid()

  1061 */

  1062 

  1063 

  1064 /*!

  1065   Constructs a datetime with date \a date and null time (00:00:00.000).

  1066 */

  1067 

  1068 QDateTime::QDateTime( const QDate &date )

  1069     : d(date)

  1070 {

  1071 }

  1072 

  1073 /*!

  1074   Constructs a datetime with date \a date and time \a time.

  1075 */

  1076 

  1077 QDateTime::QDateTime( const QDate &date, const QTime &time )

  1078     : d(date), t(time)

  1079 {

  1080 }

  1081 

  1082 

  1083 /*!

  1084   \fn bool QDateTime::isNull() const

  1085 

  1086   Returns TRUE if both the date and the time are null.	A null date is invalid.

  1087 

  1088   \sa QDate::isNull(), QTime::isNull()

  1089 */

  1090 

  1091 /*!

  1092   \fn bool QDateTime::isValid() const

  1093 

  1094   Returns TRUE if both the date and the time are valid.

  1095 

  1096   \sa QDate::isValid(), QTime::isValid()

  1097 */

  1098 

  1099 /*!

  1100   \fn QDate QDateTime::date() const

  1101 

  1102   Returns the date part of this datetime.

  1103 

  1104   \sa setDate(), time()

  1105 */

  1106 

  1107 /*!

  1108   \fn QTime QDateTime::time() const

  1109 

  1110   Returns the time part of this datetime.

  1111 

  1112   \sa setTime(), date()

  1113 */

  1114 

  1115 /*!

  1116   \fn void QDateTime::setDate( const QDate &date )

  1117 

  1118   Sets the date part of this datetime.

  1119 

  1120   \sa date(), setTime()

  1121 */

  1122 

  1123 /*!

  1124   \fn void QDateTime::setTime( const QTime &time )

  1125 

  1126   Sets the time part of this datetime.

  1127 

  1128   \sa time(), setDate()

  1129 */

  1130 

  1131 

  1132 /*!

  1133   Sets the local date and time given the number of seconds that have passed

  1134   since 00:00:00 on January 1, 1970, Coordinated Universal Time (UTC).