#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>
#include "wx/datetime.h"
-const long wxDateTime::TIME_T_FACTOR = 1000l;
+// ----------------------------------------------------------------------------
+// wxXTI
+// ----------------------------------------------------------------------------
#if wxUSE_EXTENDED_RTTI
#endif // wxUSE_EXTENDED_RTTI
-//
-// ----------------------------------------------------------------------------
-// conditional compilation
-// ----------------------------------------------------------------------------
-
-#if defined(HAVE_STRPTIME) && defined(__GLIBC__) && \
- ((__GLIBC__ == 2) && (__GLIBC_MINOR__ == 0))
- // glibc 2.0.7 strptime() is broken - the following snippet causes it to
- // crash (instead of just failing):
- //
- // strncpy(buf, "Tue Dec 21 20:25:40 1999", 128);
- // strptime(buf, "%x", &tm);
- //
- // so don't use it
- #undef HAVE_STRPTIME
-#endif // broken strptime()
-
-#if defined(HAVE_STRPTIME) && defined(__DARWIN__) && defined(_MSL_USING_MW_C_HEADERS) && _MSL_USING_MW_C_HEADERS
- // configure detects strptime as linkable because it's in the OS X
- // System library but MSL headers don't declare it.
-
-// char *strptime(const char *, const char *, struct tm *);
- // However, we DON'T want to just provide it here because we would
- // crash and/or overwrite data when strptime from OS X tries
- // to fill in MW's struct tm which is two fields shorter (no TZ stuff)
- // So for now let's just say we don't have strptime
- #undef HAVE_STRPTIME
-#endif
-
-#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
-
-// everyone has strftime except Win CE unless VC8 is used
-#if !defined(__WXWINCE__) || defined(__VISUALC8__)
- #define HAVE_STRFTIME
-#endif
-
-// 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;
// (i.e. JDN(Jan 1, 1970) = 2440587.5)
static const long EPOCH_JDN = 2440587l;
-// used only in asserts
-#ifdef __WXDEBUG__
+// these values are only used in asserts so don't define them if asserts are
+// disabled to avoid warnings about unused static variables
+#if wxDEBUG_LEVEL
// the date of JDN -0.5 (as we don't work with fractional parts, this is the
// reference date for us) is Nov 24, 4714BC
static const int JDN_0_YEAR = -4713;
static const int JDN_0_MONTH = wxDateTime::Nov;
static const int JDN_0_DAY = 24;
-#endif // __WXDEBUG__
+#endif // wxDEBUG_LEVEL
// the constants used for JDN calculations
static const long JDN_OFFSET = 32046l;
{ 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335 }
};
+const long wxDateTime::TIME_T_FACTOR = 1000l;
+
// ----------------------------------------------------------------------------
// 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
// private functions
// ----------------------------------------------------------------------------
-// debugger helper: shows what the date really is
-#ifdef __WXDEBUG__
+// debugger helper: this function can be called from a debugger to show what
+// the date really is
extern const char *wxDumpDate(const wxDateTime* dt)
{
static char buf[128];
return buf;
}
-#endif // Debug
// get the number of days in the given month of the given year
static inline
{
// 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)
-static 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
- JDN_OFFSET;
}
-#ifdef HAVE_STRFTIME
+#ifdef wxHAS_STRFTIME
// this function is a wrapper around strftime(3) adding error checking
-static wxString CallStrftime(const wxString& format, const tm* tm)
+// NOTE: not static because used by datetimefmt.cpp
+wxString CallStrftime(const wxString& format, const tm* tm)
{
wxChar buf[4096];
// Create temp wxString here to work around mingw/cygwin bug 1046059
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';
}
return s;
}
-#endif // HAVE_STRFTIME
-
-#ifdef HAVE_STRPTIME
-
-#if wxUSE_UNIX && !defined(HAVE_STRPTIME_DECL)
- // configure detected that we had strptime() but not its declaration,
- // provide it ourselves
- extern "C" char *strptime(const char *, const char *, struct tm *);
-#endif
-
-// Unicode-friendly strptime() wrapper
-static const wxStringCharType *
-CallStrptime(const wxStringCharType *input, const char *fmt, tm *tm)
-{
- // the problem here is that strptime() returns pointer into the string we
- // passed to it while we're really interested in the pointer into the
- // original, Unicode, string so we try to transform the pointer back
-#if wxUSE_UNICODE_WCHAR
- wxCharBuffer inputMB(wxConvertWX2MB(input));
-#else // ASCII
- const char * const inputMB = input;
-#endif // Unicode/Ascii
-
- const char *result = strptime(inputMB, fmt, tm);
- if ( !result )
- return NULL;
-
-#if wxUSE_UNICODE_WCHAR
- // FIXME: this is wrong in presence of surrogates &c
- return input + (result - inputMB.data());
-#else // ASCII
- return result;
-#endif // Unicode/Ascii
-}
-
-#endif // HAVE_STRPTIME
+#endif // wxHAS_STRFTIME
// if year and/or month have invalid values, replace them with the current ones
static void ReplaceDefaultYearMonthWithCurrent(int *year,
}
}
-// fll the struct tm with default values
-static void InitTm(struct tm& tm)
+// fill the struct tm with default values
+// NOTE: not static because used by datetimefmt.cpp
+void InitTm(struct tm& tm)
{
// struct tm may have etxra fields (undocumented and with unportable
// names) which, nevertheless, must be set to 0
tm.tm_isdst = -1; // auto determine
}
-// parsing helpers
-// ---------------
-
-// return the month if the string is a month name or Inv_Month otherwise
-static wxDateTime::Month GetMonthFromName(const wxString& name, int flags)
-{
- wxDateTime::Month mon;
- for ( mon = wxDateTime::Jan; mon < wxDateTime::Inv_Month; wxNextMonth(mon) )
- {
- // case-insensitive comparison either one of or with both abbreviated
- // and not versions
- if ( flags & wxDateTime::Name_Full )
- {
- if ( name.CmpNoCase(wxDateTime::
- GetMonthName(mon, wxDateTime::Name_Full)) == 0 )
- {
- break;
- }
- }
-
- if ( flags & wxDateTime::Name_Abbr )
- {
- if ( name.CmpNoCase(wxDateTime::
- GetMonthName(mon, wxDateTime::Name_Abbr)) == 0 )
- {
- break;
- }
- }
- }
-
- return mon;
-}
-
-// return the weekday if the string is a weekday name or Inv_WeekDay otherwise
-static wxDateTime::WeekDay GetWeekDayFromName(const wxString& name, int flags)
-{
- wxDateTime::WeekDay wd;
- for ( wd = wxDateTime::Sun; wd < wxDateTime::Inv_WeekDay; wxNextWDay(wd) )
- {
- // case-insensitive comparison either one of or with both abbreviated
- // and not versions
- if ( flags & wxDateTime::Name_Full )
- {
- if ( name.CmpNoCase(wxDateTime::
- GetWeekDayName(wd, wxDateTime::Name_Full)) == 0 )
- {
- break;
- }
- }
-
- if ( flags & wxDateTime::Name_Abbr )
- {
- if ( name.CmpNoCase(wxDateTime::
- GetWeekDayName(wd, wxDateTime::Name_Abbr)) == 0 )
- {
- break;
- }
- }
- }
-
- return wd;
-}
-
-/* static */
-struct tm *wxDateTime::GetTmNow(struct tm *tmstruct)
-{
- time_t t = GetTimeNow();
- return wxLocaltime_r(&t, tmstruct);
-}
-
-// scans all digits (but no more than len) and returns the resulting number
-static bool GetNumericToken(size_t len,
- const wxStringCharType*& p,
- unsigned long *number)
-{
- size_t n = 1;
- wxString s;
- while ( wxIsdigit(*p) )
- {
- s += *p++;
-
- if ( len && ++n > len )
- break;
- }
-
- return !s.empty() && s.ToULong(number);
-}
-
-// scans all alphabetic characters and returns the resulting string
-static wxString GetAlphaToken(const wxStringCharType*& p)
-{
- wxString s;
- while ( wxIsalpha(*p) )
- {
- s += *p++;
- }
-
- return s;
-}
-
// ============================================================================
// implementation of wxDateTime
// ============================================================================
{
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") );
}
}
// static functions
// ----------------------------------------------------------------------------
+/* static */
+struct tm *wxDateTime::GetTmNow(struct tm *tmstruct)
+{
+ time_t t = GetTimeNow();
+ return wxLocaltime_r(&t, tmstruct);
+}
+
/* static */
bool wxDateTime::IsLeapYear(int year, wxDateTime::Calendar cal)
{
}
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;
}
}
+namespace
+{
+
+// helper function used by GetEnglish/WeekDayName(): returns 0 if flags is
+// Name_Full and 1 if it is Name_Abbr or -1 if the flags is incorrect (and
+// asserts in this case)
+//
+// the return value of this function is used as an index into 2D array
+// containing full names in its first row and abbreviated ones in the 2nd one
+int NameArrayIndexFromFlag(wxDateTime::NameFlags flags)
+{
+ switch ( flags )
+ {
+ case wxDateTime::Name_Full:
+ return 0;
+
+ case wxDateTime::Name_Abbr:
+ return 1;
+
+ default:
+ wxFAIL_MSG( "unknown wxDateTime::NameFlags value" );
+ }
+
+ return -1;
+}
+
+} // anonymous namespace
+
+/* static */
+wxString wxDateTime::GetEnglishMonthName(Month month, NameFlags flags)
+{
+ wxCHECK_MSG( month != Inv_Month, wxEmptyString, "invalid month" );
+
+ static const char *const monthNames[2][MONTHS_IN_YEAR] =
+ {
+ { "January", "February", "March", "April", "May", "June",
+ "July", "August", "September", "October", "November", "December" },
+ { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
+ "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" }
+ };
+
+ const int idx = NameArrayIndexFromFlag(flags);
+ if ( idx == -1 )
+ return wxString();
+
+ return monthNames[idx][month];
+}
+
/* static */
wxString wxDateTime::GetMonthName(wxDateTime::Month month,
wxDateTime::NameFlags flags)
{
- wxCHECK_MSG( month != Inv_Month, wxEmptyString, _T("invalid month") );
-#ifdef HAVE_STRFTIME
+#ifdef wxHAS_STRFTIME
+ 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)
tm tm;
InitTm(tm);
tm.tm_mon = month;
- return CallStrftime(flags == Name_Abbr ? _T("%b") : _T("%B"), &tm);
-#else // !HAVE_STRFTIME
- wxString ret;
- switch(month)
+ 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, wxT("invalid weekday") );
+
+ static const char *const weekdayNames[2][DAYS_PER_WEEK] =
{
- case Jan:
- ret = (flags == Name_Abbr ? wxT("Jan"): wxT("January"));
- break;
- case Feb:
- ret = (flags == Name_Abbr ? wxT("Feb"): wxT("Febuary"));
- break;
- case Mar:
- ret = (flags == Name_Abbr ? wxT("Mar"): wxT("March"));
- break;
- case Apr:
- ret = (flags == Name_Abbr ? wxT("Apr"): wxT("April"));
- break;
- case May:
- ret = (flags == Name_Abbr ? wxT("May"): wxT("May"));
- break;
- case Jun:
- ret = (flags == Name_Abbr ? wxT("Jun"): wxT("June"));
- break;
- case Jul:
- ret = (flags == Name_Abbr ? wxT("Jul"): wxT("July"));
- break;
- case Aug:
- ret = (flags == Name_Abbr ? wxT("Aug"): wxT("August"));
- break;
- case Sep:
- ret = (flags == Name_Abbr ? wxT("Sep"): wxT("September"));
- break;
- case Oct:
- ret = (flags == Name_Abbr ? wxT("Oct"): wxT("October"));
- break;
- case Nov:
- ret = (flags == Name_Abbr ? wxT("Nov"): wxT("November"));
- break;
- case Dec:
- ret = (flags == Name_Abbr ? wxT("Dec"): wxT("December"));
- break;
- }
- return ret;
-#endif // HAVE_STRFTIME/!HAVE_STRFTIME
+ { "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday",
+ "Saturday" },
+ { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" },
+ };
+
+ const int idx = NameArrayIndexFromFlag(flags);
+ if ( idx == -1 )
+ return wxString();
+
+ return weekdayNames[idx][wday];
}
/* static */
wxString wxDateTime::GetWeekDayName(wxDateTime::WeekDay wday,
wxDateTime::NameFlags flags)
{
- wxCHECK_MSG( wday != Inv_WeekDay, wxEmptyString, _T("invalid weekday") );
-#ifdef HAVE_STRFTIME
+#ifdef wxHAS_STRFTIME
+ 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
// take 28 here!)
(void)mktime(&tm);
// ... and call strftime()
- return CallStrftime(flags == Name_Abbr ? _T("%a") : _T("%A"), &tm);
-#else // !HAVE_STRFTIME
- wxString ret;
- switch(wday)
- {
- case Sun:
- ret = (flags == Name_Abbr ? wxT("Sun") : wxT("Sunday"));
- break;
- case Mon:
- ret = (flags == Name_Abbr ? wxT("Mon") : wxT("Monday"));
- break;
- case Tue:
- ret = (flags == Name_Abbr ? wxT("Tue") : wxT("Tuesday"));
- break;
- case Wed:
- ret = (flags == Name_Abbr ? wxT("Wed") : wxT("Wednesday"));
- break;
- case Thu:
- ret = (flags == Name_Abbr ? wxT("Thu") : wxT("Thursday"));
- break;
- case Fri:
- ret = (flags == Name_Abbr ? wxT("Fri") : wxT("Friday"));
- break;
- case Sat:
- ret = (flags == Name_Abbr ? wxT("Sat") : wxT("Saturday"));
- break;
- }
- return ret;
-#endif // HAVE_STRFTIME/!HAVE_STRFTIME
+ return CallStrftime(flags == Name_Abbr ? wxT("%a") : wxT("%A"), &tm);
+#else // !wxHAS_STRFTIME
+ return GetEnglishWeekDayName(wday, flags);
+#endif // wxHAS_STRFTIME/!wxHAS_STRFTIME
}
/* static */
// 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();
}
}
+
// ----------------------------------------------------------------------------
// Country stuff: date calculations depend on the country (DST, work days,
// ...), so we need to know which rules to follow.
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;
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?
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