src/common/date.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        date.cpp
   3 // Purpose:     wxDate class
   4 // Author:
   5 //    Originally inspired by Steve Marcus (CIS 72007,1233)  6/16/91
   6 //    Enhanced by Eric Simon (CIS 70540,1522)               6/29/91
   7 //    Further Enhanced by Chris Hill (CIS 72030,2606)       7/11/91
   8 //    Still Further Enhanced by Hill & Simon  v3.10         8/05/91
   9 //    Version 4 by Charles D. Price                         6/27/92
  10 //    Integrated into wxWindows by Julian Smart             9th July 1995
  11 // Modified by:
  12 // Created:     01/02/97
  13 // RCS-ID:      $Id$
  14 // Copyright:   (c) Julian Smart and Markus Holzem
  15 // Licence:     wxWindows licence
  16 /////////////////////////////////////////////////////////////////////////////
  17
  18 #ifdef __GNUG__
  19 #pragma implementation "date.h"
  20 #endif
  21
  22 // For compilers that support precompilation, includes "wx.h".
  23 #include "wx/wxprec.h"
  24
  25 #ifdef __BORLANDC__
  26 #pragma hdrstop
  27 #endif
  28
  29 #include "wx/setup.h"
  30
  31 #if wxUSE_TIMEDATE
  32
  33 #include "wx/date.h"
  34 #include <wx/intl.h>
  35
  36 #include <stdio.h>
  37 #include <string.h>
  38 #include <stdlib.h>
  39
  40 #if wxUSE_IOSTREAMH
  41 #include <iostream.h>
  42 #else
  43 #include <iostream>
  44 #endif
  45
  46 #include <time.h>
  47 #include <string.h>
  48
  49 #define ABBR_LENGTH 3
  50
  51 static const wxChar *dayname[] = {
  52     _T("Sunday"), _T("Monday"), _T("Tuesday"), _T("Wednesday"),
  53     _T("Thursday"), _T("Friday"), _T("Saturday")
  54 };
  55
  56 static const wxChar *mname[] = {
  57     _T("January"), _T("February"), _T("March"), _T("April"), _T("May"), _T("June"),
  58     _T("July"), _T("August"), _T("September"), _T("October"), _T("November"), _T("December")
  59 };
  60
  61 static int GauDays[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
  62
  63 #if !USE_SHARED_LIBRARY
  64 IMPLEMENT_DYNAMIC_CLASS(wxDate, wxObject)
  65 #endif
  66
  67     ////////////////////////////////////////////////////////////
  68     // Constructors
  69     ////////////////////////////////////////////////////////////
  70
  71 wxDate::wxDate()
  72 {
  73     DisplayFormat=wxMDY;
  74     DisplayOptions='\0';
  75     month = day = year = day_of_week = 0;
  76     julian = 0;
  77 }
  78
  79 wxDate::wxDate (long j) : julian(j)
  80 {
  81     DisplayFormat=wxMDY;
  82     DisplayOptions='\0';
  83     julian_to_mdy ();
  84 }
  85
  86 wxDate::wxDate (int m, int d, int y) : month(m), day(d), year(y)
  87 {
  88     DisplayFormat=wxMDY;
  89     DisplayOptions='\0';
  90     mdy_to_julian ();
  91 }
  92
  93 wxDate::wxDate (const wxString& dat)
  94 {
  95     DisplayFormat=wxMDY;
  96     DisplayOptions='\0';
  97     if (wxStrcmp(dat, _T("TODAY")) == 0 || wxStrcmp(dat, _T("today")) == 0)
  98     {
  99         // Sets the current date
 100         Set();
 101     }
 102     else
 103     {
 104         wxChar buf[100];
 105         wxStrcpy(buf, WXSTRINGCAST dat);
 106
 107         wxChar *save_ptr, *token = wxStrtok(buf,_T("/-"),&save_ptr);
 108         month = wxAtoi(token);
 109         day   = wxAtoi(wxStrtok((wxChar *) NULL,_T("/-"),&save_ptr));
 110         year  = wxAtoi(wxStrtok((wxChar *) NULL,_T(" "),&save_ptr));
 111     }
 112
 113     mdy_to_julian ();
 114 }
 115
 116 wxDate::wxDate (const wxDate &dt)
 117 {
 118     DisplayFormat=dt.DisplayFormat;
 119     DisplayOptions=dt.DisplayOptions;
 120     month = dt.month;
 121     day   = dt.day;
 122     year  = dt.year;
 123     mdy_to_julian ();
 124 }
 125
 126 void wxDate::operator = (const wxDate &dt)
 127 {
 128     DisplayFormat=dt.DisplayFormat;
 129     DisplayOptions=dt.DisplayOptions;
 130     month = dt.month;
 131     day   = dt.day;
 132     year  = dt.year;
 133     mdy_to_julian (); // wxUSE_TIMEDATE
 134 }
 135
 136 void wxDate::operator = (const wxString& dat)
 137 {
 138     DisplayFormat=wxMDY;
 139     DisplayOptions='\0';
 140     if (wxStrcmp(dat, _T("TODAY")) == 0 || wxStrcmp(dat, _T("today")) == 0)
 141     {
 142         // Sets the current date
 143         Set();
 144     }
 145     else
 146     {
 147         wxChar buf[100];
 148         wxStrcpy(buf, WXSTRINGCAST dat);
 149
 150         wxChar *save_ptr, *token = wxStrtok(buf,_T("/-"),&save_ptr);
 151         month = wxAtoi(token);
 152         day   = wxAtoi(wxStrtok((wxChar *) NULL,_T("/-"),&save_ptr));
 153         year  = wxAtoi(wxStrtok((wxChar *) NULL,_T(" "),&save_ptr));
 154     }
 155
 156     mdy_to_julian ();
 157 }
 158
 159 //////////////////////////////////////////////////////////////
 160 // Conversion operations
 161 //////////////////////////////////////////////////////////////
 162
 163 #ifndef __SALFORDC__
 164 wxDate::operator wxString( void )
 165 {
 166     return FormatDate();
 167 }
 168 #endif
 169
 170 //////////////////////////////////////////////////////////////
 171 // Date Arithmetic
 172 //////////////////////////////////////////////////////////////
 173
 174 wxDate wxDate::operator + (long i)
 175 {
 176     wxDate dp(julian + i);
 177     return dp;
 178 }
 179
 180 wxDate wxDate::operator + (int i)
 181 {
 182     wxDate dp(julian + (long)i);
 183     return dp;
 184 }
 185
 186 wxDate wxDate::operator - (long i)
 187 {
 188     wxDate dp(julian - i);
 189     return dp;
 190 }
 191
 192 wxDate wxDate::operator - (int i)
 193 {
 194     wxDate dp(julian - (long)i);
 195     return dp;
 196 }
 197
 198 long wxDate::operator - (const wxDate &dt)
 199 {
 200     return ( julian - dt.julian );
 201 }
 202
 203 wxDate &wxDate::operator += (long i)
 204 {
 205     julian += i;
 206     julian_to_mdy();
 207     return *this;
 208 }
 209
 210 wxDate &wxDate::operator -= (long i)
 211 {
 212     julian -= i;
 213     julian_to_mdy();
 214     return *this;
 215 }
 216
 217 wxDate &wxDate::operator ++()
 218 {
 219     julian++;
 220     julian_to_mdy();
 221     return *this;
 222 }
 223
 224 wxDate &wxDate::operator ++(int)
 225 {
 226     julian++;
 227     julian_to_mdy();
 228     return *this;
 229 }
 230
 231 wxDate &wxDate::operator --()
 232 {
 233     julian--;
 234     julian_to_mdy();
 235     return *this;
 236 }
 237
 238 wxDate &wxDate::operator --(int)
 239 {
 240     julian--;
 241     julian_to_mdy();
 242     return *this;
 243 }
 244
 245 //////////////////////////////////////////////////////////////
 246 // Date comparison
 247 //////////////////////////////////////////////////////////////
 248
 249 bool WXDLLEXPORT operator <  (const wxDate &dt1, const wxDate &dt2)
 250 {
 251     return ( dt1.julian < dt2.julian );
 252 }
 253
 254 bool WXDLLEXPORT operator <= (const wxDate &dt1, const wxDate &dt2)
 255 {
 256     return ( (dt1.julian == dt2.julian) || (dt1.julian < dt2.julian) );
 257 }
 258
 259 bool WXDLLEXPORT operator >  (const wxDate &dt1, const wxDate &dt2)
 260 {
 261     return ( dt1.julian > dt2.julian );
 262 }
 263
 264 bool WXDLLEXPORT operator >= (const wxDate &dt1, const wxDate &dt2)
 265 {
 266     return ( (dt1.julian == dt2.julian) || (dt1.julian > dt2.julian) );
 267 }
 268
 269 bool WXDLLEXPORT operator == (const wxDate &dt1, const wxDate &dt2)
 270 {
 271     return ( dt1.julian == dt2.julian );
 272 }
 273
 274 bool WXDLLEXPORT operator != (const wxDate &dt1, const wxDate &dt2)
 275 {
 276     return ( dt1.julian != dt2.julian );
 277 }
 278
 279 ////////////////////////////////////////////////////////////////
 280 // Ostream operations
 281 ////////////////////////////////////////////////////////////////
 282
 283 ostream WXDLLEXPORT & operator << (ostream &os, const wxDate &dt)
 284 {
 285     return os << dt.FormatDate().mb_str();
 286 }
 287
 288 //////////////////////////////////////////////////////////////
 289 // Conversion routines
 290 //////////////////////////////////////////////////////////////
 291
 292 void wxDate::julian_to_wday (void)
 293 {
 294     // Correction by Peter Stadel <peters@jetcity.com>
 295         day_of_week = ((julian - 2) % 7L);
 296 /*
 297     day_of_week = (int) ((julian + 2) % 7 + 1);
 298 */
 299 }
 300
 301 void wxDate::julian_to_mdy ()
 302 {
 303     long a,b,c,d,e,z,alpha;
 304     z = julian+1;
 305     // dealing with Gregorian calendar reform
 306     if (z < 2299161L)
 307         a = z;
 308     else {
 309         alpha = (long) ((z-1867216.25) / 36524.25);
 310         a = z + 1 + alpha - alpha/4;
 311     }
 312     b = ( a > 1721423 ? a + 1524 : a + 1158 );
 313     c = (long) ((b - 122.1) / 365.25);
 314     d = (long) (365.25 * c);
 315     e = (long) ((b - d) / 30.6001);
 316     day = (int)(b - d - (long)(30.6001 * e));
 317     month = (int)((e < 13.5) ? e - 1 : e - 13);
 318     year = (int)((month > 2.5 ) ? (c - 4716) : c - 4715);
 319     julian_to_wday ();
 320 }
 321
 322 void wxDate::mdy_to_julian (void)
 323 {
 324     int a,b=0;
 325     int work_month=month, work_day=day, work_year=year;
 326     // correct for negative year
 327     if (work_year < 0)
 328         work_year++;
 329     if (work_month <= 2)
 330     { work_year--; work_month +=12; }
 331
 332     // deal with Gregorian calendar
 333     if (work_year*10000. + work_month*100. + work_day >= 15821015.)
 334     {
 335         a = (int)(work_year/100.);
 336         b = 2 - a + a/4;
 337     }
 338     julian = (long) (365.25*work_year) +
 339         (long) (30.6001 * (work_month+1))  +  work_day + 1720994L + b;
 340     julian_to_wday ();
 341 }
 342
 343 ////////////////////////////////////////////////////////////////
 344 // Format routine
 345 ////////////////////////////////////////////////////////////////
 346
 347 wxString wxDate::FormatDate (int type) const
 348 {
 349     int actualType = type;
 350     if (actualType == -1)
 351         actualType = DisplayFormat;
 352
 353     wxChar buf[40];
 354
 355     memset( buf, '\0', sizeof(buf) );
 356     switch ( actualType )
 357     {
 358         case wxDAY:
 359             if ( (day_of_week < 1) || (day_of_week > 7) )
 360                 wxStrcpy(buf, _("invalid day"));
 361             else
 362                 wxStrncpy( buf, wxGetTranslation(dayname[day_of_week-1]),
 363                            (DisplayOptions & wxDATE_ABBR) ? ABBR_LENGTH : 9);
 364             return wxString(buf);
 365
 366         case wxMONTH:
 367             if ( (month < 1) || (month > 12) )
 368                 wxStrcpy(buf, _("invalid month"));
 369             else
 370                 wxStrncpy( buf, wxGetTranslation(mname[month-1]),
 371                            (DisplayOptions & wxDATE_ABBR) ? ABBR_LENGTH : 9);
 372             return wxString(buf);
 373
 374         case wxFULL:
 375             if ( (month < 1) || (month > 12) || (day_of_week < 0) ||
 376                     (day_of_week > 7) )
 377             {
 378                 wxStrcpy(buf, _("invalid date"));
 379                 return wxString(buf);
 380             }
 381             wxStrncpy( buf, wxGetTranslation(dayname[day_of_week-1]),
 382                        (DisplayOptions & wxDATE_ABBR) ? ABBR_LENGTH : 9);
 383             wxStrcat( buf, _T(", "));
 384             wxStrncat( buf, wxGetTranslation(mname[month-1]),
 385                        (DisplayOptions & wxDATE_ABBR) ? ABBR_LENGTH : 9);
 386             wxStrcat( buf, _T(" "));
 387             wxSprintf( buf+wxStrlen(buf), _T("%d, %d"), day, abs(year) );
 388             if (year < 0)
 389                 wxStrcat(buf,_(" B.C."));
 390             return wxString(buf);
 391
 392         case wxEUROPEAN:
 393             if ( (month < 1) || (month > 12) || (day_of_week < 0) ||
 394                     (day_of_week > 7) )
 395             {
 396                 wxStrcpy(buf, _("invalid date"));
 397                 return wxString(buf);
 398             }
 399             wxSprintf(buf,_T("%d "),  day);
 400             wxStrncat(buf, wxGetTranslation(mname[month-1]),
 401                     (DisplayOptions & wxDATE_ABBR) ? ABBR_LENGTH : 9);
 402             wxSprintf( buf+wxStrlen(buf), _T(" %d"), abs(year) );
 403             if (year < 0)
 404                 wxStrcat(buf, _(" B.C."));
 405             return wxString(buf);
 406
 407         case wxMDY:
 408         default:
 409             if (day==0 || month==0 || year==0)
 410                 wxStrcpy(buf, _("invalid date"));
 411             else
 412                 wxSprintf( buf+wxStrlen(buf), _T("%1d/%1d/%02d"), month, day,
 413                            (DisplayOptions & wxNO_CENTURY) && (abs(year) > 1899)
 414                            ? (abs(year) - (abs(year) / 100 * 100))
 415                            : (abs(year))  );
 416             return wxString(buf);
 417     }
 418     return wxString(_T(""));
 419 }
 420
 421 void wxDate::SetFormat( int format )
 422 {
 423     DisplayFormat = format;
 424 }
 425
 426 int wxDate::SetOption( int option, bool action )
 427 {
 428     switch ( option )
 429     {
 430         case wxNO_CENTURY:
 431             if ( action )
 432                 DisplayOptions |= wxNO_CENTURY;
 433             else
 434             {
 435                 DisplayOptions &= (~wxNO_CENTURY);
 436             }
 437             return 1;
 438         case wxDATE_ABBR:
 439             if ( action )
 440                 DisplayOptions |= wxDATE_ABBR;
 441             else
 442             {
 443                 DisplayOptions &= (~wxDATE_ABBR);
 444             }
 445             return 1;
 446         default:
 447             return 0;
 448     }
 449     return 0;
 450 }
 451
 452 ///////////////////////////////////////////////////////////////
 453 //  Miscellaneous Routines
 454 ///////////////////////////////////////////////////////////////
 455
 456 long wxDate::GetJulianDate( void ) const
 457 {
 458     return julian;
 459 }
 460
 461 int wxDate::GetDayOfYear( void ) const
 462 {
 463     wxDate temp( 1, 1, year );
 464
 465     return (int) (julian - temp.julian + 1);
 466 }
 467
 468
 469 bool wxDate::IsLeapYear( void ) const
 470 {
 471     return  ( (year >= 1582) ?
 472             (year % 4 == 0  &&  year % 100 != 0  ||  year % 400 == 0 ):
 473             (year % 4 == 0) );
 474 }
 475
 476 // Version 4.0 Extension to Public Interface - CDP
 477
 478 wxDate& wxDate::Set()
 479 {
 480     //#ifdef __WXMSW__
 481 #if 0
 482     struct _dosdate_t sDate;
 483     _dos_getdate(&sDate);
 484
 485     month = sDate.month;
 486     day   = sDate.day;
 487     year  = sDate.year;
 488
 489     mdy_to_julian();
 490 #else
 491     time_t now = time((time_t *) NULL);
 492     struct tm *localTime = localtime(&now);
 493
 494     month = localTime->tm_mon + 1;
 495     day = localTime->tm_mday;
 496     year = localTime->tm_year + 1900;
 497
 498     mdy_to_julian ();
 499 #endif
 500     return *this;
 501 }
 502
 503 wxDate& wxDate::Set(
 504         int  nMonth,
 505         int  nDay,
 506         int  nYear)
 507 {
 508     month = nMonth;
 509     year  = nYear < 0 ? 9999 : nYear;
 510     year  = nYear > 9999 ? 0 : nYear;
 511     day   = nDay < GetDaysInMonth() ? nDay : GetDaysInMonth();
 512
 513     mdy_to_julian();
 514     return *this;
 515 }
 516
 517 wxDate &
 518 wxDate::Set(long j)
 519 {
 520     julian = j;
 521
 522     julian_to_mdy();
 523     return *this;
 524 }
 525
 526
 527 int wxDate::GetDaysInMonth()
 528 {
 529     return GauDays[month-1] + (month==2 && IsLeapYear());
 530 }
 531
 532 int wxDate::GetFirstDayOfMonth() const
 533 {
 534     return wxDate(month, 1, year).GetDayOfWeek();
 535 }
 536
 537 int wxDate::GetDay() const
 538 {
 539     return day;
 540 }
 541
 542 int wxDate::GetDayOfWeek() const
 543 {
 544     return day_of_week;
 545 }
 546
 547 int wxDate::GetYear() const
 548 {
 549     return year;
 550 }
 551
 552 int wxDate::GetMonth() const
 553 {
 554     return month;
 555 }
 556
 557 wxDate& wxDate::AddWeeks(int nCount)
 558 {
 559     Set(julian + (long)nCount*7);
 560     return *this;
 561 }
 562
 563 wxDate& wxDate::AddMonths(int nCount)
 564 {
 565     month += nCount;
 566
 567     if (month < 1) {
 568         month = 12;
 569         year--;
 570     }
 571
 572     if (month > 12) {
 573         month = 1;
 574         year++;
 575     }
 576     mdy_to_julian();
 577     return *this;
 578 }
 579
 580 wxDate& wxDate::AddYears(int nCount)
 581 {
 582     year += nCount;
 583     mdy_to_julian();
 584     return *this;
 585 }
 586
 587 int wxDate::GetWeekOfMonth()
 588 {
 589     // Abs day includes the days from previous month that fills up
 590     // the begin. of the week.
 591     int nAbsDay = day + GetFirstDayOfMonth()-1;
 592     return (nAbsDay-GetDayOfWeek())/7 + 1;
 593 }
 594
 595 int wxDate::GetWeekOfYear()
 596 {
 597     wxDate   doTemp(1, 1, year);
 598     return (int)(((julian - doTemp.julian+1)/7) + 1);
 599 }
 600
 601 wxDate wxDate::GetMonthStart()
 602 {
 603     return(wxDate(month, 1, year));
 604 }
 605
 606 wxDate wxDate::GetMonthEnd()
 607 {
 608     return(wxDate(month+1, 1, year)-1);
 609 }
 610
 611 wxDate wxDate::GetYearStart()
 612 {
 613     return(wxDate(1, 1, year));
 614 }
 615
 616 wxDate wxDate::GetYearEnd()
 617 {
 618     return(wxDate(1, 1, year+1)-1);
 619 }
 620
 621 wxString wxDate::GetMonthName()
 622 {
 623     return(FormatDate(wxMONTH));
 624 }
 625
 626 wxString wxDate::GetDayOfWeekName()
 627 {
 628     return(FormatDate(wxDAY));
 629 }
 630
 631 bool wxDate::IsBetween(const wxDate& first, const wxDate& second) const
 632 {
 633     return (julian >= first.julian && julian <= second.julian);
 634 }
 635
 636 // This function is from NIHCL
 637 wxDate wxDate::Previous(int dayOfWeek) const
 638 {
 639     int this_day_Of_Week, desired_day_Of_Week;
 640     long j;
 641
 642     //      Set the desired and current day of week to start at 0 (Monday)
 643     //      and end at 6 (Sunday).
 644
 645     desired_day_Of_Week = dayOfWeek - 1; // These functions return a value
 646     this_day_Of_Week    = GetDayOfWeek() - 1;            // from 1-7.  Subtract 1 for 0-6.
 647     j = julian;
 648
 649     //      Have to determine how many days difference from current day back to
 650     //      desired, if any.  Special calculation under the 'if' statement to
 651     //      effect the wraparound counting from Monday (0) back to Sunday (6).
 652
 653     if (desired_day_Of_Week > this_day_Of_Week)
 654         this_day_Of_Week += 7 - desired_day_Of_Week;
 655     else
 656         this_day_Of_Week -= desired_day_Of_Week;
 657     j -= this_day_Of_Week; // Adjust j to set it at the desired day of week.
 658     return wxDate(j);
 659 }
 660
 661 #endif