// Author: Vadim Zeitlin
// Modified by:
// Created: 11.05.99
-// RCS-ID: $Id$
// Copyright: (c) 1999 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
// parts of code taken from sndcal library by Scott E. Lee:
//
#if !defined(wxUSE_DATETIME) || wxUSE_DATETIME
#ifndef WX_PRECOMP
- #ifdef __WXMSW__
+ #ifdef __WINDOWS__
#include "wx/msw/wrapwin.h"
#endif
#include "wx/string.h"
#endif // WX_PRECOMP
#include "wx/thread.h"
+#include "wx/time.h"
#include "wx/tokenzr.h"
#include <ctype.h>
#endif // wxUSE_EXTENDED_RTTI
-
-// ----------------------------------------------------------------------------
-// conditional compilation
-// ----------------------------------------------------------------------------
-
-#if defined(__MWERKS__) && wxUSE_UNICODE
- #include <wtime.h>
-#endif
-
-#if !defined(WX_TIMEZONE) && !defined(WX_GMTOFF_IN_TM)
- #if defined(__WXPALMOS__)
- #define WX_GMTOFF_IN_TM
- #elif defined(__BORLANDC__) || defined(__MINGW32__) || defined(__VISAGECPP__)
- #define WX_TIMEZONE _timezone
- #elif defined(__MWERKS__)
- long wxmw_timezone = 28800;
- #define WX_TIMEZONE wxmw_timezone
- #elif defined(__DJGPP__) || defined(__WINE__)
- #include <sys/timeb.h>
- #include <values.h>
- static long wxGetTimeZone()
- {
- static long timezone = MAXLONG; // invalid timezone
- if (timezone == MAXLONG)
- {
- struct timeb tb;
- ftime(&tb);
- timezone = tb.timezone;
- }
- return timezone;
- }
- #define WX_TIMEZONE wxGetTimeZone()
- #elif defined(__DARWIN__)
- #define WX_GMTOFF_IN_TM
- #elif defined(__WXWINCE__) && defined(__VISUALC8__)
- // _timezone is not present in dynamic run-time library
- #if 0
- // Solution (1): use the function equivalent of _timezone
- static long wxGetTimeZone()
- {
- static long s_Timezone = MAXLONG; // invalid timezone
- if (s_Timezone == MAXLONG)
- {
- int t;
- _get_timezone(& t);
- s_Timezone = (long) t;
- }
- return s_Timezone;
- }
- #define WX_TIMEZONE wxGetTimeZone()
- #elif 1
- // Solution (2): using GetTimeZoneInformation
- static long wxGetTimeZone()
- {
- static long timezone = MAXLONG; // invalid timezone
- if (timezone == MAXLONG)
- {
- TIME_ZONE_INFORMATION tzi;
- ::GetTimeZoneInformation(&tzi);
- timezone = tzi.Bias;
- }
- return timezone;
- }
- #define WX_TIMEZONE wxGetTimeZone()
- #else
- // Old method using _timezone: this symbol doesn't exist in the dynamic run-time library (i.e. using /MD)
- #define WX_TIMEZONE _timezone
- #endif
- #else // unknown platform - try timezone
- #define WX_TIMEZONE timezone
- #endif
-#endif // !WX_TIMEZONE && !WX_GMTOFF_IN_TM
-
-// NB: VC8 safe time functions could/should be used for wxMSW as well probably
-#if defined(__WXWINCE__) && defined(__VISUALC8__)
-
-struct tm *wxLocaltime_r(const time_t *t, struct tm* tm)
-{
- __time64_t t64 = *t;
- return _localtime64_s(tm, &t64) == 0 ? tm : NULL;
-}
-
-struct tm *wxGmtime_r(const time_t* t, struct tm* tm)
-{
- __time64_t t64 = *t;
- return _gmtime64_s(tm, &t64) == 0 ? tm : NULL;
-}
-
-#else // !wxWinCE with VC8
-
-#if (!defined(HAVE_LOCALTIME_R) || !defined(HAVE_GMTIME_R)) && wxUSE_THREADS && !defined(__WINDOWS__)
-static wxMutex timeLock;
-#endif
-
-#ifndef HAVE_LOCALTIME_R
-struct tm *wxLocaltime_r(const time_t* ticks, struct tm* temp)
-{
-#if wxUSE_THREADS && !defined(__WINDOWS__)
- // No need to waste time with a mutex on windows since it's using
- // thread local storage for localtime anyway.
- wxMutexLocker locker(timeLock);
-#endif
-
- // Borland CRT crashes when passed 0 ticks for some reason, see SF bug 1704438
-#ifdef __BORLANDC__
- if ( !*ticks )
- return NULL;
-#endif
-
- const tm * const t = localtime(ticks);
- if ( !t )
- return NULL;
-
- memcpy(temp, t, sizeof(struct tm));
- return temp;
-}
-#endif // !HAVE_LOCALTIME_R
-
-#ifndef HAVE_GMTIME_R
-struct tm *wxGmtime_r(const time_t* ticks, struct tm* temp)
-{
-#if wxUSE_THREADS && !defined(__WINDOWS__)
- // No need to waste time with a mutex on windows since it's
- // using thread local storage for gmtime anyway.
- wxMutexLocker locker(timeLock);
-#endif
-
-#ifdef __BORLANDC__
- if ( !*ticks )
- return NULL;
-#endif
-
- const tm * const t = gmtime(ticks);
- if ( !t )
- return NULL;
-
- memcpy(temp, gmtime(ticks), sizeof(struct tm));
- return temp;
-}
-#endif // !HAVE_GMTIME_R
-
-#endif // wxWinCE with VC8/other platforms
-
// ----------------------------------------------------------------------------
// macros
// ----------------------------------------------------------------------------
static const int MIN_PER_HOUR = 60;
-static const int HOURS_PER_DAY = 24;
-
static const long SECONDS_PER_DAY = 86400l;
static const int DAYS_PER_WEEK = 7;
// global data
// ----------------------------------------------------------------------------
-const char *wxDefaultDateTimeFormat = "%c";
-const char *wxDefaultTimeSpanFormat = "%H:%M:%S";
+const char wxDefaultDateTimeFormat[] = "%c";
+const char wxDefaultTimeSpanFormat[] = "%H:%M:%S";
// in the fine tradition of ANSI C we use our equivalent of (time_t)-1 to
// indicate an invalid wxDateTime object
{
// the number of days in month in Julian/Gregorian calendar: the first line
// is for normal years, the second one is for the leap ones
- static wxDateTime::wxDateTime_t daysInMonth[2][MONTHS_IN_YEAR] =
+ static const wxDateTime::wxDateTime_t daysInMonth[2][MONTHS_IN_YEAR] =
{
{ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
{ 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
return daysInMonth[wxDateTime::IsLeapYear(year)][month];
}
-// returns the time zone in the C sense, i.e. the difference UTC - local
-// (in seconds)
-// NOTE: not static because used by datetimefmt.cpp
-int GetTimeZone()
-{
- // set to true when the timezone is set
- static bool s_timezoneSet = false;
- static long gmtoffset = LONG_MAX; // invalid timezone
-
- // ensure that the timezone variable is set by calling wxLocaltime_r
- if ( !s_timezoneSet )
- {
- // just call wxLocaltime_r() instead of figuring out whether this
- // system supports tzset(), _tzset() or something else
- time_t t = 0;
- struct tm tm;
-
- wxLocaltime_r(&t, &tm);
- s_timezoneSet = true;
-
-#ifdef WX_GMTOFF_IN_TM
- // note that GMT offset is the opposite of time zone and so to return
- // consistent results in both WX_GMTOFF_IN_TM and !WX_GMTOFF_IN_TM
- // cases we have to negate it
- gmtoffset = -tm.tm_gmtoff;
-#else // !WX_GMTOFF_IN_TM
- gmtoffset = WX_TIMEZONE;
-#endif // WX_GMTOFF_IN_TM/!WX_GMTOFF_IN_TM
- }
-
- return (int)gmtoffset;
-}
-
// return the integral part of the JDN for the midnight of the given date (to
// get the real JDN you need to add 0.5, this is, in fact, JDN of the
// noon of the previous day)
(year > JDN_0_YEAR) ||
((year == JDN_0_YEAR) && (mon > JDN_0_MONTH)) ||
((year == JDN_0_YEAR) && (mon == JDN_0_MONTH) && (day >= JDN_0_DAY)),
- _T("date out of range - can't convert to JDN")
+ wxT("date out of range - can't convert to JDN")
);
// make the year positive to avoid problems with negative numbers division
if ( !wxStrftime(buf, WXSIZEOF(buf), format, tm) )
{
- // if the format is valid, buffer must be too small?
- wxFAIL_MSG(_T("strftime() failed"));
+ // There is one special case in which strftime() can return 0 without
+ // indicating an error: "%p" may give empty string depending on the
+ // locale, so check for it explicitly. Apparently it's really the only
+ // exception.
+ if ( format != wxS("%p") )
+ {
+ // if the format is valid, buffer must be too small?
+ wxFAIL_MSG(wxT("strftime() failed"));
+ }
buf[0] = '\0';
}
{
year = (wxDateTime_t)wxDateTime::Inv_Year;
mon = wxDateTime::Inv_Month;
- mday = 0;
- hour = min = sec = msec = 0;
+ mday =
+ yday = 0;
+ hour =
+ min =
+ sec =
+ msec = 0;
wday = wxDateTime::Inv_WeekDay;
}
bool wxDateTime::Tm::IsValid() const
{
+ if ( mon == wxDateTime::Inv_Month )
+ return false;
+
+ // We need to check this here to avoid crashing in GetNumOfDaysInMonth() if
+ // somebody passed us "(wxDateTime::Month)1000".
+ wxCHECK_MSG( mon >= wxDateTime::Jan && mon < wxDateTime::Inv_Month, false,
+ wxS("Invalid month value") );
+
// we allow for the leap seconds, although we don't use them (yet)
return (year != wxDateTime::Inv_Year) && (mon != wxDateTime::Inv_Month) &&
- (mday <= GetNumOfDaysInMonth(year, mon)) &&
+ (mday > 0 && mday <= GetNumOfDaysInMonth(year, mon)) &&
(hour < 24) && (min < 60) && (sec < 62) && (msec < 1000);
}
mon = (wxDateTime::Month)(mon + monDiff);
- wxASSERT_MSG( mon >= 0 && mon < MONTHS_IN_YEAR, _T("logic error") );
+ wxASSERT_MSG( mon >= 0 && mon < MONTHS_IN_YEAR, wxT("logic error") );
// NB: we don't check here that the resulting date is valid, this function
// is private and the caller must check it if needed
}
wxASSERT_MSG( mday > 0 && mday <= GetNumOfDaysInMonth(year, mon),
- _T("logic error") );
+ wxT("logic error") );
}
// ----------------------------------------------------------------------------
case wxDateTime::Local:
// get the offset from C RTL: it returns the difference GMT-local
// while we want to have the offset _from_ GMT, hence the '-'
- m_offset = -GetTimeZone();
+ m_offset = -wxGetTimeZone();
break;
case wxDateTime::GMT_12:
break;
default:
- wxFAIL_MSG( _T("unknown time zone") );
+ wxFAIL_MSG( wxT("unknown time zone") );
}
}
}
else
{
- wxFAIL_MSG(_T("unknown calendar"));
+ wxFAIL_MSG(wxT("unknown calendar"));
return false;
}
return Now().GetYear();
case Julian:
- wxFAIL_MSG(_T("TODO"));
+ wxFAIL_MSG(wxT("TODO"));
break;
default:
- wxFAIL_MSG(_T("unsupported calendar"));
+ wxFAIL_MSG(wxT("unsupported calendar"));
break;
}
return Now().GetMonth();
case Julian:
- wxFAIL_MSG(_T("TODO"));
+ wxFAIL_MSG(wxT("TODO"));
break;
default:
- wxFAIL_MSG(_T("unsupported calendar"));
+ wxFAIL_MSG(wxT("unsupported calendar"));
break;
}
return IsLeapYear(year) ? 366 : 365;
default:
- wxFAIL_MSG(_T("unsupported calendar"));
+ wxFAIL_MSG(wxT("unsupported calendar"));
break;
}
int year,
wxDateTime::Calendar cal)
{
- wxCHECK_MSG( month < MONTHS_IN_YEAR, 0, _T("invalid month") );
+ wxCHECK_MSG( month < MONTHS_IN_YEAR, 0, wxT("invalid month") );
if ( cal == Gregorian || cal == Julian )
{
}
else
{
- wxFAIL_MSG(_T("unsupported calendar"));
+ wxFAIL_MSG(wxT("unsupported calendar"));
return 0;
}
{
wxCHECK_MSG( month != Inv_Month, wxEmptyString, "invalid month" );
- static const char *monthNames[2][MONTHS_IN_YEAR] =
+ static const char *const monthNames[2][MONTHS_IN_YEAR] =
{
{ "January", "February", "March", "April", "May", "June",
"July", "August", "September", "October", "November", "December" },
wxDateTime::NameFlags flags)
{
#ifdef wxHAS_STRFTIME
- wxCHECK_MSG( month != Inv_Month, wxEmptyString, _T("invalid month") );
+ wxCHECK_MSG( month != Inv_Month, wxEmptyString, wxT("invalid month") );
// notice that we must set all the fields to avoid confusing libc (GNU one
// gets confused to a crash if we don't do this)
InitTm(tm);
tm.tm_mon = month;
- return CallStrftime(flags == Name_Abbr ? _T("%b") : _T("%B"), &tm);
+ return CallStrftime(flags == Name_Abbr ? wxT("%b") : wxT("%B"), &tm);
#else // !wxHAS_STRFTIME
return GetEnglishMonthName(month, flags);
#endif // wxHAS_STRFTIME/!wxHAS_STRFTIME
/* static */
wxString wxDateTime::GetEnglishWeekDayName(WeekDay wday, NameFlags flags)
{
- wxCHECK_MSG( wday != Inv_WeekDay, wxEmptyString, _T("invalid weekday") );
+ wxCHECK_MSG( wday != Inv_WeekDay, wxEmptyString, wxT("invalid weekday") );
- static const char *weekdayNames[2][DAYS_PER_400_YEARS] =
+ static const char *const weekdayNames[2][DAYS_PER_WEEK] =
{
{ "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday",
"Saturday" },
wxDateTime::NameFlags flags)
{
#ifdef wxHAS_STRFTIME
- wxCHECK_MSG( wday != Inv_WeekDay, wxEmptyString, _T("invalid weekday") );
+ wxCHECK_MSG( wday != Inv_WeekDay, wxEmptyString, wxT("invalid weekday") );
// take some arbitrary Sunday (but notice that the day should be such that
// after adding wday to it below we still have a valid date, e.g. don't
(void)mktime(&tm);
// ... and call strftime()
- return CallStrftime(flags == Name_Abbr ? _T("%a") : _T("%A"), &tm);
+ return CallStrftime(flags == Name_Abbr ? wxT("%a") : wxT("%A"), &tm);
#else // !wxHAS_STRFTIME
return GetEnglishWeekDayName(wday, flags);
#endif // wxHAS_STRFTIME/!wxHAS_STRFTIME
// assert, even though it is a perfectly legal use.
if ( am )
{
- if (wxStrftime(buffer, sizeof(buffer)/sizeof(wxChar), _T("%p"), &tm) > 0)
+ if (wxStrftime(buffer, WXSIZEOF(buffer), wxT("%p"), &tm) > 0)
*am = wxString(buffer);
else
*am = wxString();
if ( pm )
{
tm.tm_hour = 13;
- if (wxStrftime(buffer, sizeof(buffer)/sizeof(wxChar), _T("%p"), &tm) > 0)
+ if (wxStrftime(buffer, WXSIZEOF(buffer), wxT("%p"), &tm) > 0)
*pm = wxString(buffer);
else
*pm = wxString();
struct tm tmstruct;
struct tm *tm = wxLocaltime_r(&t, &tmstruct);
- wxString tz = CallStrftime(_T("%Z"), tm);
- if ( tz == _T("WET") || tz == _T("WEST") )
+ wxString tz = CallStrftime(wxT("%Z"), tm);
+ if ( tz == wxT("WET") || tz == wxT("WEST") )
{
ms_country = UK;
}
- else if ( tz == _T("CET") || tz == _T("CEST") )
+ else if ( tz == wxT("CET") || tz == wxT("CEST") )
{
ms_country = Country_EEC;
}
- else if ( tz == _T("MSK") || tz == _T("MSD") )
+ else if ( tz == wxT("MSK") || tz == wxT("MSD") )
{
ms_country = Russia;
}
- else if ( tz == _T("AST") || tz == _T("ADT") ||
- tz == _T("EST") || tz == _T("EDT") ||
- tz == _T("CST") || tz == _T("CDT") ||
- tz == _T("MST") || tz == _T("MDT") ||
- tz == _T("PST") || tz == _T("PDT") )
+ else if ( tz == wxT("AST") || tz == wxT("ADT") ||
+ tz == wxT("EST") || tz == wxT("EDT") ||
+ tz == wxT("CST") || tz == wxT("CDT") ||
+ tz == wxT("MST") || tz == wxT("MDT") ||
+ tz == wxT("PST") || tz == wxT("PDT") )
{
ms_country = USA;
}
if ( !dt.SetToLastWeekDay(Sun, Mar, year) )
{
// weird...
- wxFAIL_MSG( _T("no last Sunday in March?") );
+ wxFAIL_MSG( wxT("no last Sunday in March?") );
}
dt += wxTimeSpan::Hours(1);
if ( !dt.SetToLastWeekDay(Sun, Apr, year) )
{
// weird...
- wxFAIL_MSG( _T("no first Sunday in April?") );
+ wxFAIL_MSG( wxT("no first Sunday in April?") );
}
}
else if ( year > 2006 )
if ( !dt.SetToWeekDay(Sun, 2, Mar, year) )
{
// weird...
- wxFAIL_MSG( _T("no second Sunday in March?") );
+ wxFAIL_MSG( wxT("no second Sunday in March?") );
}
}
else
if ( !dt.SetToWeekDay(Sun, 1, Apr, year) )
{
// weird...
- wxFAIL_MSG( _T("no first Sunday in April?") );
+ wxFAIL_MSG( wxT("no first Sunday in April?") );
}
}
if ( !dt.SetToLastWeekDay(Sun, Oct, year) )
{
// weirder and weirder...
- wxFAIL_MSG( _T("no last Sunday in October?") );
+ wxFAIL_MSG( wxT("no last Sunday in October?") );
}
dt += wxTimeSpan::Hours(1);
if ( !dt.SetToWeekDay(Sun, 1, Nov, year) )
{
// weird...
- wxFAIL_MSG( _T("no first Sunday in November?") );
+ wxFAIL_MSG( wxT("no first Sunday in November?") );
}
}
else
if ( !dt.SetToLastWeekDay(Sun, Oct, year) )
{
// weirder and weirder...
- wxFAIL_MSG( _T("no last Sunday in October?") );
+ wxFAIL_MSG( wxT("no last Sunday in October?") );
}
}
// return the current time with ms precision
/* static */ wxDateTime wxDateTime::UNow()
{
- return wxDateTime(wxGetLocalTimeMillis());
+ return wxDateTime(wxGetUTCTimeMillis());
}
// the values in the tm structure contain the local time
if ( tm2.tm_year == 70 && tm2.tm_mon == 0 && tm2.tm_mday == 1 )
{
return Set((time_t)(
- GetTimeZone() +
+ wxGetTimeZone() +
tm2.tm_hour * MIN_PER_HOUR * SEC_PER_MIN +
tm2.tm_min * SEC_PER_MIN +
tm2.tm_sec));
}
- wxFAIL_MSG( _T("mktime() failed") );
+ wxFAIL_MSG( wxT("mktime() failed") );
*this = wxInvalidDateTime;
return *this;
}
- else
- {
- return Set(timet);
+
+ // mktime() only adjusts tm_wday, tm_yday and tm_isdst fields normally, if
+ // it changed anything else, it must have performed the DST adjustment. But
+ // the trouble with this is that different implementations do it
+ // differently, e.g. GNU libc moves the time forward if the specified time
+ // is invalid in the local time zone, while MSVC CRT moves it backwards
+ // which is especially pernicious as it can change the date if the DST
+ // starts at midnight, as it does in some time zones (see #15419), and this
+ // is completely unexpected for the code working with dates only.
+ //
+ // So standardize on moving the time forwards to have consistent behaviour
+ // under all platforms and to avoid the problem above.
+ if ( tm2.tm_hour != tm.tm_hour )
+ {
+ tm2 = tm;
+ tm2.tm_hour++;
+ if ( tm2.tm_hour == 24 )
+ {
+ // This shouldn't normally happen as the DST never starts at 23:00
+ // but if it does, we have a problem as we need to adjust the day
+ // as well. However we stop here, i.e. we don't adjust the month
+ // (or the year) because mktime() is supposed to take care of this
+ // for us.
+ tm2.tm_hour = 0;
+ tm2.tm_mday++;
+ }
+
+ timet = mktime(&tm2);
}
+
+ return Set(timet);
}
wxDateTime& wxDateTime::Set(wxDateTime_t hour,
second < 62 &&
minute < 60 &&
millisec < 1000,
- _T("Invalid time in wxDateTime::Set()") );
+ wxT("Invalid time in wxDateTime::Set()") );
// get the current date from system
struct tm tmstruct;
struct tm *tm = GetTmNow(&tmstruct);
- wxDATETIME_CHECK( tm, _T("wxLocaltime_r() failed") );
+ wxDATETIME_CHECK( tm, wxT("wxLocaltime_r() failed") );
// make a copy so it isn't clobbered by the call to mktime() below
struct tm tm1(*tm);
second < 62 &&
minute < 60 &&
millisec < 1000,
- _T("Invalid time in wxDateTime::Set()") );
+ wxT("Invalid time in wxDateTime::Set()") );
ReplaceDefaultYearMonthWithCurrent(&year, &month);
wxDATETIME_CHECK( (0 < day) && (day <= GetNumberOfDays(month, year)),
- _T("Invalid date in wxDateTime::Set()") );
+ wxT("Invalid date in wxDateTime::Set()") );
// the range of time_t type (inclusive)
static const int yearMinInRange = 1970;
m_time *= SECONDS_PER_DAY * TIME_T_FACTOR;
// JDN corresponds to GMT, we take localtime
- Add(wxTimeSpan(hour, minute, second + GetTimeZone(), millisec));
+ Add(wxTimeSpan(hour, minute, second + wxGetTimeZone(), millisec));
}
return *this;
time_t ticks = GetTicks();
struct tm tmstruct;
struct tm *tm = wxLocaltime_r(&ticks, &tmstruct);
- wxCHECK_MSG( tm, ULONG_MAX, _T("time can't be represented in DOS format") );
+ wxCHECK_MSG( tm, ULONG_MAX, wxT("time can't be represented in DOS format") );
long year = tm->tm_year;
year -= 80;
wxDateTime::Tm wxDateTime::GetTm(const TimeZone& tz) const
{
- wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
+ wxASSERT_MSG( IsValid(), wxT("invalid wxDateTime") );
time_t time = GetTicks();
if ( time != (time_t)-1 )
// use C RTL functions
struct tm tmstruct;
tm *tm;
- if ( tz.GetOffset() == -GetTimeZone() )
+ if ( tz.GetOffset() == -wxGetTimeZone() )
{
// we are working with local time
tm = wxLocaltime_r(&time, &tmstruct);
// should never happen
- wxCHECK_MSG( tm, Tm(), _T("wxLocaltime_r() failed") );
+ wxCHECK_MSG( tm, Tm(), wxT("wxLocaltime_r() failed") );
}
else
{
tm = wxGmtime_r(&time, &tmstruct);
// should never happen
- wxCHECK_MSG( tm, Tm(), _T("wxGmtime_r() failed") );
+ wxCHECK_MSG( tm, Tm(), wxT("wxGmtime_r() failed") );
}
else
{
// CREDIT: code below is by Scott E. Lee (but bugs are mine)
- wxASSERT_MSG( jdn > -2, _T("JDN out of range") );
+ wxASSERT_MSG( jdn > -2, wxT("JDN out of range") );
// calculate the century
long temp = (jdn + JDN_OFFSET) * 4 - 1;
year -= 4800;
// check that the algorithm gave us something reasonable
- wxASSERT_MSG( (0 < month) && (month <= 12), _T("invalid month") );
- wxASSERT_MSG( (1 <= day) && (day < 32), _T("invalid day") );
+ wxASSERT_MSG( (0 < month) && (month <= 12), wxT("invalid month") );
+ wxASSERT_MSG( (1 <= day) && (day < 32), wxT("invalid day") );
// construct Tm from these values
Tm tm;
tm.year = (int)year;
+ tm.yday = (wxDateTime_t)(dayOfYear - 1); // use C convention for day number
tm.mon = (Month)(month - 1); // algorithm yields 1 for January, not 0
tm.mday = (wxDateTime_t)day;
tm.msec = (wxDateTime_t)(timeOnly % 1000);
wxDateTime& wxDateTime::SetYear(int year)
{
- wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
+ wxASSERT_MSG( IsValid(), wxT("invalid wxDateTime") );
Tm tm(GetTm());
tm.year = year;
wxDateTime& wxDateTime::SetMonth(Month month)
{
- wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
+ wxASSERT_MSG( IsValid(), wxT("invalid wxDateTime") );
Tm tm(GetTm());
tm.mon = month;
wxDateTime& wxDateTime::SetDay(wxDateTime_t mday)
{
- wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
+ wxASSERT_MSG( IsValid(), wxT("invalid wxDateTime") );
Tm tm(GetTm());
tm.mday = mday;
wxDateTime& wxDateTime::SetHour(wxDateTime_t hour)
{
- wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
+ wxASSERT_MSG( IsValid(), wxT("invalid wxDateTime") );
Tm tm(GetTm());
tm.hour = hour;
wxDateTime& wxDateTime::SetMinute(wxDateTime_t min)
{
- wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
+ wxASSERT_MSG( IsValid(), wxT("invalid wxDateTime") );
Tm tm(GetTm());
tm.min = min;
wxDateTime& wxDateTime::SetSecond(wxDateTime_t sec)
{
- wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
+ wxASSERT_MSG( IsValid(), wxT("invalid wxDateTime") );
Tm tm(GetTm());
tm.sec = sec;
wxDateTime& wxDateTime::SetMillisecond(wxDateTime_t millisecond)
{
- wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
+ wxASSERT_MSG( IsValid(), wxT("invalid wxDateTime") );
// we don't need to use GetTm() for this one
m_time -= m_time % 1000l;
Set(tm);
wxASSERT_MSG( IsSameTime(tm),
- _T("Add(wxDateSpan) shouldn't modify time") );
+ wxT("Add(wxDateSpan) shouldn't modify time") );
return *this;
}
+wxDateSpan wxDateTime::DiffAsDateSpan(const wxDateTime& dt) const
+{
+ wxASSERT_MSG( IsValid() && dt.IsValid(), wxT("invalid wxDateTime"));
+
+ // If dt is larger than this, calculations below needs to be inverted.
+ int inv = 1;
+ if ( dt > *this )
+ inv = -1;
+
+ int y = GetYear() - dt.GetYear();
+ int m = GetMonth() - dt.GetMonth();
+ int d = GetDay() - dt.GetDay();
+
+ // If month diff is negative, dt is the year before, so decrease year
+ // and set month diff to its inverse, e.g. January - December should be 1,
+ // not -11.
+ if ( m * inv < 0 || (m == 0 && d * inv < 0))
+ {
+ m += inv * MONTHS_IN_YEAR;
+ y -= inv;
+ }
+
+ // Same logic for days as for months above.
+ if ( d * inv < 0 )
+ {
+ // Use number of days in month from the month which end date we're
+ // crossing. That is month before this for positive diff, and this
+ // month for negative diff.
+ // If we're on january and using previous month, we get december
+ // previous year, but don't care, december has same amount of days
+ // every year.
+ wxDateTime::Month monthfordays = GetMonth();
+ if (inv > 0 && monthfordays == wxDateTime::Jan)
+ monthfordays = wxDateTime::Dec;
+ else if (inv > 0)
+ monthfordays = static_cast<wxDateTime::Month>(monthfordays - 1);
+
+ d += inv * wxDateTime::GetNumberOfDays(monthfordays, GetYear());
+ m -= inv;
+ }
+
+ int w = d / DAYS_PER_WEEK;
+
+ // Remove weeks from d, since wxDateSpan only keep days as the ones
+ // not in complete weeks
+ d -= w * DAYS_PER_WEEK;
+
+ return wxDateSpan(y, m, w, d);
+}
+
// ----------------------------------------------------------------------------
// Weekday and monthday stuff
// ----------------------------------------------------------------------------
wxDateTime::SetToWeekOfYear(int year, wxDateTime_t numWeek, WeekDay wd)
{
wxASSERT_MSG( numWeek > 0,
- _T("invalid week number: weeks are counted from 1") );
+ wxT("invalid week number: weeks are counted from 1") );
// Jan 4 always lies in the 1st week of the year
wxDateTime dt(4, Jan, year);
wxDateTime& wxDateTime::SetToWeekDayInSameWeek(WeekDay weekday, WeekFlags flags)
{
- wxDATETIME_CHECK( weekday != Inv_WeekDay, _T("invalid weekday") );
+ wxDATETIME_CHECK( weekday != Inv_WeekDay, wxT("invalid weekday") );
int wdayDst = weekday,
wdayThis = GetWeekDay();
wxDateTime& wxDateTime::SetToNextWeekDay(WeekDay weekday)
{
- wxDATETIME_CHECK( weekday != Inv_WeekDay, _T("invalid weekday") );
+ wxDATETIME_CHECK( weekday != Inv_WeekDay, wxT("invalid weekday") );
int diff;
WeekDay wdayThis = GetWeekDay();
wxDateTime& wxDateTime::SetToPrevWeekDay(WeekDay weekday)
{
- wxDATETIME_CHECK( weekday != Inv_WeekDay, _T("invalid weekday") );
+ wxDATETIME_CHECK( weekday != Inv_WeekDay, wxT("invalid weekday") );
int diff;
WeekDay wdayThis = GetWeekDay();
Month month,
int year)
{
- wxCHECK_MSG( weekday != Inv_WeekDay, false, _T("invalid weekday") );
+ wxCHECK_MSG( weekday != Inv_WeekDay, false, wxT("invalid weekday") );
// we don't check explicitly that -5 <= n <= 5 because we will return false
// anyhow in such case - but may be should still give an assert for it?
{
// adjust the weekdays to non-US style.
wdYearStart = ConvertWeekDayToMondayBase(wdYearStart);
- wdTarget = ConvertWeekDayToMondayBase(wdTarget);
// quoting from http://www.cl.cam.ac.uk/~mgk25/iso-time.html:
//
//
// if Jan 1 is Thursday or less, it is in the first week of this year
- if ( wdYearStart < 4 )
- {
- // count the number of entire weeks between Jan 1 and this date
- week = (nDayInYear + wdYearStart + 6 - wdTarget)/7;
+ int dayCountFix = wdYearStart < 4 ? 6 : -1;
- // be careful to check for overflow in the next year
- if ( week == 53 && tm.mday - wdTarget > 28 )
- week = 1;
+ // count the number of week
+ week = (nDayInYear + wdYearStart + dayCountFix) / DAYS_PER_WEEK;
+
+ // check if we happen to be at the last week of previous year:
+ if ( week == 0 )
+ {
+ week = wxDateTime(31, Dec, GetYear() - 1).GetWeekOfYear();
}
- else // Jan 1 is in the last week of the previous year
+ else if ( week == 53 )
{
- // check if we happen to be at the last week of previous year:
- if ( tm.mon == Jan && tm.mday < 8 - wdYearStart )
- week = wxDateTime(31, Dec, GetYear()-1).GetWeekOfYear();
- else
- week = (nDayInYear + wdYearStart - 1 - wdTarget)/7;
+ int wdYearEnd = (wdYearStart + 364 + IsLeapYear(GetYear()))
+ % DAYS_PER_WEEK;
+
+ // Week 53 only if last day of year is Thursday or later.
+ if ( wdYearEnd < 3 )
+ week = 1;
}
}
const TimeZone& tz) const
{
Tm tm = GetTm(tz);
- wxDateTime dtMonthStart = wxDateTime(1, tm.mon, tm.year);
- int nWeek = GetWeekOfYear(flags) - dtMonthStart.GetWeekOfYear(flags) + 1;
- if ( nWeek < 0 )
+ const wxDateTime dateFirst = wxDateTime(1, tm.mon, tm.year);
+ const wxDateTime::WeekDay wdFirst = dateFirst.GetWeekDay();
+
+ if ( flags == Default_First )
{
- // this may happen for January when Jan, 1 is the last week of the
- // previous year
- nWeek += IsLeapYear(tm.year - 1) ? 53 : 52;
+ flags = GetCountry() == USA ? Sunday_First : Monday_First;
}
- return (wxDateTime::wxDateTime_t)nWeek;
+ // compute offset of dateFirst from the beginning of the week
+ int firstOffset;
+ if ( flags == Sunday_First )
+ firstOffset = wdFirst - Sun;
+ else
+ firstOffset = wdFirst == Sun ? DAYS_PER_WEEK - 1 : wdFirst - Mon;
+
+ return (wxDateTime::wxDateTime_t)((tm.mday - 1 + firstOffset)/7 + 1);
}
wxDateTime& wxDateTime::SetToYearDay(wxDateTime::wxDateTime_t yday)
{
int year = GetYear();
wxDATETIME_CHECK( (0 < yday) && (yday <= GetNumberOfDays(year)),
- _T("invalid year day") );
+ wxT("invalid year day") );
bool isLeap = IsLeapYear(year);
for ( Month mon = Jan; mon < Inv_Month; wxNextMonth(mon) )
int wxDateTime::IsDST(wxDateTime::Country country) const
{
wxCHECK_MSG( country == Country_Default, -1,
- _T("country support not implemented") );
+ wxT("country support not implemented") );
// use the C RTL for the dates in the standard range
time_t timet = GetTicks();
struct tm tmstruct;
tm *tm = wxLocaltime_r(&timet, &tmstruct);
- wxCHECK_MSG( tm, -1, _T("wxLocaltime_r() failed") );
+ wxCHECK_MSG( tm, -1, wxT("wxLocaltime_r() failed") );
return tm->tm_isdst;
}
wxDateTime& wxDateTime::MakeTimezone(const TimeZone& tz, bool noDST)
{
- long secDiff = GetTimeZone() + tz.GetOffset();
+ long secDiff = wxGetTimeZone() + tz.GetOffset();
// we need to know whether DST is or not in effect for this date unless
// the test disabled by the caller
wxDateTime& wxDateTime::MakeFromTimezone(const TimeZone& tz, bool noDST)
{
- long secDiff = GetTimeZone() + tz.GetOffset();
+ long secDiff = wxGetTimeZone() + tz.GetOffset();
// we need to know whether DST is or not in effect for this date unless
// the test disabled by the caller
{
if ( dtStart > dtEnd )
{
- wxFAIL_MSG( _T("invalid date range in GetHolidaysInRange") );
+ wxFAIL_MSG( wxT("invalid date range in GetHolidaysInRange") );
return 0u;
}
WXDLLIMPEXP_BASE void wxNextMonth(wxDateTime::Month& m)
{
- wxASSERT_MSG( m < wxDateTime::Inv_Month, _T("invalid month") );
+ wxASSERT_MSG( m < wxDateTime::Inv_Month, wxT("invalid month") );
// no wrapping or the for loop above would never end!
m = (wxDateTime::Month)(m + 1);
WXDLLIMPEXP_BASE void wxPrevMonth(wxDateTime::Month& m)
{
- wxASSERT_MSG( m < wxDateTime::Inv_Month, _T("invalid month") );
+ wxASSERT_MSG( m < wxDateTime::Inv_Month, wxT("invalid month") );
m = m == wxDateTime::Jan ? wxDateTime::Inv_Month
: (wxDateTime::Month)(m - 1);
WXDLLIMPEXP_BASE void wxNextWDay(wxDateTime::WeekDay& wd)
{
- wxASSERT_MSG( wd < wxDateTime::Inv_WeekDay, _T("invalid week day") );
+ wxASSERT_MSG( wd < wxDateTime::Inv_WeekDay, wxT("invalid week day") );
// no wrapping or the for loop above would never end!
wd = (wxDateTime::WeekDay)(wd + 1);
WXDLLIMPEXP_BASE void wxPrevWDay(wxDateTime::WeekDay& wd)
{
- wxASSERT_MSG( wd < wxDateTime::Inv_WeekDay, _T("invalid week day") );
+ wxASSERT_MSG( wd < wxDateTime::Inv_WeekDay, wxT("invalid week day") );
wd = wd == wxDateTime::Sun ? wxDateTime::Inv_WeekDay
: (wxDateTime::WeekDay)(wd - 1);
}
-#ifdef __WXMSW__
+#ifdef __WINDOWS__
wxDateTime& wxDateTime::SetFromMSWSysTime(const SYSTEMTIME& st)
{
return Set(st.wDay,
static_cast<wxDateTime::Month>(wxDateTime::Jan + st.wMonth - 1),
st.wYear,
- 0, 0, 0);
+ st.wHour, st.wMinute, st.wSecond, st.wMilliseconds);
+}
+
+wxDateTime& wxDateTime::SetFromMSWSysDate(const SYSTEMTIME& st)
+{
+ return Set(st.wDay,
+ static_cast<wxDateTime::Month>(wxDateTime::Jan + st.wMonth - 1),
+ st.wYear,
+ 0, 0, 0, 0);
}
void wxDateTime::GetAsMSWSysTime(SYSTEMTIME* st) const
st->wMonth = (WXWORD)(tm.mon - wxDateTime::Jan + 1);
st->wDay = tm.mday;
+ st->wDayOfWeek = 0;
+ st->wHour = tm.hour;
+ st->wMinute = tm.min;
+ st->wSecond = tm.sec;
+ st->wMilliseconds = tm.msec;
+}
+
+void wxDateTime::GetAsMSWSysDate(SYSTEMTIME* st) const
+{
+ const wxDateTime::Tm tm(GetTm());
+
+ st->wYear = (WXWORD)tm.year;
+ st->wMonth = (WXWORD)(tm.mon - wxDateTime::Jan + 1);
+ st->wDay = tm.mday;
+
st->wDayOfWeek =
st->wHour =
st->wMinute =
st->wSecond =
st->wMilliseconds = 0;
}
-#endif // __WXMSW__
+
+#endif // __WINDOWS__
#endif // wxUSE_DATETIME
projects / wxWidgets.git / blobdiff