debug check for infinite loop in InitializeClasses() added

[wxWidgets.git] / src / common / datetime.cpp

diff --git a/src/common/datetime.cpp b/src/common/datetime.cpp
index 901156a569d02ab5d00b29a6c97e70ae9f702545..e623c60294ca2ff3326aa19acc7d150ac3f12603 100644 (file)
--- a/src/common/datetime.cpp
+++ b/src/common/datetime.cpp
@@ -1,13 +1,39 @@
-/////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////

 // Name:        wx/datetime.h
 // Purpose:     implementation of time/date related classes
 // Author:      Vadim Zeitlin
 // Modified by:
 // Created:     11.05.99
 // RCS-ID:      $Id$
 // Name:        wx/datetime.h
 // Purpose:     implementation of time/date related classes
 // Author:      Vadim Zeitlin
 // Modified by:
 // Created:     11.05.99
 // RCS-ID:      $Id$

-// Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
+// Copyright:   (c) 1999 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
+//              parts of code taken from sndcal library by Scott E. Lee:
+//
+//               Copyright 1993-1995, Scott E. Lee, all rights reserved.
+//               Permission granted to use, copy, modify, distribute and sell
+//               so long as the above copyright and this permission statement
+//               are retained in all copies.
+//

 // Licence:     wxWindows license
 // Licence:     wxWindows license

-/////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+/*
+ * Implementation notes:
+ *
+ * 1. the time is stored as a 64bit integer containing the signed number of
+ *    milliseconds since Jan 1. 1970 (the Unix Epoch)
+ *
+ * 2. the range is thus something about 580 million years, but due to current
+ *    algorithms limitations, only dates from Nov 24, 4714BC are handled
+ *
+ * 3. standard ANSI C functions are used to do time calculations whenever
+ *    possible, i.e. when the date is in the range Jan 1, 1970 to 2038
+ *
+ * 4. otherwise, the calculations are done by converting the date to/from JDN
+ *    first (the range limitation mentioned above comes from here: the
+ *    algorithm used by Scott E. Lee's code only works for positive JDNs, more
+ *    or less)
+ *
+ */

 
 // ============================================================================
 // declarations
 
 // ============================================================================
 // declarations


@@ -44,19 +70,30 @@
 // constants
 // ----------------------------------------------------------------------------
 
 // constants
 // ----------------------------------------------------------------------------
 

-// note that all these constants should be signed or we'd get some big
-// surprizes with C integer arithmetics
+// some trivial ones

 static const int MONTHS_IN_YEAR = 12;
 
 static const int SECONDS_IN_MINUTE = 60;
 
 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
-// for normal years, the second one is for the leap ones
-static wxDateTime::wxDateTime_t gs_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 }
-};
+static const long SECONDS_PER_DAY = 86400l;
+
+static const long MILLISECONDS_PER_DAY = 86400000l;
+
+// this is the integral part of JDN of the midnight of Jan 1, 1970
+// (i.e. JDN(Jan 1, 1970) = 2440587.5)
+static const int EPOCH_JDN = 2440587;
+
+// 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;
+
+// the constants used for JDN calculations
+static const int JDN_OFFSET         = 32046;
+static const int DAYS_PER_5_MONTHS  = 153;
+static const int DAYS_PER_4_YEARS   = 1461;
+static const int DAYS_PER_400_YEARS = 146097;

 
 // ----------------------------------------------------------------------------
 // globals
 
 // ----------------------------------------------------------------------------
 // globals


@@ -76,7 +113,15 @@ static wxDateTime::wxDateTime_t gs_daysInMonth[2][MONTHS_IN_YEAR] =
 static inline
 wxDateTime::wxDateTime_t GetNumOfDaysInMonth(int year, wxDateTime::Month month)
 {
 static inline
 wxDateTime::wxDateTime_t GetNumOfDaysInMonth(int year, wxDateTime::Month month)
 {

-    return gs_daysInMonth[wxDateTime::IsLeapYear(year)][month];
+    // 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] =
+    {
+        { 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];

 }
 
 // ensure that the timezone variable is set by calling localtime
 }
 
 // ensure that the timezone variable is set by calling localtime


@@ -89,7 +134,10 @@ static int GetTimeZone()
 
     if ( !s_timezoneSet )
     {
 
     if ( !s_timezoneSet )
     {

-        (void)localtime(0);
+        // just call localtime() instead of figuring out whether this system
+        // supports tzset(), _tzset() or something else
+        time_t t;
+        (void)localtime(&t);

 
         s_timezoneSet = TRUE;
     }
 
         s_timezoneSet = TRUE;
     }


@@ -97,6 +145,46 @@ static int GetTimeZone()
     return (int)timezone;
 }
 
     return (int)timezone;
 }
 

+// 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)
+static long GetTruncatedJDN(wxDateTime::wxDateTime_t day,
+                            wxDateTime::Month mon,
+                            int year)
+{
+    // CREDIT: code below is by Scott E. Lee (but bugs are mine)
+
+    // check the date validity
+    wxASSERT_MSG(
+      (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")
+                );
+
+    // make the year positive to avoid problems with negative numbers division
+    year += 4800;
+
+    // months are counted from March here
+    int month;
+    if ( mon >= wxDateTime::Mar )
+    {
+        month = mon - 2;
+    }
+    else
+    {
+        month = mon + 10;
+        year--;
+    }
+
+    // now we can simply add all the contributions together
+    return ((year / 100) * DAYS_PER_400_YEARS) / 4
+            + ((year % 100) * DAYS_PER_4_YEARS) / 4
+            + (month * DAYS_PER_5_MONTHS + 2) / 5
+            + day
+            - JDN_OFFSET;
+}
+

 // this function is a wrapper around strftime(3)
 static wxString CallStrftime(const wxChar *format, const tm* tm)
 {
 // this function is a wrapper around strftime(3)
 static wxString CallStrftime(const wxChar *format, const tm* tm)
 {


@@ -152,12 +240,13 @@ wxDateTime::Tm::Tm()
     year = (wxDateTime_t)wxDateTime::Inv_Year;
     mon = wxDateTime::Inv_Month;
     mday = 0;
     year = (wxDateTime_t)wxDateTime::Inv_Year;
     mon = wxDateTime::Inv_Month;
     mday = 0;

-    hour = min = sec = 0;
+    hour = min = sec = msec = 0;

     wday = wxDateTime::Inv_WeekDay;
 }
 
 wxDateTime::Tm::Tm(const struct tm& tm)
 {
     wday = wxDateTime::Inv_WeekDay;
 }
 
 wxDateTime::Tm::Tm(const struct tm& tm)
 {

+    msec = 0;

     sec = tm.tm_sec;
     min = tm.tm_min;
     hour = tm.tm_hour;
     sec = tm.tm_sec;
     min = tm.tm_min;
     hour = tm.tm_hour;


@@ -173,7 +262,7 @@ bool wxDateTime::Tm::IsValid() const
     // 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)) &&
     // 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)) &&

-           (hour < 24) && (min < 60) && (sec < 62);
+           (hour < 24) && (min < 60) && (sec < 62) && (msec < 1000);

 }
 
 void wxDateTime::Tm::ComputeWeekDay()
 }
 
 void wxDateTime::Tm::ComputeWeekDay()


@@ -181,7 +270,7 @@ void wxDateTime::Tm::ComputeWeekDay()
     wxFAIL_MSG(_T("TODO"));
 }
 
     wxFAIL_MSG(_T("TODO"));
 }
 

-void wxDateTime::Tm::AddMonths(wxDateTime::wxDateTime_t monDiff)
+void wxDateTime::Tm::AddMonths(int monDiff)

 {
     // normalize the months field
     while ( monDiff < -mon )
 {
     // normalize the months field
     while ( monDiff < -mon )


@@ -198,10 +287,10 @@ void wxDateTime::Tm::AddMonths(wxDateTime::wxDateTime_t monDiff)
 
     mon = (wxDateTime::Month)(mon + monDiff);
 
 
     mon = (wxDateTime::Month)(mon + monDiff);
 

-    wxASSERT_MSG( mon >= 0 && mon < 12, _T("logic error") );
+    wxASSERT_MSG( mon >= 0 && mon < MONTHS_IN_YEAR, _T("logic error") );

 }
 
 }
 

-void wxDateTime::Tm::AddDays(wxDateTime::wxDateTime_t dayDiff)
+void wxDateTime::Tm::AddDays(int dayDiff)

 {
     // normalize the days field
     mday += dayDiff;
 {
     // normalize the days field
     mday += dayDiff;


@@ -434,7 +523,7 @@ wxString wxDateTime::GetWeekDayName(wxDateTime::WeekDay wday, bool abbr)
     // take some arbitrary Sunday
     tm tm = { 0, 0, 0, 28, Nov, 99 };
 
     // take some arbitrary Sunday
     tm tm = { 0, 0, 0, 28, Nov, 99 };
 

-    // and offset it by the number of days needed to get 
+    // and offset it by the number of days needed to get the correct wday

     tm.tm_mday += wday;
 
     return CallStrftime(abbr ? _T("%a") : _T("%A"), &tm);
     tm.tm_mday += wday;
 
     return CallStrftime(abbr ? _T("%a") : _T("%A"), &tm);


@@ -449,7 +538,25 @@ wxDateTime& wxDateTime::Set(const struct tm& tm1)
     wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
 
     tm tm2(tm1);
     wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
 
     tm tm2(tm1);

+
+    // we want the time in GMT, mktime() takes the local time, so use timegm()
+    // if it's available
+#ifdef HAVE_TIMEGM
+    time_t timet = timegm(&tm2);
+#else // !HAVE_TIMEGM
+    // FIXME this almost surely doesn't work
+    tm2.tm_sec -= GetTimeZone();
+

     time_t timet = mktime(&tm2);
     time_t timet = mktime(&tm2);

+
+    if ( tm2.tm_isdst )
+    {
+        tm2.tm_hour += 1;
+
+        timet = mktime(&tm2);
+    }
+#endif // HAVE_TIMEGM/!HAVE_TIMEGM
+

     if ( timet == (time_t)(-1) )
     {
         wxFAIL_MSG(_T("Invalid time"));
     if ( timet == (time_t)(-1) )
     {
         wxFAIL_MSG(_T("Invalid time"));


@@ -477,7 +584,7 @@ wxDateTime& wxDateTime::Set(wxDateTime_t hour,
 
     // get the current date from system
     time_t timet = GetTimeNow();
 
     // get the current date from system
     time_t timet = GetTimeNow();

-    struct tm *tm = localtime(&timet);
+    struct tm *tm = gmtime(&timet);

 
     // adjust the time
     tm->tm_hour = hour;
 
     // adjust the time
     tm->tm_hour = hour;


@@ -506,7 +613,8 @@ wxDateTime& wxDateTime::Set(wxDateTime_t day,
 
     ReplaceDefaultYearMonthWithCurrent(&year, &month);
 
 
     ReplaceDefaultYearMonthWithCurrent(&year, &month);
 

-    wxCHECK_MSG( day <= GetNumberOfDays(month, year), ms_InvDateTime,
+    wxCHECK_MSG( (0 < day) && (day <= GetNumberOfDays(month, year)),
+                 ms_InvDateTime,

                  _T("Invalid date in wxDateTime::Set()") );
 
     // the range of time_t type (inclusive)
                  _T("Invalid date in wxDateTime::Set()") );
 
     // the range of time_t type (inclusive)


@@ -526,6 +634,7 @@ wxDateTime& wxDateTime::Set(wxDateTime_t day,
         tm.tm_hour = hour;
         tm.tm_min = minute;
         tm.tm_sec = second;
         tm.tm_hour = hour;
         tm.tm_min = minute;
         tm.tm_sec = second;

+        tm.tm_isdst = -1;       // mktime() will guess it (wrongly, probably)

 
         (void)Set(tm);
 
 
         (void)Set(tm);
 


@@ -536,12 +645,30 @@ wxDateTime& wxDateTime::Set(wxDateTime_t day,
     {
         // do time calculations ourselves: we want to calculate the number of
         // milliseconds between the given date and the epoch
     {
         // do time calculations ourselves: we want to calculate the number of
         // milliseconds between the given date and the epoch

-        wxFAIL_MSG(_T("TODO"));
+
+        // get the JDN for the midnight of this day
+        m_time = GetTruncatedJDN(day, month, year);
+        m_time -= EPOCH_JDN;
+        m_time *= SECONDS_PER_DAY * TIME_T_FACTOR;
+
+        Add(wxTimeSpan(hour, minute, second, millisec));

     }
 
     return *this;
 }
 
     }
 
     return *this;
 }
 

+wxDateTime& wxDateTime::Set(double jdn)
+{
+    // so that m_time will be 0 for the midnight of Jan 1, 1970 which is jdn
+    // EPOCH_JDN + 0.5
+    jdn -= EPOCH_JDN + 0.5;
+
+    m_time = jdn;
+    m_time *= MILLISECONDS_PER_DAY;
+
+    return *this;
+}
+

 // ----------------------------------------------------------------------------
 // time_t <-> broken down time conversions
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // time_t <-> broken down time conversions
 // ----------------------------------------------------------------------------


@@ -554,18 +681,91 @@ wxDateTime::Tm wxDateTime::GetTm() const
     if ( time != (time_t)-1 )
     {
         // use C RTL functions
     if ( time != (time_t)-1 )
     {
         // use C RTL functions

-        tm *tm = localtime(&time);
+        tm *tm = gmtime(&time);

 
         // should never happen
 
         // should never happen

-        wxCHECK_MSG( tm, Tm(), _T("localtime() failed") );
+        wxCHECK_MSG( tm, Tm(), _T("gmtime() failed") );

 
         return Tm(*tm);
     }
     else
     {
 
         return Tm(*tm);
     }
     else
     {

-        wxFAIL_MSG(_T("TODO"));
+        // remember the time and do the calculations with the date only - this
+        // eliminates rounding errors of the floating point arithmetics
+
+        wxLongLong timeMidnight = m_time;
+
+        long timeOnly = (m_time % MILLISECONDS_PER_DAY).ToLong();
+        if ( timeOnly < 0 )
+        {
+            timeOnly = MILLISECONDS_PER_DAY - timeOnly;
+        }
+
+        timeMidnight -= timeOnly;
+
+        // calculate the Gregorian date from JDN for the midnight of our date:
+        // this will yield day, month (in 1..12 range) and year
+
+        // actually, this is the JDN for the noon of the previous day
+        long jdn = (timeMidnight / MILLISECONDS_PER_DAY).ToLong() + EPOCH_JDN;
+
+        // CREDIT: code below is by Scott E. Lee (but bugs are mine)
+
+        wxASSERT_MSG( jdn > -2, _T("JDN out of range") );

 
 

-        return Tm();
+        // calculate the century
+        int temp = (jdn + JDN_OFFSET) * 4 - 1;
+        int century = temp / DAYS_PER_400_YEARS;
+
+        // then the year and day of year (1 <= dayOfYear <= 366)
+        temp = ((temp % DAYS_PER_400_YEARS) / 4) * 4 + 3;
+        int year = (century * 100) + (temp / DAYS_PER_4_YEARS);
+        int dayOfYear = (temp % DAYS_PER_4_YEARS) / 4 + 1;
+
+        // and finally the month and day of the month
+        temp = dayOfYear * 5 - 3;
+        int month = temp / DAYS_PER_5_MONTHS;
+        int day = (temp % DAYS_PER_5_MONTHS) / 5 + 1;
+
+        // month is counted from March - convert to normal
+        if ( month < 10 )
+        {
+            month += 3;
+        }
+        else
+        {
+            year += 1;
+            month -= 9;
+        }
+
+        // year is offset by 4800
+        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( (INT_MIN <= year) && (year <= INT_MAX),
+                      _T("year range overflow") );
+
+        // construct Tm from these values
+        Tm tm;
+        tm.year = (int)year;
+        tm.mon = (Month)(month - 1); // algorithm yields 1 for January, not 0
+        tm.mday = (wxDateTime_t)day;
+        tm.msec = timeOnly % 1000;
+        timeOnly -= tm.msec;
+        timeOnly /= 1000;               // now we have time in seconds
+
+        tm.sec = timeOnly % 60;
+        timeOnly -= tm.sec;
+        timeOnly /= 60;                 // now we have time in minutes
+
+        tm.min = timeOnly % 60;
+        timeOnly -= tm.min;
+
+        tm.hour = timeOnly / 60;
+
+        return tm;

     }
 }
 
     }
 }
 


@@ -744,6 +944,29 @@ bool wxDateTime::SetToWeekDay(WeekDay weekday,
     }
 }
 
     }
 }
 

+// ----------------------------------------------------------------------------
+// Julian day number conversion and related stuff
+// ----------------------------------------------------------------------------
+
+double wxDateTime::GetJulianDayNumber() const
+{
+    Tm tm(GetTm());
+
+    double result = GetTruncatedJDN(tm.mday, tm.mon, tm.year);
+
+    // add the part GetTruncatedJDN() neglected
+    result += 0.5;
+
+    // and now add the time: 86400 sec = 1 JDN
+    return result + ((double)(60*(60*tm.hour + tm.min) + tm.sec)) / 86400;
+}
+
+double wxDateTime::GetRataDie() const
+{
+    // March 1 of the year 0 is Rata Die day -306 and JDN 1721119.5
+    return GetJulianDayNumber() - 1721119.5 - 306;
+}
+

 // ----------------------------------------------------------------------------
 // timezone stuff
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // timezone stuff
 // ----------------------------------------------------------------------------


@@ -771,22 +994,63 @@ wxDateTime& wxDateTime::MakeLocalTime(const TimeZone& tz)
 
 wxString wxDateTime::Format(const wxChar *format) const
 {
 
 wxString wxDateTime::Format(const wxChar *format) const
 {

+    wxCHECK_MSG( format, _T(""), _T("NULL format in wxDateTime::Format") );
+

     time_t time = GetTicks();
     if ( time != (time_t)-1 )
     {
         // use strftime()
     time_t time = GetTicks();
     if ( time != (time_t)-1 )
     {
         // use strftime()

-        tm *tm = localtime(&time);
+        tm *tm = gmtime(&time);

 
         // should never happen
 
         // should never happen

-        wxCHECK_MSG( tm, _T(""), _T("localtime() failed") );
+        wxCHECK_MSG( tm, _T(""), _T("gmtime() failed") );

 
         return CallStrftime(format, tm);
     }
     else
     {
 
         return CallStrftime(format, tm);
     }
     else
     {

-        wxFAIL_MSG(_T("TODO"));
+        // use a hack and still use strftime(): make a copy of the format and
+        // replace all occurences of YEAR in it with some unique string not
+        // appearing anywhere else in it, then use strftime() to format the
+        // date in year YEAR and then replace YEAR back by the real year and
+        // the unique replacement string back with YEAR where YEAR is any year
+        // in the range supported by strftime() (1970 - 2037) which is equal to
+        // the real year modulo 28 (so the week days coincide for them)
+
+        // find the YEAR
+        int yearReal = GetYear();
+        int year = 1970 + yearReal % 28;
+
+        wxString strYear;
+        strYear.Printf(_T("%d"), year);
+
+        // find a string not occuring in format (this is surely not optimal way
+        // of doing it... improvements welcome!)
+        wxString fmt = format;
+        wxString replacement = (wxChar)-1;
+        while ( fmt.Find(replacement) != wxNOT_FOUND )
+        {
+            replacement << (wxChar)-1;
+        }
+
+        // replace all occurences of year with it
+        bool wasReplaced = fmt.Replace(strYear, replacement) > 0;

 
 

-        return _T("");
+        // use strftime() to format the same date but in supported year
+        wxDateTime dt(*this);
+        dt.SetYear(year);
+        wxString str = dt.Format(format);
+
+        // now replace the occurence of 1999 with the real year
+        wxString strYearReal;
+        strYearReal.Printf(_T("%d"), yearReal);
+        str.Replace(strYear, strYearReal);
+
+        // and replace back all occurences of replacement string
+        if ( wasReplaced )
+            str.Replace(replacement, strYear);
+
+        return str;

     }
 }
 
     }
 }
 


@@ -794,11 +1058,84 @@ wxString wxDateTime::Format(const wxChar *format) const
 // wxTimeSpan
 // ============================================================================
 
 // wxTimeSpan
 // ============================================================================
 

+// not all strftime(3) format specifiers make sense here because, for example,
+// a time span doesn't have a year nor a timezone
+//
+// Here are the ones which are supported (all of them are supported by strftime
+// as well):
+//  %H          hour in 24 hour format
+//  %M          minute (00 - 59)
+//  %S          second (00 - 59)
+//  %%          percent sign
+//
+// Also, for MFC CTimeSpan compatibility, we support
+//  %D          number of days
+//
+// And, to be better than MFC :-), we also have
+//  %E          number of wEeks
+//  %l          milliseconds (000 - 999)

 wxString wxTimeSpan::Format(const wxChar *format) const
 {
 wxString wxTimeSpan::Format(const wxChar *format) const
 {

-    wxFAIL_MSG( _T("TODO") );
+    wxCHECK_MSG( format, _T(""), _T("NULL format in wxTimeSpan::Format") );

 
     wxString str;
 
     wxString str;

+    str.Alloc(strlen(format));
+
+    for ( const wxChar *pch = format; pch; pch++ )
+    {
+        wxChar ch = *pch;
+
+        if ( ch == '%' )
+        {
+            wxString tmp;
+
+            ch = *pch++;
+            switch ( ch )
+            {
+                default:
+                    wxFAIL_MSG( _T("invalid format character") );
+                    // fall through
+
+                case '%':
+                    // will get to str << ch below
+                    break;
+
+                case 'D':
+                    tmp.Printf(_T("%d"), GetDays());
+                    break;
+
+                case 'E':
+                    tmp.Printf(_T("%d"), GetWeeks());
+                    break;
+
+                case 'H':
+                    tmp.Printf(_T("%02d"), GetHours());
+                    break;
+
+                case 'l':
+                    tmp.Printf(_T("%03d"), GetMilliseconds());
+                    break;
+
+                case 'M':
+                    tmp.Printf(_T("%02d"), GetMinutes());
+                    break;
+
+                case 'S':
+                    tmp.Printf(_T("%02d"), GetSeconds());
+                    break;
+            }
+
+            if ( !!tmp )
+            {
+                str += tmp;
+
+                // skip str += ch below
+                continue;
+            }
+        }
+
+        str += ch;
+    }

 
     return str;
 }
 
     return str;
 }