Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

1. more wxDateTime work

Browse Source 
2. some thread corrections (not fixing the deadlock with Delete() :-( )


git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@4791 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Vadim Zeitlin
1999-12-01 22:15:53 +00:00
parent fa5f6926ec
commit fcc3d7cbad
7 changed files with 359 additions and 57 deletions
Download Patch File Download Diff File Expand all files Collapse all files

106
include/wx/datetime.h
View File

@@ -114,10 +114,45 @@ public:
// Note that GMT12 and GMT_12 are not the same: there is a difference // Note that GMT12 and GMT_12 are not the same: there is a difference
// of exactly one day between them // of exactly one day between them
// Universal Coordinated Time // some symbolic names for TZ
UTC = GMT0
// TODO add symbolic names for TZ (EST, MET, ...)? // Europe
WET = GMT0, // Western Europe Time
WEST = GMT1, // Western Europe Summer Time
CET = GMT1, // Central Europe Time
CEST = GMT2, // Central Europe Summer Time
EET = GMT2, // Eastern Europe Time
EEST = GMT3, // Eastern Europe Summer Time
MSK = GMT3, // Moscow Time
MSD = GMT4, // Moscow Summer Time
// US and Canada
AST = GMT_4, // Atlantic Standard Time
ADT = GMT_3, // Atlantic Daylight Time
EST = GMT_5, // Eastern Standard Time
EDT = GMT_4, // Eastern Daylight Saving Time
CST = GMT_6, // Central Standard Time
CDT = GMT_5, // Central Daylight Saving Time
MST = GMT_7, // Mountain Standard Time
MDT = GMT_6, // Mountain Daylight Saving Time
PST = GMT_8, // Pacific Standard Time
PDT = GMT_7, // Pacific Daylight Saving Time
HST = GMT_10, // Hawaiian Standard Time
AKST = GMT_9, // Alaska Standard Time
AKDT = GMT_8, // Alaska Daylight Saving Time
// Australia
A_WST = GMT8, // Western Standard Time
A_CST = GMT12 + 1, // Central Standard Time (+9.5)
A_EST = GMT10, // Eastern Standard Time
A_ESST = GMT11, // Eastern Summer Time
// TODO add more symbolic timezone names here
// Universal Coordinated Time = the new and politically correct name
// for GMT
UTC = GMT0
}; };
// the calendar systems we know about: notice that it's valid (for // the calendar systems we know about: notice that it's valid (for
@@ -290,10 +325,15 @@ public:
// standard struct tm is limited to the years from 1900 (because // standard struct tm is limited to the years from 1900 (because
// tm_year field is the offset from 1900), so we use our own struct // tm_year field is the offset from 1900), so we use our own struct
// instead to represent broken down time // instead to represent broken down time
//
// NB: this struct should always be kept normalized (i.e. mon should
// be < 12, 1 <= day <= 31 &c), so use AddMonths(), AddDays()
// instead of modifying the member fields directly!
struct Tm struct Tm
{ {
wxDateTime_t sec, min, hour, wxDateTime_t sec, min, hour, mday;
mday, mon, year; Month mon;
int year;
// default ctor inits the object to an invalid value // default ctor inits the object to an invalid value
Tm(); Tm();
@@ -313,6 +353,12 @@ public:
return (WeekDay)wday; return (WeekDay)wday;
} }
// add the given number of months to the date keeping it normalized
void AddMonths(wxDateTime_t monDiff);
// add the given number of months to the date keeping it normalized
void AddDays(wxDateTime_t dayDiff);
private: private:
// compute the weekday from other fields // compute the weekday from other fields
void ComputeWeekDay(); void ComputeWeekDay();
@@ -330,11 +376,11 @@ public:
TimeZone(TZ tz); TimeZone(TZ tz);
TimeZone(wxDateTime_t offset) { m_offset = offset; } TimeZone(wxDateTime_t offset) { m_offset = offset; }
wxDateTime_t GetOffset() const { return m_offset; } int GetOffset() const { return m_offset; }
private: private:
// offset for this timezone from GMT in minutes // offset for this timezone from GMT in minutes
wxDateTime_t m_offset; int m_offset;
}; };
// static methods // static methods
@@ -558,18 +604,24 @@ public:
// anything else, it should be requested explicitly // anything else, it should be requested explicitly
// ------------------------------------------------------------------------ // ------------------------------------------------------------------------
// get the time corresponding to this one in UTC/GMT
wxDateTime ToUTC() const;
wxDateTime ToGMT() const { return ToUTC(); }
// transform this object to UTC/GMT // transform this object to UTC/GMT
wxDateTime& MakeUTC(); wxDateTime& MakeUTC();
wxDateTime& MakeGMT() { return MakeUTC(); } wxDateTime& MakeGMT() { return MakeUTC(); }
// generic version: transform time to any given timezone // get the time corresponding to this one in UTC/GMT
wxDateTime ToTimezone(const TimeZone& tz); inline wxDateTime ToUTC() const;
wxDateTime ToGMT() const { return ToUTC(); }
// generic versions of the above
// transform from local time to any given timezone
inline wxDateTime ToTimezone(const TimeZone& tz) const;
wxDateTime& MakeTimezone(const TimeZone& tz); wxDateTime& MakeTimezone(const TimeZone& tz);
// transform time from any timezone to the local time
inline wxDateTime ToLocalTime(const TimeZone& tz) const;
wxDateTime& MakeLocalTime(const TimeZone& tz);
// accessors: many of them take the timezone parameter which indicates the // accessors: many of them take the timezone parameter which indicates the
// timezone for which to make the calculations and the default value means // timezone for which to make the calculations and the default value means
// to do it for the current timezone of this machine (even if the function // to do it for the current timezone of this machine (even if the function
@@ -741,7 +793,7 @@ private:
// returns TRUE if we fall in range in which we can use standard ANSI C // returns TRUE if we fall in range in which we can use standard ANSI C
// functions // functions
inline IsInStdRange() const; inline bool IsInStdRange() const;
// the internal representation of the time is the amount of milliseconds // the internal representation of the time is the amount of milliseconds
// elapsed since the origin which is set by convention to the UNIX/C epoch // elapsed since the origin which is set by convention to the UNIX/C epoch
@@ -761,22 +813,22 @@ public:
// constructors // constructors
// ------------------------------------------------------------------------ // ------------------------------------------------------------------------
// return the timespan for the given number of seconds
static wxTimeSpan Seconds(int sec) { return wxTimeSpan(0, 0, sec); }
// return the timespan for the given number of minutes
static wxTimeSpan Minutes(int min) { return wxTimeSpan(0, min, 0 ); }
// return the timespan for the given number of hours
static wxTimeSpan Hours(int hours) { return wxTimeSpan(hours, 0, 0); }
// default ctor constructs the 0 time span // default ctor constructs the 0 time span
wxTimeSpan() { } wxTimeSpan() { }
// from separate values for each component, date set to 0 (hours are // from separate values for each component, date set to 0 (hours are
// not restricted to 0..24 range, neither are minutes, seconds or // not restricted to 0..24 range, neither are minutes, seconds or
// milliseconds) // milliseconds)
wxTimeSpan(int hours, inline wxTimeSpan(int hours,
int minutes = 0,
int seconds = 0,
int milliseconds = 0);
// from separate values for each component with explicit date (none of
// the parameters isn't restricted to any range)
wxTimeSpan(int years,
int months,
int days,
int hours = 0,
int minutes = 0, int minutes = 0,
int seconds = 0, int seconds = 0,
int milliseconds = 0); int milliseconds = 0);
@@ -879,11 +931,11 @@ public:
// resulting text representation. Notice that only some of format // resulting text representation. Notice that only some of format
// specifiers valid for wxDateTime are valid for wxTimeSpan: hours, // specifiers valid for wxDateTime are valid for wxTimeSpan: hours,
// minutes and seconds make sense, but not "PM/AM" string for example. // minutes and seconds make sense, but not "PM/AM" string for example.
wxString Format(const char *format = "%c") const; wxString Format(const wxChar *format = _T("%c")) const;
// preferred date representation for the current locale // preferred date representation for the current locale
wxString FormatDate() const { return Format("%x"); } wxString FormatDate() const { return Format(_T("%x")); }
// preferred time representation for the current locale // preferred time representation for the current locale
wxString FormatTime() const { return Format("%X"); } wxString FormatTime() const { return Format(_T("%X")); }
// implementation // implementation
// ------------------------------------------------------------------------ // ------------------------------------------------------------------------

34
include/wx/datetime.inl
View File

@@ -35,7 +35,7 @@ wxDateTime::Country wxDateTime::GetCountry()
const unsigned int wxDateTime::TIME_T_FACTOR = 1000; const unsigned int wxDateTime::TIME_T_FACTOR = 1000;
#endif // wxDEFINE_TIME_CONSTANTS #endif // wxDEFINE_TIME_CONSTANTS
wxDateTime::IsInStdRange() const bool wxDateTime::IsInStdRange() const
{ {
return m_time >= 0l && (m_time / (long)TIME_T_FACTOR) < LONG_MAX; return m_time >= 0l && (m_time / (long)TIME_T_FACTOR) < LONG_MAX;
} }
@@ -237,10 +237,41 @@ wxDateTime& wxDateTime::operator+=(const wxDateSpan& diff)
return Add(diff); return Add(diff);
} }
// ----------------------------------------------------------------------------
// wxDateTime and timezones
// ----------------------------------------------------------------------------
wxDateTime wxDateTime::ToUTC() const
{
return wxDateTime(*this).MakeUTC();
}
wxDateTime wxDateTime::ToTimezone(const wxDateTime::TimeZone& tz) const
{
return wxDateTime(*this).MakeTimezone(tz);
}
wxDateTime wxDateTime::ToLocalTime(const wxDateTime::TimeZone& tz) const
{
return wxDateTime(*this).MakeLocalTime(tz);
}
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// wxTimeSpan // wxTimeSpan
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
wxTimeSpan::wxTimeSpan(int hours, int minutes, int seconds, int milliseconds)
{
// assign first to avoid precision loss
m_diff = hours;
m_diff *= 60;
m_diff += minutes;
m_diff *= 60;
m_diff += seconds;
m_diff *= 1000;
m_diff += milliseconds;
}
wxTimeSpan& wxTimeSpan::Add(const wxTimeSpan& diff) wxTimeSpan& wxTimeSpan::Add(const wxTimeSpan& diff)
{ {
m_diff += diff.GetValue(); m_diff += diff.GetValue();
@@ -325,4 +356,3 @@ wxDateSpan& wxDateSpan::Neg()
return *this; return *this;
} }

4
include/wx/longlong.h
View File

@@ -254,8 +254,10 @@ public:
// conversion to byte array: returns a pointer to static buffer! // conversion to byte array: returns a pointer to static buffer!
void *asArray() const; void *asArray() const;
#if wxUSE_STD_IOSTREAM
// input/output // input/output
friend ostream& operator<<(ostream&, const wxLongLongNative&); friend ostream& operator<<(ostream&, const wxLongLongNative&);
#endif
private: private:
wxLongLong_t m_ll; wxLongLong_t m_ll;
@@ -356,8 +358,10 @@ public:
wxLongLongWx& quotient, wxLongLongWx& quotient,
wxLongLongWx& remainder) const; wxLongLongWx& remainder) const;
#if wxUSE_STD_IOSTREAM
// input/output // input/output
friend ostream& operator<<(ostream&, const wxLongLongWx&); friend ostream& operator<<(ostream&, const wxLongLongWx&);
#endif // wxUSE_STD_IOSTREAM
private: private:
// long is at least 32 bits, so represent our 64bit number as 2 longs // long is at least 32 bits, so represent our 64bit number as 2 longs

40
samples/console/console.cpp
View File

@@ -32,8 +32,8 @@
//#define TEST_ARRAYS //#define TEST_ARRAYS
//#define TEST_LOG //#define TEST_LOG
//#define TEST_STRINGS //#define TEST_STRINGS
//#define TEST_THREADS #define TEST_THREADS
#define TEST_TIME //#define TEST_TIME
//#define TEST_LONGLONG //#define TEST_LONGLONG
// ============================================================================ // ============================================================================
@@ -144,8 +144,8 @@ static void TestTimeStatic()
wxDateTime::GetNumberOfDays(month)); wxDateTime::GetNumberOfDays(month));
// leap year logic // leap year logic
static const nYears = 5; static const size_t nYears = 5;
static const int years[2][nYears] = static const size_t years[2][nYears] =
{ {
// first line: the years to test // first line: the years to test
{ 1990, 1976, 2000, 2030, 1984, }, { 1990, 1976, 2000, 2030, 1984, },
@@ -179,6 +179,20 @@ static void TestTimeSet()
printf("May 29, 1976:\t%s\n", wxDateTime(29, wxDateTime::May, 1976).Format().c_str()); printf("May 29, 1976:\t%s\n", wxDateTime(29, wxDateTime::May, 1976).Format().c_str());
} }
// test time zones stuff
static void TestTimeZones()
{
puts("\n*** wxDateTime timezone test ***");
wxDateTime now = wxDateTime::Now();
printf("Current GMT time:\t%s\n", now.ToGMT().Format().c_str());
//printf("Unix epoch (GMT):\t%s\n", wxDateTime((time_t)0).MakeGMT().Format().c_str());
printf("Current time in Paris:\t%s\n", now.ToTimezone(wxDateTime::CET).Format().c_str());
printf(" Moscow:\t%s\n", now.ToTimezone(wxDateTime::MSK).Format().c_str());
printf(" New York:\t%s\n", now.ToTimezone(wxDateTime::EST).Format().c_str());
}
#endif // TEST_TIME #endif // TEST_TIME
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
@@ -223,7 +237,14 @@ wxThread::ExitCode MyJoinableThread::Entry()
class MyDetachedThread : public wxThread class MyDetachedThread : public wxThread
{ {
public: public:
MyDetachedThread(size_t n, char ch) { m_n = n; m_ch = ch; Create(); } MyDetachedThread(size_t n, char ch)
{
m_n = n;
m_ch = ch;
m_cancelled = FALSE;
Create();
}
// thread execution starts here // thread execution starts here
virtual ExitCode Entry(); virtual ExitCode Entry();
@@ -234,6 +255,8 @@ public:
private: private:
size_t m_n; // number of characters to write size_t m_n; // number of characters to write
char m_ch; // character to write char m_ch; // character to write
bool m_cancelled; // FALSE if we exit normally
}; };
wxThread::ExitCode MyDetachedThread::Entry() wxThread::ExitCode MyDetachedThread::Entry()
@@ -249,7 +272,11 @@ wxThread::ExitCode MyDetachedThread::Entry()
for ( size_t n = 0; n < m_n; n++ ) for ( size_t n = 0; n < m_n; n++ )
{ {
if ( TestDestroy() ) if ( TestDestroy() )
{
m_cancelled = TRUE;
break; break;
}
putchar(m_ch); putchar(m_ch);
fflush(stdout); fflush(stdout);
@@ -265,7 +292,7 @@ void MyDetachedThread::OnExit()
wxLogTrace("thread", "Thread %ld is in OnExit", GetId()); wxLogTrace("thread", "Thread %ld is in OnExit", GetId());
wxCriticalSectionLocker lock(gs_critsect); wxCriticalSectionLocker lock(gs_critsect);
if ( !--gs_counter ) if ( !--gs_counter && !m_cancelled )
gs_cond.Signal(); gs_cond.Signal();
} }
@@ -565,6 +592,7 @@ int main(int argc, char **argv)
#ifdef TEST_TIME #ifdef TEST_TIME
TestTimeStatic(); TestTimeStatic();
TestTimeSet(); TestTimeSet();
TestTimeZones();
#endif // TEST_TIME #endif // TEST_TIME
wxUninitialize(); wxUninitialize();

199
src/common/datetime.cpp
View File

@@ -34,6 +34,8 @@
#include "wx/log.h" #include "wx/log.h"
#endif // WX_PRECOMP #endif // WX_PRECOMP
#include "wx/thread.h"
#define wxDEFINE_TIME_CONSTANTS #define wxDEFINE_TIME_CONSTANTS
#include "wx/datetime.h" #include "wx/datetime.h"
@@ -42,18 +44,59 @@
// constants // constants
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// note that all these constants should be signed or we'd get some big
// surprizes with C integer arithmetics
static const int MONTHS_IN_YEAR = 12;
static const int SECONDS_IN_MINUTE = 60;
// the number of days in month in Julian/Gregorian calendar: the first line is // 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 // for normal years, the second one is for the leap ones
static wxDateTime::wxDateTime_t gs_daysInMonth[2][12] = static wxDateTime::wxDateTime_t gs_daysInMonth[2][MONTHS_IN_YEAR] =
{ {
{ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }, { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
{ 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 } { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
}; };
// ----------------------------------------------------------------------------
// globals
// ----------------------------------------------------------------------------
// a critical section is needed to protect GetTimeZone() static
// variable in MT case
#ifdef wxUSE_THREADS
wxCriticalSection gs_critsectTimezone;
#endif // wxUSE_THREADS
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// private functions // private functions
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// get the number of days in the given month of the given year
static inline
wxDateTime::wxDateTime_t GetNumOfDaysInMonth(int year, wxDateTime::Month month)
{
return gs_daysInMonth[wxDateTime::IsLeapYear(year)][month];
}
// ensure that the timezone variable is set by calling localtime
static int GetTimeZone()
{
// set to TRUE when the timezone is set
static bool s_timezoneSet = FALSE;
wxCRIT_SECT_LOCKER(lock, gs_critsectTimezone);
if ( !s_timezoneSet )
{
(void)localtime(0);
s_timezoneSet = TRUE;
}
return (int)timezone;
}
// this function is a wrapper around strftime(3) // this function is a wrapper around strftime(3)
static wxString CallStrftime(const wxChar *format, const tm* tm) static wxString CallStrftime(const wxChar *format, const tm* tm)
{ {
@@ -119,7 +162,7 @@ wxDateTime::Tm::Tm(const struct tm& tm)
min = tm.tm_min; min = tm.tm_min;
hour = tm.tm_hour; hour = tm.tm_hour;
mday = tm.tm_mday; mday = tm.tm_mday;
mon = tm.tm_mon; mon = (wxDateTime::Month)tm.tm_mon;
year = 1900 + tm.tm_year; year = 1900 + tm.tm_year;
wday = tm.tm_wday; wday = tm.tm_wday;
yday = tm.tm_yday; yday = tm.tm_yday;
@@ -128,8 +171,8 @@ wxDateTime::Tm::Tm(const struct tm& tm)
bool wxDateTime::Tm::IsValid() const bool wxDateTime::Tm::IsValid() const
{ {
// we allow for the leap seconds, although we don't use them (yet) // we allow for the leap seconds, although we don't use them (yet)
return (year != wxDateTime::Inv_Year) && (mon < 12) && return (year != wxDateTime::Inv_Year) && (mon != wxDateTime::Inv_Month) &&
(mday < gs_daysInMonth[IsLeapYear(year)][mon]) && (mday < GetNumOfDaysInMonth(year, mon)) &&
(hour < 24) && (min < 60) && (sec < 62); (hour < 24) && (min < 60) && (sec < 62);
} }
@@ -138,6 +181,101 @@ void wxDateTime::Tm::ComputeWeekDay()
wxFAIL_MSG(_T("TODO")); wxFAIL_MSG(_T("TODO"));
} }
void wxDateTime::Tm::AddMonths(wxDateTime::wxDateTime_t monDiff)
{
// normalize the months field
while ( monDiff < -mon )
{
year--;
monDiff += MONTHS_IN_YEAR;
}
while ( monDiff + mon > MONTHS_IN_YEAR )
{
year++;
}
mon = (wxDateTime::Month)(mon + monDiff);
wxASSERT_MSG( mon >= 0 && mon < 12, _T("logic error") );
}
void wxDateTime::Tm::AddDays(wxDateTime::wxDateTime_t dayDiff)
{
// normalize the days field
mday += dayDiff;
while ( mday < 1 )
{
AddMonths(-1);
mday += GetNumOfDaysInMonth(year, mon);
}
while ( mday > GetNumOfDaysInMonth(year, mon) )
{
mday -= GetNumOfDaysInMonth(year, mon);
AddMonths(1);
}
wxASSERT_MSG( mday > 0 && mday <= GetNumOfDaysInMonth(year, mon),
_T("logic error") );
}
// ----------------------------------------------------------------------------
// class TimeZone
// ----------------------------------------------------------------------------
wxDateTime::TimeZone::TimeZone(wxDateTime::TZ tz)
{
switch ( tz )
{
case wxDateTime::Local:
// leave offset to be 0
break;
case wxDateTime::GMT_12:
case wxDateTime::GMT_11:
case wxDateTime::GMT_10:
case wxDateTime::GMT_9:
case wxDateTime::GMT_8:
case wxDateTime::GMT_7:
case wxDateTime::GMT_6:
case wxDateTime::GMT_5:
case wxDateTime::GMT_4:
case wxDateTime::GMT_3:
case wxDateTime::GMT_2:
case wxDateTime::GMT_1:
m_offset = -60*(wxDateTime::GMT0 - tz);
break;
case wxDateTime::GMT0:
case wxDateTime::GMT1:
case wxDateTime::GMT2:
case wxDateTime::GMT3:
case wxDateTime::GMT4:
case wxDateTime::GMT5:
case wxDateTime::GMT6:
case wxDateTime::GMT7:
case wxDateTime::GMT8:
case wxDateTime::GMT9:
case wxDateTime::GMT10:
case wxDateTime::GMT11:
case wxDateTime::GMT12:
m_offset = 60*(tz - wxDateTime::GMT0);
break;
case wxDateTime::A_CST:
// Central Standard Time in use in Australia = UTC + 9.5
m_offset = 9*60 + 30;
break;
default:
wxFAIL_MSG( _T("unknown time zone") );
}
}
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// static functions // static functions
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
@@ -169,6 +307,12 @@ bool wxDateTime::IsLeapYear(int year, wxDateTime::Calendar cal)
} }
} }
/* static */
int wxDateTime::GetCentury(int year)
{
return year > 0 ? year / 100 : year / 100 - 1;
}
/* static */ /* static */
void wxDateTime::SetCountry(wxDateTime::Country country) void wxDateTime::SetCountry(wxDateTime::Country country)
{ {
@@ -252,7 +396,7 @@ wxDateTime::wxDateTime_t wxDateTime::GetNumberOfDays(wxDateTime::Month month,
int year, int year,
wxDateTime::Calendar cal) wxDateTime::Calendar cal)
{ {
wxCHECK_MSG( month < 12, 0, _T("invalid month") ); wxCHECK_MSG( month < MONTHS_IN_YEAR, 0, _T("invalid month") );
if ( cal == Gregorian || cal == Julian ) if ( cal == Gregorian || cal == Julian )
{ {
@@ -262,7 +406,7 @@ wxDateTime::wxDateTime_t wxDateTime::GetNumberOfDays(wxDateTime::Month month,
year = GetCurrentYear(); year = GetCurrentYear();
} }
return gs_daysInMonth[IsLeapYear(year)][month]; return GetNumOfDaysInMonth(year, month);
} }
else else
{ {
@@ -391,8 +535,7 @@ wxDateTime& wxDateTime::Set(wxDateTime_t day,
else else
{ {
// do time calculations ourselves: we want to calculate the number of // do time calculations ourselves: we want to calculate the number of
// milliseconds between the given date and the epoch (necessarily // milliseconds between the given date and the epoch
// negative)
wxFAIL_MSG(_T("TODO")); wxFAIL_MSG(_T("TODO"));
} }
@@ -512,8 +655,8 @@ wxDateTime& wxDateTime::Add(const wxDateSpan& diff)
Tm tm(GetTm()); Tm tm(GetTm());
tm.year += diff.GetYears(); tm.year += diff.GetYears();
tm.mon += diff.GetMonths(); tm.AddMonths(diff.GetMonths());
tm.mday += diff.GetTotalDays(); tm.AddDays(diff.GetTotalDays());
Set(tm); Set(tm);
@@ -530,7 +673,7 @@ wxDateTime& wxDateTime::SetToLastMonthDay(Month month,
// take the current month/year if none specified // take the current month/year if none specified
ReplaceDefaultYearMonthWithCurrent(&year, &month); ReplaceDefaultYearMonthWithCurrent(&year, &month);
return Set(gs_daysInMonth[IsLeapYear(year)][month], month, year); return Set(GetNumOfDaysInMonth(year, month), month, year);
} }
bool wxDateTime::SetToWeekDay(WeekDay weekday, bool wxDateTime::SetToWeekDay(WeekDay weekday,
@@ -601,6 +744,27 @@ bool wxDateTime::SetToWeekDay(WeekDay weekday,
} }
} }
// ----------------------------------------------------------------------------
// timezone stuff
// ----------------------------------------------------------------------------
wxDateTime& wxDateTime::MakeUTC()
{
return Add(wxTimeSpan::Seconds(GetTimeZone()));
}
wxDateTime& wxDateTime::MakeTimezone(const TimeZone& tz)
{
int minDiff = GetTimeZone() / SECONDS_IN_MINUTE + tz.GetOffset();
return Add(wxTimeSpan::Minutes(minDiff));
}
wxDateTime& wxDateTime::MakeLocalTime(const TimeZone& tz)
{
int minDiff = GetTimeZone() / SECONDS_IN_MINUTE + tz.GetOffset();
return Substract(wxTimeSpan::Minutes(minDiff));
}
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// wxDateTime to/from text representations // wxDateTime to/from text representations
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
@@ -625,3 +789,16 @@ wxString wxDateTime::Format(const wxChar *format) const
return _T(""); return _T("");
} }
} }
// ============================================================================
// wxTimeSpan
// ============================================================================
wxString wxTimeSpan::Format(const wxChar *format) const
{
wxFAIL_MSG( _T("TODO") );
wxString str;
return str;
}

12
src/common/longlong.cpp
View File

@@ -57,6 +57,8 @@ void *wxLongLongNative::asArray(void) const
return temp; return temp;
} }
#if wxUSE_STD_IOSTREAM
// input/output // input/output
ostream& operator<< (ostream& o, const wxLongLongNative& ll) ostream& operator<< (ostream& o, const wxLongLongNative& ll)
{ {
@@ -74,6 +76,8 @@ ostream& operator<< (ostream& o, const wxLongLongNative& ll)
return o << result; return o << result;
} }
#endif // wxUSE_STD_IOSTREAM
#endif // wxUSE_LONGLONG_NATIVE #endif // wxUSE_LONGLONG_NATIVE
#if wxUSE_LONGLONG_WX #if wxUSE_LONGLONG_WX
@@ -449,8 +453,9 @@ void *wxLongLongWx::asArray(void) const
return temp; return temp;
} }
// input/output #if wxUSE_STD_IOSTREAM
// input/output
ostream& operator<< (ostream& o, const wxLongLongWx& ll) ostream& operator<< (ostream& o, const wxLongLongWx& ll)
{ {
char result[65]; char result[65];
@@ -467,7 +472,8 @@ ostream& operator<< (ostream& o, const wxLongLongWx& ll)
return o << result; return o << result;
} }
#endif #endif // wxUSE_STD_IOSTREAM
// wxUSE_LONGLONG_NATIVE
#endif // wxUSE_LONGLONG_NATIVE
#endif // wxUSE_LONGLONG #endif // wxUSE_LONGLONG

15
src/unix/threadpsx.cpp
View File

@@ -24,9 +24,7 @@
#pragma implementation "thread.h" #pragma implementation "thread.h"
#endif #endif
// With simple makefiles, we must ignore the file body if not using #include "wx/defs.h"
// threads.
#include "wx/setup.h"
#if wxUSE_THREADS #if wxUSE_THREADS
@@ -586,6 +584,9 @@ void wxThreadInternal::Wait()
if ( wxThread::IsMain() ) if ( wxThread::IsMain() )
wxMutexGuiLeave(); wxMutexGuiLeave();
wxLogTrace(TRACE_THREADS, _T("Starting to wait for thread %ld to exit."),
GetId());
// wait until the thread terminates (we're blocking in _another_ thread, // wait until the thread terminates (we're blocking in _another_ thread,
// of course) // of course)
m_condEnd.Wait(); m_condEnd.Wait();
@@ -622,6 +623,9 @@ void wxThreadInternal::SignalExit()
// wake up all the threads waiting for our termination - if there are any // wake up all the threads waiting for our termination - if there are any
if ( m_shouldBroadcast ) if ( m_shouldBroadcast )
{ {
wxLogTrace(TRACE_THREADS, _T("Thread %ld signals end condition."),
GetId());
m_condEnd.Broadcast(); m_condEnd.Broadcast();
} }
} }
@@ -1243,8 +1247,9 @@ static void ScheduleThreadForDeletion()
gs_nThreadsBeingDeleted++; gs_nThreadsBeingDeleted++;
wxLogTrace(TRACE_THREADS, _T("%u threads waiting to be deleted"), wxLogTrace(TRACE_THREADS, _T("%u thread%s waiting to be deleted"),
gs_nThreadsBeingDeleted); gs_nThreadsBeingDeleted,
gs_nThreadsBeingDeleted == 1 ? "" : "s");
} }
static void DeleteThread(wxThread *This) static void DeleteThread(wxThread *This)