]> git.saurik.com Git - wxWidgets.git/blame - include/wx/datetime.h
Override MSWTranslateMessage for wxActiveXContainer. Calling IOleInPlaceActiveObject...
[wxWidgets.git] / include / wx / datetime.h
CommitLineData
0979c962
VZ
1/////////////////////////////////////////////////////////////////////////////
2// Name: wx/datetime.h
3// Purpose: declarations of time/date related classes (wxDateTime,
4// wxTimeSpan)
5// Author: Vadim Zeitlin
6// Modified by:
7// Created: 10.02.99
8// RCS-ID: $Id$
9// Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
65571936 10// Licence: wxWindows licence
0979c962
VZ
11/////////////////////////////////////////////////////////////////////////////
12
2f02cb89
VZ
13#ifndef _WX_DATETIME_H
14#define _WX_DATETIME_H
0979c962 15
2b5f62a0
VZ
16#include "wx/defs.h"
17
e421922f
VZ
18#if wxUSE_DATETIME
19
9b4da627
VZ
20#ifdef __WXWINCE__
21 #include "wx/msw/wince/time.h"
22#elif !defined(__WXPALMOS5__)
23 #include <time.h>
24#endif // OS
5e967044 25
b76b015e 26#include <limits.h> // for INT_MIN
0979c962
VZ
27
28#include "wx/longlong.h"
254696bb 29#include "wx/anystr.h"
0979c962 30
b5dbe15d
VS
31class WXDLLIMPEXP_FWD_BASE wxDateTime;
32class WXDLLIMPEXP_FWD_BASE wxTimeSpan;
33class WXDLLIMPEXP_FWD_BASE wxDateSpan;
154014d6
VZ
34#ifdef __WXMSW__
35struct _SYSTEMTIME;
36#endif
0979c962 37
df5168c4 38#include "wx/dynarray.h"
2f02cb89 39
5b781a67
SC
40// not all c-runtimes are based on 1/1/1970 being (time_t) 0
41// set this to the corresponding value in seconds 1/1/1970 has on your
42// systems c-runtime
43
92f89387
SC
44#define WX_TIME_BASE_OFFSET 0
45
0979c962 46/*
f6bcfd97 47 * TODO
0979c962 48 *
299fcbfe 49 * + 1. Time zones with minutes (make TimeZone a class)
4f6aed9c 50 * ? 2. getdate() function like under Solaris
299fcbfe 51 * + 3. text conversion for wxDateSpan
4f6aed9c
VZ
52 * + 4. pluggable modules for the workdays calculations
53 * 5. wxDateTimeHolidayAuthority for Easter and other christian feasts
0979c962
VZ
54 */
55
56/*
299fcbfe 57 The three (main) classes declared in this header represent:
0979c962
VZ
58
59 1. An absolute moment in the time (wxDateTime)
60 2. A difference between two moments in the time, positive or negative
61 (wxTimeSpan)
62 3. A logical difference between two dates expressed in
63 years/months/weeks/days (wxDateSpan)
64
65 The following arithmetic operations are permitted (all others are not):
66
67 addition
68 --------
69
70 wxDateTime + wxTimeSpan = wxDateTime
71 wxDateTime + wxDateSpan = wxDateTime
72 wxTimeSpan + wxTimeSpan = wxTimeSpan
73 wxDateSpan + wxDateSpan = wxDateSpan
74
f6bcfd97 75 subtraction
0979c962
VZ
76 ------------
77 wxDateTime - wxDateTime = wxTimeSpan
cd0b1709
VZ
78 wxDateTime - wxTimeSpan = wxDateTime
79 wxDateTime - wxDateSpan = wxDateTime
0979c962
VZ
80 wxTimeSpan - wxTimeSpan = wxTimeSpan
81 wxDateSpan - wxDateSpan = wxDateSpan
82
83 multiplication
84 --------------
85 wxTimeSpan * number = wxTimeSpan
cd0b1709 86 number * wxTimeSpan = wxTimeSpan
0979c962 87 wxDateSpan * number = wxDateSpan
cd0b1709 88 number * wxDateSpan = wxDateSpan
0979c962
VZ
89
90 unitary minus
91 -------------
92 -wxTimeSpan = wxTimeSpan
93 -wxDateSpan = wxDateSpan
cd0b1709
VZ
94
95 For each binary operation OP (+, -, *) we have the following operatorOP=() as
f6bcfd97 96 a method and the method with a symbolic name OPER (Add, Subtract, Multiply)
cd0b1709
VZ
97 as a synonym for it and another const method with the same name which returns
98 the changed copy of the object and operatorOP() as a global function which is
99 implemented in terms of the const version of OPEN. For the unary - we have
100 operator-() as a method, Neg() as synonym for it and Negate() which returns
101 the copy of the object with the changed sign.
0979c962
VZ
102*/
103
2ef31e80
VZ
104// an invalid/default date time object which may be used as the default
105// argument for arguments of type wxDateTime; it is also returned by all
106// functions returning wxDateTime on failure (this is why it is also called
107// wxInvalidDateTime)
b5dbe15d 108class WXDLLIMPEXP_FWD_BASE wxDateTime;
2ef31e80 109
a243da29
PC
110extern WXDLLIMPEXP_DATA_BASE(const char) wxDefaultDateTimeFormat[];
111extern WXDLLIMPEXP_DATA_BASE(const char) wxDefaultTimeSpanFormat[];
bddd7a8d 112extern WXDLLIMPEXP_DATA_BASE(const wxDateTime) wxDefaultDateTime;
1aaf88d2 113
2ef31e80
VZ
114#define wxInvalidDateTime wxDefaultDateTime
115
48fd6e9d
FM
116
117// ----------------------------------------------------------------------------
118// conditional compilation
119// ----------------------------------------------------------------------------
120
dd36b5a3
VZ
121// if configure detected strftime(), we have it too
122#ifdef HAVE_STRFTIME
123 #define wxHAS_STRFTIME
124// suppose everyone else has strftime except Win CE unless VC8 is used
125#elif !defined(__WXWINCE__) || defined(__VISUALC8__)
126 #define wxHAS_STRFTIME
48fd6e9d
FM
127#endif
128
0979c962 129// ----------------------------------------------------------------------------
cd0b1709 130// wxDateTime represents an absolute moment in the time
0979c962 131// ----------------------------------------------------------------------------
b76b015e 132
bddd7a8d 133class WXDLLIMPEXP_BASE wxDateTime
0979c962
VZ
134{
135public:
136 // types
137 // ------------------------------------------------------------------------
138
cd0b1709
VZ
139 // a small unsigned integer type for storing things like minutes,
140 // seconds &c. It should be at least short (i.e. not char) to contain
141 // the number of milliseconds - it may also be 'int' because there is
142 // no size penalty associated with it in our code, we don't store any
143 // data in this format
0979c962
VZ
144 typedef unsigned short wxDateTime_t;
145
f0f951fa
VZ
146 // constants
147 // ------------------------------------------------------------------------
148
0979c962 149 // the timezones
b76b015e 150 enum TZ
0979c962
VZ
151 {
152 // the time in the current time zone
153 Local,
154
4c51a665 155 // zones from GMT (= Greenwich Mean Time): they're guaranteed to be
0979c962
VZ
156 // consequent numbers, so writing something like `GMT0 + offset' is
157 // safe if abs(offset) <= 12
158
159 // underscore stands for minus
160 GMT_12, GMT_11, GMT_10, GMT_9, GMT_8, GMT_7,
161 GMT_6, GMT_5, GMT_4, GMT_3, GMT_2, GMT_1,
162 GMT0,
163 GMT1, GMT2, GMT3, GMT4, GMT5, GMT6,
34f90a1c 164 GMT7, GMT8, GMT9, GMT10, GMT11, GMT12, GMT13,
0979c962
VZ
165 // Note that GMT12 and GMT_12 are not the same: there is a difference
166 // of exactly one day between them
167
fcc3d7cb
VZ
168 // some symbolic names for TZ
169
170 // Europe
171 WET = GMT0, // Western Europe Time
172 WEST = GMT1, // Western Europe Summer Time
173 CET = GMT1, // Central Europe Time
174 CEST = GMT2, // Central Europe Summer Time
175 EET = GMT2, // Eastern Europe Time
176 EEST = GMT3, // Eastern Europe Summer Time
177 MSK = GMT3, // Moscow Time
178 MSD = GMT4, // Moscow Summer Time
179
180 // US and Canada
181 AST = GMT_4, // Atlantic Standard Time
182 ADT = GMT_3, // Atlantic Daylight Time
183 EST = GMT_5, // Eastern Standard Time
184 EDT = GMT_4, // Eastern Daylight Saving Time
185 CST = GMT_6, // Central Standard Time
186 CDT = GMT_5, // Central Daylight Saving Time
187 MST = GMT_7, // Mountain Standard Time
188 MDT = GMT_6, // Mountain Daylight Saving Time
189 PST = GMT_8, // Pacific Standard Time
190 PDT = GMT_7, // Pacific Daylight Saving Time
191 HST = GMT_10, // Hawaiian Standard Time
192 AKST = GMT_9, // Alaska Standard Time
193 AKDT = GMT_8, // Alaska Daylight Saving Time
194
195 // Australia
196
197 A_WST = GMT8, // Western Standard Time
34f90a1c 198 A_CST = GMT13 + 1, // Central Standard Time (+9.5)
fcc3d7cb
VZ
199 A_EST = GMT10, // Eastern Standard Time
200 A_ESST = GMT11, // Eastern Summer Time
201
34f90a1c
VZ
202 // New Zealand
203 NZST = GMT12, // Standard Time
204 NZDT = GMT13, // Daylight Saving Time
205
fcc3d7cb
VZ
206 // TODO add more symbolic timezone names here
207
208 // Universal Coordinated Time = the new and politically correct name
209 // for GMT
0979c962 210 UTC = GMT0
0979c962
VZ
211 };
212
213 // the calendar systems we know about: notice that it's valid (for
214 // this classes purpose anyhow) to work with any of these calendars
215 // even with the dates before the historical appearance of the
216 // calendar
217 enum Calendar
218 {
219 Gregorian, // current calendar
220 Julian // calendar in use since -45 until the 1582 (or later)
221
222 // TODO Hebrew, Chinese, Maya, ... (just kidding) (or then may be not?)
223 };
224
225 // these values only are used to identify the different dates of
226 // adoption of the Gregorian calendar (see IsGregorian())
227 //
228 // All data and comments taken verbatim from "The Calendar FAQ (v 2.0)"
e9670814 229 // by Claus Tøndering, http://www.pip.dknet.dk/~c-t/calendar.html
0979c962
VZ
230 // except for the comments "we take".
231 //
232 // Symbol "->" should be read as "was followed by" in the comments
233 // which follow.
234 enum GregorianAdoption
235 {
236 Gr_Unknown, // no data for this country or it's too uncertain to use
237 Gr_Standard, // on the day 0 of Gregorian calendar: 15 Oct 1582
238
239 Gr_Alaska, // Oct 1867 when Alaska became part of the USA
240 Gr_Albania, // Dec 1912
241
242 Gr_Austria = Gr_Unknown, // Different regions on different dates
243 Gr_Austria_Brixen, // 5 Oct 1583 -> 16 Oct 1583
244 Gr_Austria_Salzburg = Gr_Austria_Brixen,
245 Gr_Austria_Tyrol = Gr_Austria_Brixen,
246 Gr_Austria_Carinthia, // 14 Dec 1583 -> 25 Dec 1583
247 Gr_Austria_Styria = Gr_Austria_Carinthia,
248
249 Gr_Belgium, // Then part of the Netherlands
250
251 Gr_Bulgaria = Gr_Unknown, // Unknown precisely (from 1915 to 1920)
252 Gr_Bulgaria_1, // 18 Mar 1916 -> 1 Apr 1916
253 Gr_Bulgaria_2, // 31 Mar 1916 -> 14 Apr 1916
254 Gr_Bulgaria_3, // 3 Sep 1920 -> 17 Sep 1920
255
256 Gr_Canada = Gr_Unknown, // Different regions followed the changes in
257 // Great Britain or France
258
259 Gr_China = Gr_Unknown, // Different authorities say:
260 Gr_China_1, // 18 Dec 1911 -> 1 Jan 1912
261 Gr_China_2, // 18 Dec 1928 -> 1 Jan 1929
262
263 Gr_Czechoslovakia, // (Bohemia and Moravia) 6 Jan 1584 -> 17 Jan 1584
264 Gr_Denmark, // (including Norway) 18 Feb 1700 -> 1 Mar 1700
265 Gr_Egypt, // 1875
266 Gr_Estonia, // 1918
267 Gr_Finland, // Then part of Sweden
268
269 Gr_France, // 9 Dec 1582 -> 20 Dec 1582
270 Gr_France_Alsace, // 4 Feb 1682 -> 16 Feb 1682
271 Gr_France_Lorraine, // 16 Feb 1760 -> 28 Feb 1760
272 Gr_France_Strasbourg, // February 1682
273
274 Gr_Germany = Gr_Unknown, // Different states on different dates:
275 Gr_Germany_Catholic, // 1583-1585 (we take 1584)
276 Gr_Germany_Prussia, // 22 Aug 1610 -> 2 Sep 1610
277 Gr_Germany_Protestant, // 18 Feb 1700 -> 1 Mar 1700
278
279 Gr_GreatBritain, // 2 Sep 1752 -> 14 Sep 1752 (use 'cal(1)')
280
281 Gr_Greece, // 9 Mar 1924 -> 23 Mar 1924
282 Gr_Hungary, // 21 Oct 1587 -> 1 Nov 1587
283 Gr_Ireland = Gr_GreatBritain,
284 Gr_Italy = Gr_Standard,
285
286 Gr_Japan = Gr_Unknown, // Different authorities say:
287 Gr_Japan_1, // 19 Dec 1872 -> 1 Jan 1873
288 Gr_Japan_2, // 19 Dec 1892 -> 1 Jan 1893
289 Gr_Japan_3, // 18 Dec 1918 -> 1 Jan 1919
290
291 Gr_Latvia, // 1915-1918 (we take 1915)
292 Gr_Lithuania, // 1915
293 Gr_Luxemburg, // 14 Dec 1582 -> 25 Dec 1582
294 Gr_Netherlands = Gr_Belgium, // (including Belgium) 1 Jan 1583
295
296 // this is too weird to take into account: the Gregorian calendar was
297 // introduced twice in Groningen, first time 28 Feb 1583 was followed
298 // by 11 Mar 1583, then it has gone back to Julian in the summer of
299 // 1584 and then 13 Dec 1700 -> 12 Jan 1701 - which is
300 // the date we take here
301 Gr_Netherlands_Groningen, // 13 Dec 1700 -> 12 Jan 1701
302 Gr_Netherlands_Gelderland, // 30 Jun 1700 -> 12 Jul 1700
303 Gr_Netherlands_Utrecht, // (and Overijssel) 30 Nov 1700->12 Dec 1700
304 Gr_Netherlands_Friesland, // (and Drenthe) 31 Dec 1700 -> 12 Jan 1701
305
306 Gr_Norway = Gr_Denmark, // Then part of Denmark
307 Gr_Poland = Gr_Standard,
308 Gr_Portugal = Gr_Standard,
309 Gr_Romania, // 31 Mar 1919 -> 14 Apr 1919
310 Gr_Russia, // 31 Jan 1918 -> 14 Feb 1918
311 Gr_Scotland = Gr_GreatBritain,
312 Gr_Spain = Gr_Standard,
313
314 // Sweden has a curious history. Sweden decided to make a gradual
315 // change from the Julian to the Gregorian calendar. By dropping every
316 // leap year from 1700 through 1740 the eleven superfluous days would
317 // be omitted and from 1 Mar 1740 they would be in sync with the
318 // Gregorian calendar. (But in the meantime they would be in sync with
319 // nobody!)
320 //
321 // So 1700 (which should have been a leap year in the Julian calendar)
322 // was not a leap year in Sweden. However, by mistake 1704 and 1708
323 // became leap years. This left Sweden out of synchronisation with
324 // both the Julian and the Gregorian world, so they decided to go back
325 // to the Julian calendar. In order to do this, they inserted an extra
326 // day in 1712, making that year a double leap year! So in 1712,
327 // February had 30 days in Sweden.
328 //
329 // Later, in 1753, Sweden changed to the Gregorian calendar by
330 // dropping 11 days like everyone else.
331 Gr_Sweden = Gr_Finland, // 17 Feb 1753 -> 1 Mar 1753
332
333 Gr_Switzerland = Gr_Unknown,// Different cantons used different dates
334 Gr_Switzerland_Catholic, // 1583, 1584 or 1597 (we take 1584)
335 Gr_Switzerland_Protestant, // 31 Dec 1700 -> 12 Jan 1701
336
337 Gr_Turkey, // 1 Jan 1927
338 Gr_USA = Gr_GreatBritain,
339 Gr_Wales = Gr_GreatBritain,
340 Gr_Yugoslavia // 1919
341 };
342
343 // the country parameter is used so far for calculating the start and
344 // the end of DST period and for deciding whether the date is a work
345 // day or not
346 //
347 // TODO move this to intl.h
5e967044
JS
348
349// Required for WinCE
350#ifdef USA
351#undef USA
352#endif
353
0979c962
VZ
354 enum Country
355 {
356 Country_Unknown, // no special information for this country
357 Country_Default, // set the default country with SetCountry() method
239446b4 358 // or use the default country with any other
0979c962
VZ
359
360 // TODO add more countries (for this we must know about DST and/or
361 // holidays for this country)
239446b4
VZ
362
363 // Western European countries: we assume that they all follow the same
364 // DST rules (true or false?)
365 Country_WesternEurope_Start,
366 Country_EEC = Country_WesternEurope_Start,
0979c962 367 France,
239446b4
VZ
368 Germany,
369 UK,
370 Country_WesternEurope_End = UK,
371
372 Russia,
0979c962
VZ
373 USA
374 };
0979c962
VZ
375 // symbolic names for the months
376 enum Month
377 {
378 Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec, Inv_Month
379 };
380
381 // symbolic names for the weekdays
382 enum WeekDay
383 {
384 Sun, Mon, Tue, Wed, Thu, Fri, Sat, Inv_WeekDay
385 };
386
387 // invalid value for the year
388 enum Year
389 {
b76b015e
VZ
390 Inv_Year = SHRT_MIN // should hold in wxDateTime_t
391 };
392
f0f951fa
VZ
393 // flags for GetWeekDayName and GetMonthName
394 enum NameFlags
395 {
396 Name_Full = 0x01, // return full name
397 Name_Abbr = 0x02 // return abbreviated name
398 };
399
9d9b7755
VZ
400 // flags for GetWeekOfYear and GetWeekOfMonth
401 enum WeekFlags
402 {
403 Default_First, // Sunday_First for US, Monday_First for the rest
404 Monday_First, // week starts with a Monday
405 Sunday_First // week starts with a Sunday
406 };
407
b76b015e
VZ
408 // helper classes
409 // ------------------------------------------------------------------------
410
299fcbfe
VZ
411 // a class representing a time zone: basicly, this is just an offset
412 // (in seconds) from GMT
bddd7a8d 413 class WXDLLIMPEXP_BASE TimeZone
299fcbfe
VZ
414 {
415 public:
416 TimeZone(TZ tz);
1cf57808
VZ
417
418 // create time zone object with the given offset
419 TimeZone(long offset = 0) { m_offset = offset; }
420
421 static TimeZone Make(long offset)
422 {
423 TimeZone tz;
424 tz.m_offset = offset;
425 return tz;
426 }
299fcbfe 427
cd0b1709 428 long GetOffset() const { return m_offset; }
299fcbfe
VZ
429
430 private:
431 // offset for this timezone from GMT in seconds
cd0b1709 432 long m_offset;
299fcbfe
VZ
433 };
434
b76b015e
VZ
435 // standard struct tm is limited to the years from 1900 (because
436 // tm_year field is the offset from 1900), so we use our own struct
437 // instead to represent broken down time
fcc3d7cb
VZ
438 //
439 // NB: this struct should always be kept normalized (i.e. mon should
440 // be < 12, 1 <= day <= 31 &c), so use AddMonths(), AddDays()
441 // instead of modifying the member fields directly!
bddd7a8d 442 struct WXDLLIMPEXP_BASE Tm
b76b015e 443 {
5ed8879e
VZ
444 wxDateTime_t msec, sec, min, hour,
445 mday, // Day of the month in 1..31 range.
446 yday; // Day of the year in 0..365 range.
fcc3d7cb
VZ
447 Month mon;
448 int year;
b76b015e
VZ
449
450 // default ctor inits the object to an invalid value
451 Tm();
452
299fcbfe
VZ
453 // ctor from struct tm and the timezone
454 Tm(const struct tm& tm, const TimeZone& tz);
b76b015e
VZ
455
456 // check that the given date/time is valid (in Gregorian calendar)
457 bool IsValid() const;
458
459 // get the week day
460 WeekDay GetWeekDay() // not const because wday may be changed
461 {
462 if ( wday == Inv_WeekDay )
463 ComputeWeekDay();
464
465 return (WeekDay)wday;
466 }
467
fcc3d7cb 468 // add the given number of months to the date keeping it normalized
e6ec579c 469 void AddMonths(int monDiff);
fcc3d7cb
VZ
470
471 // add the given number of months to the date keeping it normalized
e6ec579c 472 void AddDays(int dayDiff);
fcc3d7cb 473
b76b015e
VZ
474 private:
475 // compute the weekday from other fields
476 void ComputeWeekDay();
477
299fcbfe
VZ
478 // the timezone we correspond to
479 TimeZone m_tz;
480
5ed8879e
VZ
481 // This value can only be accessed via GetWeekDay() and not directly
482 // because it's not always computed when creating this object and may
483 // need to be calculated on demand.
484 wxDateTime_t wday;
b76b015e
VZ
485 };
486
0979c962
VZ
487 // static methods
488 // ------------------------------------------------------------------------
489
490 // set the current country
491 static void SetCountry(Country country);
492 // get the current country
239446b4
VZ
493 static Country GetCountry();
494
68379eaf 495 // return true if the country is a West European one (in practice,
239446b4
VZ
496 // this means that the same DST rules as for EEC apply)
497 static bool IsWestEuropeanCountry(Country country = Country_Default);
0979c962
VZ
498
499 // return the current year
500 static int GetCurrentYear(Calendar cal = Gregorian);
501
502 // convert the year as returned by wxDateTime::GetYear() to a year
503 // suitable for BC/AD notation. The difference is that BC year 1
504 // corresponds to the year 0 (while BC year 0 didn't exist) and AD
505 // year N is just year N.
506 static int ConvertYearToBC(int year);
507
508 // return the current month
509 static Month GetCurrentMonth(Calendar cal = Gregorian);
510
68379eaf 511 // returns true if the given year is a leap year in the given calendar
2f02cb89
VZ
512 static bool IsLeapYear(int year = Inv_Year, Calendar cal = Gregorian);
513
514 // get the century (19 for 1999, 20 for 2000 and -5 for 492 BC)
a333edbd 515 static int GetCentury(int year);
0979c962 516
b76b015e
VZ
517 // returns the number of days in this year (356 or 355 for Gregorian
518 // calendar usually :-)
0979c962
VZ
519 static wxDateTime_t GetNumberOfDays(int year, Calendar cal = Gregorian);
520
521 // get the number of the days in the given month (default value for
522 // the year means the current one)
523 static wxDateTime_t GetNumberOfDays(Month month,
524 int year = Inv_Year,
525 Calendar cal = Gregorian);
526
e538985e 527
b76b015e
VZ
528 // get the full (default) or abbreviated month name in the current
529 // locale, returns empty string on error
f0f951fa
VZ
530 static wxString GetMonthName(Month month,
531 NameFlags flags = Name_Full);
0979c962 532
e538985e
VZ
533 // get the standard English full (default) or abbreviated month name
534 static wxString GetEnglishMonthName(Month month,
535 NameFlags flags = Name_Full);
536
b76b015e
VZ
537 // get the full (default) or abbreviated weekday name in the current
538 // locale, returns empty string on error
f0f951fa
VZ
539 static wxString GetWeekDayName(WeekDay weekday,
540 NameFlags flags = Name_Full);
541
e538985e
VZ
542 // get the standard English full (default) or abbreviated weekday name
543 static wxString GetEnglishWeekDayName(WeekDay weekday,
544 NameFlags flags = Name_Full);
545
f0f951fa
VZ
546 // get the AM and PM strings in the current locale (may be empty)
547 static void GetAmPmStrings(wxString *am, wxString *pm);
0979c962 548
68379eaf 549 // return true if the given country uses DST for this year
239446b4
VZ
550 static bool IsDSTApplicable(int year = Inv_Year,
551 Country country = Country_Default);
552
0979c962
VZ
553 // get the beginning of DST for this year, will return invalid object
554 // if no DST applicable in this year. The default value of the
555 // parameter means to take the current year.
239446b4
VZ
556 static wxDateTime GetBeginDST(int year = Inv_Year,
557 Country country = Country_Default);
0979c962
VZ
558 // get the end of DST for this year, will return invalid object
559 // if no DST applicable in this year. The default value of the
560 // parameter means to take the current year.
239446b4
VZ
561 static wxDateTime GetEndDST(int year = Inv_Year,
562 Country country = Country_Default);
0979c962 563
b76b015e
VZ
564 // return the wxDateTime object for the current time
565 static inline wxDateTime Now();
566
f6bcfd97
BP
567 // return the wxDateTime object for the current time with millisecond
568 // precision (if available on this platform)
569 static wxDateTime UNow();
570
cd0b1709
VZ
571 // return the wxDateTime object for today midnight: i.e. as Now() but
572 // with time set to 0
573 static inline wxDateTime Today();
574
0979c962
VZ
575 // constructors: you should test whether the constructor succeeded with
576 // IsValid() function. The values Inv_Month and Inv_Year for the
577 // parameters mean take current month and/or year values.
578 // ------------------------------------------------------------------------
579
580 // default ctor does not initialize the object, use Set()!
4bd53224 581 wxDateTime() { m_time = wxLongLong(wxINT32_MIN, 0); }
0979c962
VZ
582
583 // from time_t: seconds since the Epoch 00:00:00 UTC, Jan 1, 1970)
16ee521a
DW
584#if (!(defined(__VISAGECPP__) && __IBMCPP__ >= 400))
585// VA C++ confuses this with wxDateTime(double jdn) thinking it is a duplicate declaration
0979c962 586 inline wxDateTime(time_t timet);
16ee521a 587#endif
b76b015e 588 // from broken down time/date (only for standard Unix range)
0979c962 589 inline wxDateTime(const struct tm& tm);
b76b015e
VZ
590 // from broken down time/date (any range)
591 inline wxDateTime(const Tm& tm);
0979c962 592
e6ec579c
VZ
593 // from JDN (beware of rounding errors)
594 inline wxDateTime(double jdn);
595
0979c962
VZ
596 // from separate values for each component, date set to today
597 inline wxDateTime(wxDateTime_t hour,
598 wxDateTime_t minute = 0,
599 wxDateTime_t second = 0,
600 wxDateTime_t millisec = 0);
601 // from separate values for each component with explicit date
b76b015e 602 inline wxDateTime(wxDateTime_t day, // day of the month
33ac7e6f 603 Month month,
0979c962
VZ
604 int year = Inv_Year, // 1999, not 99 please!
605 wxDateTime_t hour = 0,
606 wxDateTime_t minute = 0,
607 wxDateTime_t second = 0,
608 wxDateTime_t millisec = 0);
154014d6
VZ
609#ifdef __WXMSW__
610 wxDateTime(const struct _SYSTEMTIME& st)
611 {
612 SetFromMSWSysTime(st);
613 }
614#endif
0979c962
VZ
615
616 // default copy ctor ok
617
618 // no dtor
619
620 // assignment operators and Set() functions: all non const methods return
621 // the reference to this object. IsValid() should be used to test whether
622 // the function succeeded.
623 // ------------------------------------------------------------------------
624
625 // set to the current time
626 inline wxDateTime& SetToCurrent();
627
16ee521a
DW
628#if (!(defined(__VISAGECPP__) && __IBMCPP__ >= 400))
629// VA C++ confuses this with wxDateTime(double jdn) thinking it is a duplicate declaration
0979c962
VZ
630 // set to given time_t value
631 inline wxDateTime& Set(time_t timet);
16ee521a 632#endif
0979c962
VZ
633
634 // set to given broken down time/date
635 wxDateTime& Set(const struct tm& tm);
636
b76b015e
VZ
637 // set to given broken down time/date
638 inline wxDateTime& Set(const Tm& tm);
639
e6ec579c
VZ
640 // set to given JDN (beware of rounding errors)
641 wxDateTime& Set(double jdn);
642
0979c962
VZ
643 // set to given time, date = today
644 wxDateTime& Set(wxDateTime_t hour,
645 wxDateTime_t minute = 0,
646 wxDateTime_t second = 0,
647 wxDateTime_t millisec = 0);
648
649 // from separate values for each component with explicit date
650 // (defaults for month and year are the current values)
651 wxDateTime& Set(wxDateTime_t day,
33ac7e6f 652 Month month,
0979c962
VZ
653 int year = Inv_Year, // 1999, not 99 please!
654 wxDateTime_t hour = 0,
655 wxDateTime_t minute = 0,
656 wxDateTime_t second = 0,
657 wxDateTime_t millisec = 0);
658
659 // resets time to 00:00:00, doesn't change the date
660 wxDateTime& ResetTime();
661
fb96cf85
VZ
662 // get the date part of this object only, i.e. the object which has the
663 // same date as this one but time of 00:00:00
664 wxDateTime GetDateOnly() const;
fb96cf85 665
0979c962
VZ
666 // the following functions don't change the values of the other
667 // fields, i.e. SetMinute() won't change either hour or seconds value
668
669 // set the year
670 wxDateTime& SetYear(int year);
671 // set the month
672 wxDateTime& SetMonth(Month month);
673 // set the day of the month
674 wxDateTime& SetDay(wxDateTime_t day);
675 // set hour
676 wxDateTime& SetHour(wxDateTime_t hour);
677 // set minute
678 wxDateTime& SetMinute(wxDateTime_t minute);
679 // set second
680 wxDateTime& SetSecond(wxDateTime_t second);
681 // set millisecond
682 wxDateTime& SetMillisecond(wxDateTime_t millisecond);
683
684 // assignment operator from time_t
685 wxDateTime& operator=(time_t timet) { return Set(timet); }
686
687 // assignment operator from broken down time/date
688 wxDateTime& operator=(const struct tm& tm) { return Set(tm); }
689
b76b015e
VZ
690 // assignment operator from broken down time/date
691 wxDateTime& operator=(const Tm& tm) { return Set(tm); }
692
0979c962
VZ
693 // default assignment operator is ok
694
695 // calendar calculations (functions which set the date only leave the time
4f6aed9c
VZ
696 // unchanged, e.g. don't explictly zero it): SetXXX() functions modify the
697 // object itself, GetXXX() ones return a new object.
0979c962
VZ
698 // ------------------------------------------------------------------------
699
cd0b1709 700 // set to the given week day in the same week as this one
2b5f62a0
VZ
701 wxDateTime& SetToWeekDayInSameWeek(WeekDay weekday,
702 WeekFlags flags = Monday_First);
703 inline wxDateTime GetWeekDayInSameWeek(WeekDay weekday,
704 WeekFlags flags = Monday_First) const;
cd0b1709
VZ
705
706 // set to the next week day following this one
707 wxDateTime& SetToNextWeekDay(WeekDay weekday);
4f6aed9c 708 inline wxDateTime GetNextWeekDay(WeekDay weekday) const;
cd0b1709 709
2ef31e80 710 // set to the previous week day before this one
cd0b1709 711 wxDateTime& SetToPrevWeekDay(WeekDay weekday);
4f6aed9c 712 inline wxDateTime GetPrevWeekDay(WeekDay weekday) const;
cd0b1709 713
7929902d 714 // set to Nth occurrence of given weekday in the given month of the
68379eaf 715 // given year (time is set to 0), return true on success and false on
0979c962
VZ
716 // failure. n may be positive (1..5) or negative to count from the end
717 // of the month (see helper function SetToLastWeekDay())
718 bool SetToWeekDay(WeekDay weekday,
719 int n = 1,
2f02cb89 720 Month month = Inv_Month,
0979c962 721 int year = Inv_Year);
4f6aed9c
VZ
722 inline wxDateTime GetWeekDay(WeekDay weekday,
723 int n = 1,
724 Month month = Inv_Month,
725 int year = Inv_Year) const;
0979c962
VZ
726
727 // sets to the last weekday in the given month, year
728 inline bool SetToLastWeekDay(WeekDay weekday,
2f02cb89 729 Month month = Inv_Month,
0979c962 730 int year = Inv_Year);
4f6aed9c
VZ
731 inline wxDateTime GetLastWeekDay(WeekDay weekday,
732 Month month = Inv_Month,
733 int year = Inv_Year);
0979c962 734
ca3e85cf 735#if WXWIN_COMPATIBILITY_2_6
0979c962 736 // sets the date to the given day of the given week in the year,
68379eaf 737 // returns true on success and false if given date doesn't exist (e.g.
0979c962 738 // numWeek is > 53)
4c27e2fa
VZ
739 //
740 // these functions are badly defined as they're not the reverse of
741 // GetWeekOfYear(), use SetToTheWeekOfYear() instead
742 wxDEPRECATED( bool SetToTheWeek(wxDateTime_t numWeek,
743 WeekDay weekday = Mon,
744 WeekFlags flags = Monday_First) );
745 wxDEPRECATED( wxDateTime GetWeek(wxDateTime_t numWeek,
746 WeekDay weekday = Mon,
747 WeekFlags flags = Monday_First) const );
ca3e85cf 748#endif // WXWIN_COMPATIBILITY_2_6
4c27e2fa
VZ
749
750 // returns the date corresponding to the given week day of the given
751 // week (in ISO notation) of the specified year
752 static wxDateTime SetToWeekOfYear(int year,
753 wxDateTime_t numWeek,
754 WeekDay weekday = Mon);
0979c962 755
2f02cb89
VZ
756 // sets the date to the last day of the given (or current) month or the
757 // given (or current) year
758 wxDateTime& SetToLastMonthDay(Month month = Inv_Month,
759 int year = Inv_Year);
4f6aed9c
VZ
760 inline wxDateTime GetLastMonthDay(Month month = Inv_Month,
761 int year = Inv_Year) const;
0979c962 762
f0f951fa
VZ
763 // sets to the given year day (1..365 or 366)
764 wxDateTime& SetToYearDay(wxDateTime_t yday);
4f6aed9c 765 inline wxDateTime GetYearDay(wxDateTime_t yday) const;
f0f951fa 766
0979c962
VZ
767 // The definitions below were taken verbatim from
768 //
769 // http://www.capecod.net/~pbaum/date/date0.htm
770 //
771 // (Peter Baum's home page)
772 //
773 // definition: The Julian Day Number, Julian Day, or JD of a
774 // particular instant of time is the number of days and fractions of a
775 // day since 12 hours Universal Time (Greenwich mean noon) on January
776 // 1 of the year -4712, where the year is given in the Julian
777 // proleptic calendar. The idea of using this reference date was
778 // originally proposed by Joseph Scalizer in 1582 to count years but
779 // it was modified by 19th century astronomers to count days. One
780 // could have equivalently defined the reference time to be noon of
781 // November 24, -4713 if were understood that Gregorian calendar rules
782 // were applied. Julian days are Julian Day Numbers and are not to be
783 // confused with Julian dates.
784 //
785 // definition: The Rata Die number is a date specified as the number
786 // of days relative to a base date of December 31 of the year 0. Thus
787 // January 1 of the year 1 is Rata Die day 1.
788
e6ec579c
VZ
789 // get the Julian Day number (the fractional part specifies the time of
790 // the day, related to noon - beware of rounding errors!)
791 double GetJulianDayNumber() const;
239446b4
VZ
792 double GetJDN() const { return GetJulianDayNumber(); }
793
794 // get the Modified Julian Day number: it is equal to JDN - 2400000.5
795 // and so integral MJDs correspond to the midnights (and not noons).
796 // MJD 0 is Nov 17, 1858
797 double GetModifiedJulianDayNumber() const { return GetJDN() - 2400000.5; }
798 double GetMJD() const { return GetModifiedJulianDayNumber(); }
0979c962
VZ
799
800 // get the Rata Die number
e6ec579c 801 double GetRataDie() const;
0979c962
VZ
802
803 // TODO algorithms for calculating some important dates, such as
804 // religious holidays (Easter...) or moon/solar eclipses? Some
805 // algorithms can be found in the calendar FAQ
806
d26adb9d
VZ
807
808 // Timezone stuff: a wxDateTime object constructed using given
809 // day/month/year/hour/min/sec values is interpreted as this moment in
810 // local time. Using the functions below, it may be converted to another
811 // time zone (e.g., the Unix epoch is wxDateTime(1, Jan, 1970).ToGMT()).
299fcbfe 812 //
d26adb9d 813 // These functions try to handle DST internally, but there is no magical
41acf5c0
VZ
814 // way to know all rules for it in all countries in the world, so if the
815 // program can handle it itself (or doesn't want to handle it at all for
816 // whatever reason), the DST handling can be disabled with noDST.
b76b015e
VZ
817 // ------------------------------------------------------------------------
818
299fcbfe 819 // transform to any given timezone
68379eaf
WS
820 inline wxDateTime ToTimezone(const TimeZone& tz, bool noDST = false) const;
821 wxDateTime& MakeTimezone(const TimeZone& tz, bool noDST = false);
b76b015e 822
d26adb9d
VZ
823 // interpret current value as being in another timezone and transform
824 // it to local one
825 inline wxDateTime FromTimezone(const TimeZone& tz, bool noDST = false) const;
826 wxDateTime& MakeFromTimezone(const TimeZone& tz, bool noDST = false);
d26adb9d
VZ
827
828 // transform to/from GMT/UTC
829 wxDateTime ToUTC(bool noDST = false) const { return ToTimezone(UTC, noDST); }
830 wxDateTime& MakeUTC(bool noDST = false) { return MakeTimezone(UTC, noDST); }
831
832 wxDateTime ToGMT(bool noDST = false) const { return ToUTC(noDST); }
833 wxDateTime& MakeGMT(bool noDST = false) { return MakeUTC(noDST); }
834
d26adb9d
VZ
835 wxDateTime FromUTC(bool noDST = false) const
836 { return FromTimezone(UTC, noDST); }
837 wxDateTime& MakeFromUTC(bool noDST = false)
838 { return MakeFromTimezone(UTC, noDST); }
fcc3d7cb 839
239446b4
VZ
840 // is daylight savings time in effect at this moment according to the
841 // rules of the specified country?
842 //
843 // Return value is > 0 if DST is in effect, 0 if it is not and -1 if
844 // the information is not available (this is compatible with ANSI C)
845 int IsDST(Country country = Country_Default) const;
846
d26adb9d 847
0979c962
VZ
848 // accessors: many of them take the timezone parameter which indicates the
849 // timezone for which to make the calculations and the default value means
850 // to do it for the current timezone of this machine (even if the function
851 // only operates with the date it's necessary because a date may wrap as
852 // result of timezone shift)
853 // ------------------------------------------------------------------------
854
c3302e7e 855 // is the date valid?
384223b3 856 inline bool IsValid() const { return m_time != wxInvalidDateTime.m_time; }
0979c962 857
299fcbfe
VZ
858 // get the broken down date/time representation in the given timezone
859 //
860 // If you wish to get several time components (day, month and year),
861 // consider getting the whole Tm strcuture first and retrieving the
862 // value from it - this is much more efficient
863 Tm GetTm(const TimeZone& tz = Local) const;
b76b015e
VZ
864
865 // get the number of seconds since the Unix epoch - returns (time_t)-1
866 // if the value is out of range
867 inline time_t GetTicks() const;
868
a333edbd
VZ
869 // get the century, same as GetCentury(GetYear())
870 int GetCentury(const TimeZone& tz = Local) const
871 { return GetCentury(GetYear(tz)); }
0979c962 872 // get the year (returns Inv_Year if date is invalid)
16ee521a 873 int GetYear(const TimeZone& tz = Local) const
299fcbfe 874 { return GetTm(tz).year; }
0979c962 875 // get the month (Inv_Month if date is invalid)
16ee521a 876 Month GetMonth(const TimeZone& tz = Local) const
299fcbfe 877 { return (Month)GetTm(tz).mon; }
0979c962 878 // get the month day (in 1..31 range, 0 if date is invalid)
16ee521a 879 wxDateTime_t GetDay(const TimeZone& tz = Local) const
299fcbfe 880 { return GetTm(tz).mday; }
0979c962 881 // get the day of the week (Inv_WeekDay if date is invalid)
16ee521a 882 WeekDay GetWeekDay(const TimeZone& tz = Local) const
299fcbfe 883 { return GetTm(tz).GetWeekDay(); }
0979c962 884 // get the hour of the day
16ee521a 885 wxDateTime_t GetHour(const TimeZone& tz = Local) const
299fcbfe 886 { return GetTm(tz).hour; }
0979c962 887 // get the minute
16ee521a 888 wxDateTime_t GetMinute(const TimeZone& tz = Local) const
299fcbfe 889 { return GetTm(tz).min; }
0979c962 890 // get the second
16ee521a 891 wxDateTime_t GetSecond(const TimeZone& tz = Local) const
299fcbfe 892 { return GetTm(tz).sec; }
0979c962 893 // get milliseconds
16ee521a 894 wxDateTime_t GetMillisecond(const TimeZone& tz = Local) const
299fcbfe 895 { return GetTm(tz).msec; }
0979c962
VZ
896
897 // get the day since the year start (1..366, 0 if date is invalid)
299fcbfe 898 wxDateTime_t GetDayOfYear(const TimeZone& tz = Local) const;
cd0b1709 899 // get the week number since the year start (1..52 or 53, 0 if date is
0979c962 900 // invalid)
9d9b7755
VZ
901 wxDateTime_t GetWeekOfYear(WeekFlags flags = Monday_First,
902 const TimeZone& tz = Local) const;
cd0b1709
VZ
903 // get the week number since the month start (1..5, 0 if date is
904 // invalid)
9d9b7755
VZ
905 wxDateTime_t GetWeekOfMonth(WeekFlags flags = Monday_First,
906 const TimeZone& tz = Local) const;
0979c962
VZ
907
908 // is this date a work day? This depends on a country, of course,
909 // because the holidays are different in different countries
4f6aed9c 910 bool IsWorkDay(Country country = Country_Default) const;
0979c962
VZ
911
912 // is this date later than Gregorian calendar introduction for the
913 // given country (see enum GregorianAdoption)?
914 //
4f6aed9c 915 // NB: this function shouldn't be considered as absolute authority in
0979c962
VZ
916 // the matter. Besides, for some countries the exact date of
917 // adoption of the Gregorian calendar is simply unknown.
b76b015e 918 bool IsGregorianDate(GregorianAdoption country = Gr_Standard) const;
0979c962 919
2b5f62a0
VZ
920 // dos date and time format
921 // ------------------------------------------------------------------------
922
923 // set from the DOS packed format
924 wxDateTime& SetFromDOS(unsigned long ddt);
925
926 // pack the date in DOS format
927 unsigned long GetAsDOS() const;
928
154014d6
VZ
929 // SYSTEMTIME format
930 // ------------------------------------------------------------------------
931#ifdef __WXMSW__
154014d6 932 // convert SYSTEMTIME to wxDateTime
10acc3ef 933 wxDateTime& SetFromMSWSysTime(const struct _SYSTEMTIME& st);
154014d6
VZ
934
935 // convert wxDateTime to SYSTEMTIME
10acc3ef
VZ
936 void GetAsMSWSysTime(struct _SYSTEMTIME* st) const;
937
938 // same as above but only take date part into account, time is always zero
939 wxDateTime& SetFromMSWSysDate(const struct _SYSTEMTIME& st);
940 void GetAsMSWSysDate(struct _SYSTEMTIME* st) const;
154014d6
VZ
941#endif // __WXMSW__
942
0979c962
VZ
943 // comparison (see also functions below for operator versions)
944 // ------------------------------------------------------------------------
945
68379eaf 946 // returns true if the two moments are strictly identical
b76b015e
VZ
947 inline bool IsEqualTo(const wxDateTime& datetime) const;
948
68379eaf 949 // returns true if the date is strictly earlier than the given one
b76b015e 950 inline bool IsEarlierThan(const wxDateTime& datetime) const;
0979c962 951
68379eaf 952 // returns true if the date is strictly later than the given one
b76b015e 953 inline bool IsLaterThan(const wxDateTime& datetime) const;
0979c962 954
68379eaf 955 // returns true if the date is strictly in the given range
b76b015e
VZ
956 inline bool IsStrictlyBetween(const wxDateTime& t1,
957 const wxDateTime& t2) const;
958
68379eaf 959 // returns true if the date is in the given range
b76b015e 960 inline bool IsBetween(const wxDateTime& t1, const wxDateTime& t2) const;
0979c962 961
be4017f8
VZ
962 // do these two objects refer to the same date?
963 inline bool IsSameDate(const wxDateTime& dt) const;
964
965 // do these two objects have the same time?
966 inline bool IsSameTime(const wxDateTime& dt) const;
967
968 // are these two objects equal up to given timespan?
969 inline bool IsEqualUpTo(const wxDateTime& dt, const wxTimeSpan& ts) const;
970
26364344
WS
971 inline bool operator<(const wxDateTime& dt) const
972 {
9a83f860 973 wxASSERT_MSG( IsValid() && dt.IsValid(), wxT("invalid wxDateTime") );
26364344
WS
974 return GetValue() < dt.GetValue();
975 }
976
977 inline bool operator<=(const wxDateTime& dt) const
978 {
9a83f860 979 wxASSERT_MSG( IsValid() && dt.IsValid(), wxT("invalid wxDateTime") );
26364344
WS
980 return GetValue() <= dt.GetValue();
981 }
982
983 inline bool operator>(const wxDateTime& dt) const
984 {
9a83f860 985 wxASSERT_MSG( IsValid() && dt.IsValid(), wxT("invalid wxDateTime") );
26364344
WS
986 return GetValue() > dt.GetValue();
987 }
988
989 inline bool operator>=(const wxDateTime& dt) const
990 {
9a83f860 991 wxASSERT_MSG( IsValid() && dt.IsValid(), wxT("invalid wxDateTime") );
26364344
WS
992 return GetValue() >= dt.GetValue();
993 }
994
995 inline bool operator==(const wxDateTime& dt) const
996 {
9a83f860 997 wxASSERT_MSG( IsValid() && dt.IsValid(), wxT("invalid wxDateTime") );
26364344
WS
998 return GetValue() == dt.GetValue();
999 }
1000
1001 inline bool operator!=(const wxDateTime& dt) const
1002 {
9a83f860 1003 wxASSERT_MSG( IsValid() && dt.IsValid(), wxT("invalid wxDateTime") );
26364344
WS
1004 return GetValue() != dt.GetValue();
1005 }
1006
cd0b1709 1007 // arithmetics with dates (see also below for more operators)
0979c962
VZ
1008 // ------------------------------------------------------------------------
1009
cd0b1709
VZ
1010 // return the sum of the date with a time span (positive or negative)
1011 inline wxDateTime Add(const wxTimeSpan& diff) const;
0979c962 1012 // add a time span (positive or negative)
b76b015e 1013 inline wxDateTime& Add(const wxTimeSpan& diff);
0979c962 1014 // add a time span (positive or negative)
b76b015e 1015 inline wxDateTime& operator+=(const wxTimeSpan& diff);
26364344
WS
1016 inline wxDateTime operator+(const wxTimeSpan& ts) const
1017 {
1018 wxDateTime dt(*this);
1019 dt.Add(ts);
1020 return dt;
1021 }
0979c962 1022
cd0b1709 1023 // return the difference of the date with a time span
f6bcfd97
BP
1024 inline wxDateTime Subtract(const wxTimeSpan& diff) const;
1025 // subtract a time span (positive or negative)
1026 inline wxDateTime& Subtract(const wxTimeSpan& diff);
1027 // subtract a time span (positive or negative)
0979c962 1028 inline wxDateTime& operator-=(const wxTimeSpan& diff);
26364344
WS
1029 inline wxDateTime operator-(const wxTimeSpan& ts) const
1030 {
1031 wxDateTime dt(*this);
1032 dt.Subtract(ts);
1033 return dt;
1034 }
0979c962 1035
cd0b1709
VZ
1036 // return the sum of the date with a date span
1037 inline wxDateTime Add(const wxDateSpan& diff) const;
0979c962
VZ
1038 // add a date span (positive or negative)
1039 wxDateTime& Add(const wxDateSpan& diff);
1040 // add a date span (positive or negative)
b76b015e 1041 inline wxDateTime& operator+=(const wxDateSpan& diff);
26364344
WS
1042 inline wxDateTime operator+(const wxDateSpan& ds) const
1043 {
1044 wxDateTime dt(*this);
1045 dt.Add(ds);
1046 return dt;
1047 }
0979c962 1048
cd0b1709 1049 // return the difference of the date with a date span
f6bcfd97
BP
1050 inline wxDateTime Subtract(const wxDateSpan& diff) const;
1051 // subtract a date span (positive or negative)
1052 inline wxDateTime& Subtract(const wxDateSpan& diff);
1053 // subtract a date span (positive or negative)
0979c962 1054 inline wxDateTime& operator-=(const wxDateSpan& diff);
26364344
WS
1055 inline wxDateTime operator-(const wxDateSpan& ds) const
1056 {
1057 wxDateTime dt(*this);
1058 dt.Subtract(ds);
1059 return dt;
1060 }
0979c962 1061
cd0b1709 1062 // return the difference between two dates
f6bcfd97 1063 inline wxTimeSpan Subtract(const wxDateTime& dt) const;
26364344 1064 inline wxTimeSpan operator-(const wxDateTime& dt2) const;
0979c962 1065
c398434d 1066 // conversion to/from text
0979c962
VZ
1067 // ------------------------------------------------------------------------
1068
c398434d
VZ
1069 // all conversions functions return true to indicate whether parsing
1070 // succeeded or failed and fill in the provided end iterator, which must
1071 // not be NULL, with the location of the character where the parsing
1072 // stopped (this will be end() of the passed string if everything was
1073 // parsed)
1074
0979c962
VZ
1075 // parse a string in RFC 822 format (found e.g. in mail headers and
1076 // having the form "Wed, 10 Feb 1999 19:07:07 +0100")
c398434d
VZ
1077 bool ParseRfc822Date(const wxString& date,
1078 wxString::const_iterator *end);
75a29ef1 1079
f0f951fa
VZ
1080 // parse a date/time in the given format (see strptime(3)), fill in
1081 // the missing (in the string) fields with the values of dateDef (by
1082 // default, they will not change if they had valid values or will
1083 // default to Today() otherwise)
c398434d
VZ
1084 bool ParseFormat(const wxString& date,
1085 const wxString& format,
1086 const wxDateTime& dateDef,
1087 wxString::const_iterator *end);
1088
1089 bool ParseFormat(const wxString& date,
1090 const wxString& format,
1091 wxString::const_iterator *end)
71ebd60b
VZ
1092 {
1093 return ParseFormat(date, format, wxDefaultDateTime, end);
1094 }
1095
c398434d
VZ
1096 bool ParseFormat(const wxString& date,
1097 wxString::const_iterator *end)
1098 {
1099 return ParseFormat(date, wxDefaultDateTimeFormat, wxDefaultDateTime, end);
1100 }
71ebd60b 1101
f3f2e255
VZ
1102 // parse a string containing date, time or both in ISO 8601 format
1103 //
1104 // notice that these functions are new in wx 3.0 and so we don't
1105 // provide compatibility overloads for them
1106 bool ParseISODate(const wxString& date)
1107 {
a0bcd61b 1108 wxString::const_iterator end;
c398434d 1109 return ParseFormat(date, wxS("%Y-%m-%d"), &end) && end == date.end();
f3f2e255
VZ
1110 }
1111
a0bcd61b 1112 bool ParseISOTime(const wxString& time)
f3f2e255 1113 {
a0bcd61b 1114 wxString::const_iterator end;
c398434d 1115 return ParseFormat(time, wxS("%H:%M:%S"), &end) && end == time.end();
f3f2e255
VZ
1116 }
1117
a0bcd61b 1118 bool ParseISOCombined(const wxString& datetime, char sep = 'T')
f3f2e255 1119 {
a0bcd61b 1120 wxString::const_iterator end;
f3f2e255 1121 const wxString fmt = wxS("%Y-%m-%d") + wxString(sep) + wxS("%H:%M:%S");
c398434d 1122 return ParseFormat(datetime, fmt, &end) && end == datetime.end();
f3f2e255
VZ
1123 }
1124
0979c962
VZ
1125 // parse a string containing the date/time in "free" format, this
1126 // function will try to make an educated guess at the string contents
c398434d
VZ
1127 bool ParseDateTime(const wxString& datetime,
1128 wxString::const_iterator *end);
71ebd60b 1129
cd0b1709
VZ
1130 // parse a string containing the date only in "free" format (less
1131 // flexible than ParseDateTime)
c398434d
VZ
1132 bool ParseDate(const wxString& date,
1133 wxString::const_iterator *end);
71ebd60b 1134
cd0b1709 1135 // parse a string containing the time only in "free" format
c398434d
VZ
1136 bool ParseTime(const wxString& time,
1137 wxString::const_iterator *end);
71ebd60b 1138
0979c962
VZ
1139
1140 // this function accepts strftime()-like format string (default
1141 // argument corresponds to the preferred date and time representation
1142 // for the current locale) and returns the string containing the
1143 // resulting text representation
12e82477 1144 wxString Format(const wxString& format = wxDefaultDateTimeFormat,
299fcbfe 1145 const TimeZone& tz = Local) const;
0979c962 1146 // preferred date representation for the current locale
f3f2e255 1147 wxString FormatDate() const { return Format(wxS("%x")); }
0979c962 1148 // preferred time representation for the current locale
f3f2e255 1149 wxString FormatTime() const { return Format(wxS("%X")); }
4f6aed9c 1150 // returns the string representing the date in ISO 8601 format
9d9b7755 1151 // (YYYY-MM-DD)
f3f2e255 1152 wxString FormatISODate() const { return Format(wxS("%Y-%m-%d")); }
4f6aed9c
VZ
1153 // returns the string representing the time in ISO 8601 format
1154 // (HH:MM:SS)
f3f2e255
VZ
1155 wxString FormatISOTime() const { return Format(wxS("%H:%M:%S")); }
1156 // return the combined date time representation in ISO 8601 format; the
1157 // separator character should be 'T' according to the standard but it
1158 // can also be useful to set it to ' '
1159 wxString FormatISOCombined(char sep = 'T') const
1160 { return FormatISODate() + sep + FormatISOTime(); }
0979c962 1161
c398434d
VZ
1162
1163 // backwards compatible versions of the parsing functions: they return an
1164 // object representing the next character following the date specification
1165 // (i.e. the one where the scan had to stop) or a special NULL-like object
1166 // on failure
1167 //
1168 // they're not deprecated because a lot of existing code uses them and
1169 // there is no particular harm in keeping them but you should still prefer
1170 // the versions above in the new code
1171 wxAnyStrPtr ParseRfc822Date(const wxString& date)
1172 {
1173 wxString::const_iterator end;
1174 return ParseRfc822Date(date, &end) ? wxAnyStrPtr(date, end)
1175 : wxAnyStrPtr();
1176 }
1177
1178 wxAnyStrPtr ParseFormat(const wxString& date,
1179 const wxString& format = wxDefaultDateTimeFormat,
1180 const wxDateTime& dateDef = wxDefaultDateTime)
1181 {
1182 wxString::const_iterator end;
1183 return ParseFormat(date, format, dateDef, &end) ? wxAnyStrPtr(date, end)
1184 : wxAnyStrPtr();
1185 }
1186
1187 wxAnyStrPtr ParseDateTime(const wxString& datetime)
1188 {
1189 wxString::const_iterator end;
1190 return ParseDateTime(datetime, &end) ? wxAnyStrPtr(datetime, end)
1191 : wxAnyStrPtr();
1192 }
1193
1194 wxAnyStrPtr ParseDate(const wxString& date)
1195 {
1196 wxString::const_iterator end;
1197 return ParseDate(date, &end) ? wxAnyStrPtr(date, end)
1198 : wxAnyStrPtr();
1199 }
1200
1201 wxAnyStrPtr ParseTime(const wxString& time)
1202 {
1203 wxString::const_iterator end;
1204 return ParseTime(time, &end) ? wxAnyStrPtr(time, end)
1205 : wxAnyStrPtr();
1206 }
1207
0979c962
VZ
1208 // implementation
1209 // ------------------------------------------------------------------------
1210
cd0b1709
VZ
1211 // construct from internal representation
1212 wxDateTime(const wxLongLong& time) { m_time = time; }
1213
0979c962
VZ
1214 // get the internal representation
1215 inline wxLongLong GetValue() const;
1216
0979c962 1217 // a helper function to get the current time_t
d3b9f782 1218 static time_t GetTimeNow() { return time(NULL); }
0979c962 1219
2f02cb89
VZ
1220 // another one to get the current time broken down
1221 static struct tm *GetTmNow()
1222 {
135d1ad0
JS
1223 static struct tm l_CurrentTime;
1224 return GetTmNow(&l_CurrentTime);
2f02cb89
VZ
1225 }
1226
a452689b
SN
1227 // get current time using thread-safe function
1228 static struct tm *GetTmNow(struct tm *tmstruct);
1229
2f02cb89 1230private:
0979c962 1231 // the current country - as it's the same for all program objects (unless
b76b015e
VZ
1232 // it runs on a _really_ big cluster system :-), this is a static member:
1233 // see SetCountry() and GetCountry()
0979c962
VZ
1234 static Country ms_country;
1235
0979c962
VZ
1236 // this constant is used to transform a time_t value to the internal
1237 // representation, as time_t is in seconds and we use milliseconds it's
1238 // fixed to 1000
cd0b1709 1239 static const long TIME_T_FACTOR;
0979c962 1240
68379eaf 1241 // returns true if we fall in range in which we can use standard ANSI C
b76b015e 1242 // functions
fcc3d7cb 1243 inline bool IsInStdRange() const;
b76b015e
VZ
1244
1245 // the internal representation of the time is the amount of milliseconds
1246 // elapsed since the origin which is set by convention to the UNIX/C epoch
1247 // value: the midnight of January 1, 1970 (UTC)
1248 wxLongLong m_time;
0979c962
VZ
1249};
1250
1251// ----------------------------------------------------------------------------
1252// This class contains a difference between 2 wxDateTime values, so it makes
f6bcfd97 1253// sense to add it to wxDateTime and it is the result of subtraction of 2
0979c962
VZ
1254// objects of that class. See also wxDateSpan.
1255// ----------------------------------------------------------------------------
b76b015e 1256
bddd7a8d 1257class WXDLLIMPEXP_BASE wxTimeSpan
0979c962
VZ
1258{
1259public:
1260 // constructors
1261 // ------------------------------------------------------------------------
1262
bd35ed32
VZ
1263 // return the timespan for the given number of milliseconds
1264 static wxTimeSpan Milliseconds(wxLongLong ms) { return wxTimeSpan(0, 0, 0, ms); }
1265 static wxTimeSpan Millisecond() { return Milliseconds(1); }
1266
fcc3d7cb 1267 // return the timespan for the given number of seconds
9c21e80b 1268 static wxTimeSpan Seconds(wxLongLong sec) { return wxTimeSpan(0, 0, sec); }
68ee7c47 1269 static wxTimeSpan Second() { return Seconds(1); }
fcc3d7cb
VZ
1270
1271 // return the timespan for the given number of minutes
6f2a55e3 1272 static wxTimeSpan Minutes(long min) { return wxTimeSpan(0, min, 0 ); }
68ee7c47 1273 static wxTimeSpan Minute() { return Minutes(1); }
fcc3d7cb
VZ
1274
1275 // return the timespan for the given number of hours
6f2a55e3 1276 static wxTimeSpan Hours(long hours) { return wxTimeSpan(hours, 0, 0); }
68ee7c47 1277 static wxTimeSpan Hour() { return Hours(1); }
fcc3d7cb 1278
cd0b1709 1279 // return the timespan for the given number of days
6f2a55e3 1280 static wxTimeSpan Days(long days) { return Hours(24 * days); }
68ee7c47 1281 static wxTimeSpan Day() { return Days(1); }
cd0b1709
VZ
1282
1283 // return the timespan for the given number of weeks
6f2a55e3 1284 static wxTimeSpan Weeks(long days) { return Days(7 * days); }
68ee7c47 1285 static wxTimeSpan Week() { return Weeks(1); }
cd0b1709 1286
0979c962
VZ
1287 // default ctor constructs the 0 time span
1288 wxTimeSpan() { }
1289
1290 // from separate values for each component, date set to 0 (hours are
1291 // not restricted to 0..24 range, neither are minutes, seconds or
1292 // milliseconds)
6f2a55e3
VZ
1293 inline wxTimeSpan(long hours,
1294 long minutes = 0,
9c21e80b
VZ
1295 wxLongLong seconds = 0,
1296 wxLongLong milliseconds = 0);
0979c962 1297
0979c962
VZ
1298 // default copy ctor is ok
1299
1300 // no dtor
1301
cd0b1709 1302 // arithmetics with time spans (see also below for more operators)
0979c962
VZ
1303 // ------------------------------------------------------------------------
1304
cd0b1709
VZ
1305 // return the sum of two timespans
1306 inline wxTimeSpan Add(const wxTimeSpan& diff) const;
0979c962
VZ
1307 // add two timespans together
1308 inline wxTimeSpan& Add(const wxTimeSpan& diff);
1309 // add two timespans together
1310 wxTimeSpan& operator+=(const wxTimeSpan& diff) { return Add(diff); }
26364344
WS
1311 inline wxTimeSpan operator+(const wxTimeSpan& ts) const
1312 {
1313 return wxTimeSpan(GetValue() + ts.GetValue());
1314 }
0979c962 1315
cd0b1709 1316 // return the difference of two timespans
f6bcfd97
BP
1317 inline wxTimeSpan Subtract(const wxTimeSpan& diff) const;
1318 // subtract another timespan
1319 inline wxTimeSpan& Subtract(const wxTimeSpan& diff);
1320 // subtract another timespan
1321 wxTimeSpan& operator-=(const wxTimeSpan& diff) { return Subtract(diff); }
26364344
WS
1322 inline wxTimeSpan operator-(const wxTimeSpan& ts)
1323 {
1324 return wxTimeSpan(GetValue() - ts.GetValue());
1325 }
0979c962 1326
cd0b1709
VZ
1327 // multiply timespan by a scalar
1328 inline wxTimeSpan Multiply(int n) const;
0979c962
VZ
1329 // multiply timespan by a scalar
1330 inline wxTimeSpan& Multiply(int n);
1331 // multiply timespan by a scalar
1332 wxTimeSpan& operator*=(int n) { return Multiply(n); }
26364344
WS
1333 inline wxTimeSpan operator*(int n) const
1334 {
1335 return wxTimeSpan(*this).Multiply(n);
1336 }
0979c962 1337
3103e8a9 1338 // return this timespan with opposite sign
b76b015e 1339 wxTimeSpan Negate() const { return wxTimeSpan(-GetValue()); }
0979c962
VZ
1340 // negate the value of the timespan
1341 wxTimeSpan& Neg() { m_diff = -GetValue(); return *this; }
1342 // negate the value of the timespan
1343 wxTimeSpan& operator-() { return Neg(); }
1344
1345 // return the absolute value of the timespan: does _not_ modify the
1346 // object
1347 inline wxTimeSpan Abs() const;
1348
1349 // there is intentionally no division because we don't want to
1350 // introduce rounding errors in time calculations
1351
1352 // comparaison (see also operator versions below)
1353 // ------------------------------------------------------------------------
1354
1355 // is the timespan null?
b76b015e 1356 bool IsNull() const { return m_diff == 0l; }
0979c962
VZ
1357 // returns true if the timespan is null
1358 bool operator!() const { return !IsNull(); }
1359
1360 // is the timespan positive?
b76b015e 1361 bool IsPositive() const { return m_diff > 0l; }
0979c962
VZ
1362
1363 // is the timespan negative?
b76b015e 1364 bool IsNegative() const { return m_diff < 0l; }
0979c962
VZ
1365
1366 // are two timespans equal?
1367 inline bool IsEqualTo(const wxTimeSpan& ts) const;
1368 // compare two timestamps: works with the absolute values, i.e. -2
68379eaf 1369 // hours is longer than 1 hour. Also, it will return false if the
0979c962
VZ
1370 // timespans are equal in absolute value.
1371 inline bool IsLongerThan(const wxTimeSpan& ts) const;
1372 // compare two timestamps: works with the absolute values, i.e. 1
68379eaf 1373 // hour is shorter than -2 hours. Also, it will return false if the
0979c962 1374 // timespans are equal in absolute value.
f7541d48 1375 bool IsShorterThan(const wxTimeSpan& t) const;
0979c962 1376
26364344
WS
1377 inline bool operator<(const wxTimeSpan &ts) const
1378 {
1379 return GetValue() < ts.GetValue();
1380 }
1381
1382 inline bool operator<=(const wxTimeSpan &ts) const
1383 {
1384 return GetValue() <= ts.GetValue();
1385 }
1386
1387 inline bool operator>(const wxTimeSpan &ts) const
1388 {
1389 return GetValue() > ts.GetValue();
1390 }
1391
1392 inline bool operator>=(const wxTimeSpan &ts) const
1393 {
1394 return GetValue() >= ts.GetValue();
1395 }
1396
1397 inline bool operator==(const wxTimeSpan &ts) const
1398 {
1399 return GetValue() == ts.GetValue();
1400 }
1401
1402 inline bool operator!=(const wxTimeSpan &ts) const
1403 {
1404 return GetValue() != ts.GetValue();
1405 }
1406
e6ec579c 1407 // breaking into days, hours, minutes and seconds
0979c962
VZ
1408 // ------------------------------------------------------------------------
1409
0979c962
VZ
1410 // get the max number of weeks in this timespan
1411 inline int GetWeeks() const;
1412 // get the max number of days in this timespan
1413 inline int GetDays() const;
1414 // get the max number of hours in this timespan
1415 inline int GetHours() const;
1416 // get the max number of minutes in this timespan
1417 inline int GetMinutes() const;
1418 // get the max number of seconds in this timespan
e6ec579c 1419 inline wxLongLong GetSeconds() const;
0979c962 1420 // get the number of milliseconds in this timespan
b76b015e 1421 wxLongLong GetMilliseconds() const { return m_diff; }
0979c962
VZ
1422
1423 // conversion to text
1424 // ------------------------------------------------------------------------
1425
1426 // this function accepts strftime()-like format string (default
1427 // argument corresponds to the preferred date and time representation
1428 // for the current locale) and returns the string containing the
1429 // resulting text representation. Notice that only some of format
1430 // specifiers valid for wxDateTime are valid for wxTimeSpan: hours,
1431 // minutes and seconds make sense, but not "PM/AM" string for example.
12e82477 1432 wxString Format(const wxString& format = wxDefaultTimeSpanFormat) const;
0979c962
VZ
1433
1434 // implementation
1435 // ------------------------------------------------------------------------
1436
cd0b1709
VZ
1437 // construct from internal representation
1438 wxTimeSpan(const wxLongLong& diff) { m_diff = diff; }
1439
0979c962
VZ
1440 // get the internal representation
1441 wxLongLong GetValue() const { return m_diff; }
1442
1443private:
1444 // the (signed) time span in milliseconds
1445 wxLongLong m_diff;
1446};
1447
1448// ----------------------------------------------------------------------------
1449// This class is a "logical time span" and is useful for implementing program
1450// logic for such things as "add one month to the date" which, in general,
1451// doesn't mean to add 60*60*24*31 seconds to it, but to take the same date
1452// the next month (to understand that this is indeed different consider adding
1453// one month to Feb, 15 - we want to get Mar, 15, of course).
1454//
1455// When adding a month to the date, all lesser components (days, hours, ...)
4f6aed9c
VZ
1456// won't be changed unless the resulting date would be invalid: for example,
1457// Jan 31 + 1 month will be Feb 28, not (non existing) Feb 31.
1458//
f6bcfd97 1459// Because of this feature, adding and subtracting back again the same
4f6aed9c
VZ
1460// wxDateSpan will *not*, in general give back the original date: Feb 28 - 1
1461// month will be Jan 28, not Jan 31!
0979c962
VZ
1462//
1463// wxDateSpan can be either positive or negative. They may be
1464// multiplied by scalars which multiply all deltas by the scalar: i.e. 2*(1
1465// month and 1 day) is 2 months and 2 days. They can be added together and
1466// with wxDateTime or wxTimeSpan, but the type of result is different for each
1467// case.
1468//
1469// Beware about weeks: if you specify both weeks and days, the total number of
1470// days added will be 7*weeks + days! See also GetTotalDays() function.
1471//
93401be9
VZ
1472// Equality operators are defined for wxDateSpans. Two datespans are equal if
1473// they both give the same target date when added to *every* source date.
1474// Thus wxDateSpan::Months(1) is not equal to wxDateSpan::Days(30), because
1475// they not give the same date when added to 1 Feb. But wxDateSpan::Days(14) is
1476// equal to wxDateSpan::Weeks(2)
1477//
0979c962
VZ
1478// Finally, notice that for adding hours, minutes &c you don't need this
1479// class: wxTimeSpan will do the job because there are no subtleties
1480// associated with those.
1481// ----------------------------------------------------------------------------
b76b015e 1482
bddd7a8d 1483class WXDLLIMPEXP_BASE wxDateSpan
0979c962
VZ
1484{
1485public:
1486 // constructors
1487 // ------------------------------------------------------------------------
1488
1489 // this many years/months/weeks/days
2f02cb89
VZ
1490 wxDateSpan(int years = 0, int months = 0, int weeks = 0, int days = 0)
1491 {
1492 m_years = years;
1493 m_months = months;
1494 m_weeks = weeks;
1495 m_days = days;
1496 }
1497
1498 // get an object for the given number of days
1499 static wxDateSpan Days(int days) { return wxDateSpan(0, 0, 0, days); }
68ee7c47 1500 static wxDateSpan Day() { return Days(1); }
2f02cb89
VZ
1501
1502 // get an object for the given number of weeks
1503 static wxDateSpan Weeks(int weeks) { return wxDateSpan(0, 0, weeks, 0); }
68ee7c47 1504 static wxDateSpan Week() { return Weeks(1); }
2f02cb89
VZ
1505
1506 // get an object for the given number of months
1507 static wxDateSpan Months(int mon) { return wxDateSpan(0, mon, 0, 0); }
68ee7c47 1508 static wxDateSpan Month() { return Months(1); }
2f02cb89
VZ
1509
1510 // get an object for the given number of years
1511 static wxDateSpan Years(int years) { return wxDateSpan(years, 0, 0, 0); }
68ee7c47 1512 static wxDateSpan Year() { return Years(1); }
0979c962
VZ
1513
1514 // default copy ctor is ok
1515
1516 // no dtor
1517
1518 // accessors (all SetXXX() return the (modified) wxDateSpan object)
1519 // ------------------------------------------------------------------------
1520
1521 // set number of years
b76b015e 1522 wxDateSpan& SetYears(int n) { m_years = n; return *this; }
0979c962 1523 // set number of months
b76b015e 1524 wxDateSpan& SetMonths(int n) { m_months = n; return *this; }
0979c962 1525 // set number of weeks
b76b015e 1526 wxDateSpan& SetWeeks(int n) { m_weeks = n; return *this; }
0979c962 1527 // set number of days
b76b015e 1528 wxDateSpan& SetDays(int n) { m_days = n; return *this; }
0979c962
VZ
1529
1530 // get number of years
1531 int GetYears() const { return m_years; }
1532 // get number of months
1533 int GetMonths() const { return m_months; }
1534 // get number of weeks
1535 int GetWeeks() const { return m_weeks; }
1536 // get number of days
1537 int GetDays() const { return m_days; }
1538 // returns 7*GetWeeks() + GetDays()
1539 int GetTotalDays() const { return 7*m_weeks + m_days; }
1540
cd0b1709 1541 // arithmetics with date spans (see also below for more operators)
0979c962
VZ
1542 // ------------------------------------------------------------------------
1543
cd0b1709
VZ
1544 // return sum of two date spans
1545 inline wxDateSpan Add(const wxDateSpan& other) const;
0979c962
VZ
1546 // add another wxDateSpan to us
1547 inline wxDateSpan& Add(const wxDateSpan& other);
1548 // add another wxDateSpan to us
1549 inline wxDateSpan& operator+=(const wxDateSpan& other);
26364344
WS
1550 inline wxDateSpan operator+(const wxDateSpan& ds) const
1551 {
1552 return wxDateSpan(GetYears() + ds.GetYears(),
1553 GetMonths() + ds.GetMonths(),
1554 GetWeeks() + ds.GetWeeks(),
1555 GetDays() + ds.GetDays());
1556 }
0979c962 1557
cd0b1709 1558 // return difference of two date spans
f6bcfd97
BP
1559 inline wxDateSpan Subtract(const wxDateSpan& other) const;
1560 // subtract another wxDateSpan from us
1561 inline wxDateSpan& Subtract(const wxDateSpan& other);
1562 // subtract another wxDateSpan from us
0979c962 1563 inline wxDateSpan& operator-=(const wxDateSpan& other);
26364344
WS
1564 inline wxDateSpan operator-(const wxDateSpan& ds) const
1565 {
1566 return wxDateSpan(GetYears() - ds.GetYears(),
1567 GetMonths() - ds.GetMonths(),
1568 GetWeeks() - ds.GetWeeks(),
1569 GetDays() - ds.GetDays());
1570 }
0979c962
VZ
1571
1572 // return a copy of this time span with changed sign
1573 inline wxDateSpan Negate() const;
1574 // inverse the sign of this timespan
1575 inline wxDateSpan& Neg();
1576 // inverse the sign of this timespan
1577 wxDateSpan& operator-() { return Neg(); }
1578
cd0b1709
VZ
1579 // return the date span proportional to this one with given factor
1580 inline wxDateSpan Multiply(int factor) const;
0979c962 1581 // multiply all components by a (signed) number
cd0b1709
VZ
1582 inline wxDateSpan& Multiply(int factor);
1583 // multiply all components by a (signed) number
1584 inline wxDateSpan& operator*=(int factor) { return Multiply(factor); }
26364344
WS
1585 inline wxDateSpan operator*(int n) const
1586 {
1587 return wxDateSpan(*this).Multiply(n);
1588 }
1589
1590 // ds1 == d2 if and only if for every wxDateTime t t + ds1 == t + ds2
1591 inline bool operator==(const wxDateSpan& ds) const
1592 {
1593 return GetYears() == ds.GetYears() &&
1594 GetMonths() == ds.GetMonths() &&
1595 GetTotalDays() == ds.GetTotalDays();
1596 }
1597
1598 inline bool operator!=(const wxDateSpan& ds) const
1599 {
1600 return !(*this == ds);
1601 }
0979c962
VZ
1602
1603private:
1604 int m_years,
1605 m_months,
1606 m_weeks,
1607 m_days;
1608};
1609
4f6aed9c
VZ
1610// ----------------------------------------------------------------------------
1611// wxDateTimeArray: array of dates.
1612// ----------------------------------------------------------------------------
1613
bb24c68f 1614WX_DECLARE_USER_EXPORTED_OBJARRAY(wxDateTime, wxDateTimeArray, WXDLLIMPEXP_BASE);
4f6aed9c
VZ
1615
1616// ----------------------------------------------------------------------------
1617// wxDateTimeHolidayAuthority: an object of this class will decide whether a
1618// given date is a holiday and is used by all functions working with "work
1619// days".
1620//
1621// NB: the base class is an ABC, derived classes must implement the pure
1622// virtual methods to work with the holidays they correspond to.
1623// ----------------------------------------------------------------------------
1624
b5dbe15d 1625class WXDLLIMPEXP_FWD_BASE wxDateTimeHolidayAuthority;
d5d29b8a 1626WX_DEFINE_USER_EXPORTED_ARRAY_PTR(wxDateTimeHolidayAuthority *,
bb24c68f 1627 wxHolidayAuthoritiesArray,
fd497ede 1628 class WXDLLIMPEXP_BASE);
4f6aed9c 1629
f6081a04 1630class wxDateTimeHolidaysModule;
bddd7a8d 1631class WXDLLIMPEXP_BASE wxDateTimeHolidayAuthority
4f6aed9c 1632{
f6bcfd97 1633friend class wxDateTimeHolidaysModule;
4f6aed9c 1634public:
68379eaf 1635 // returns true if the given date is a holiday
4f6aed9c
VZ
1636 static bool IsHoliday(const wxDateTime& dt);
1637
1638 // fills the provided array with all holidays in the given range, returns
1639 // the number of them
1640 static size_t GetHolidaysInRange(const wxDateTime& dtStart,
1641 const wxDateTime& dtEnd,
1642 wxDateTimeArray& holidays);
1643
1644 // clear the list of holiday authorities
1645 static void ClearAllAuthorities();
1646
1647 // add a new holiday authority (the pointer will be deleted by
1648 // wxDateTimeHolidayAuthority)
1649 static void AddAuthority(wxDateTimeHolidayAuthority *auth);
1650
30e671a5 1651 // the base class must have a virtual dtor
5e233068 1652 virtual ~wxDateTimeHolidayAuthority();
30e671a5 1653
4f6aed9c
VZ
1654protected:
1655 // this function is called to determine whether a given day is a holiday
1656 virtual bool DoIsHoliday(const wxDateTime& dt) const = 0;
1657
1658 // this function should fill the array with all holidays between the two
1659 // given dates - it is implemented in the base class, but in a very
1660 // inefficient way (it just iterates over all days and uses IsHoliday() for
1661 // each of them), so it must be overridden in the derived class where the
1662 // base class version may be explicitly used if needed
1663 //
1664 // returns the number of holidays in the given range and fills holidays
1665 // array
1666 virtual size_t DoGetHolidaysInRange(const wxDateTime& dtStart,
1667 const wxDateTime& dtEnd,
1668 wxDateTimeArray& holidays) const = 0;
1669
1670private:
1671 // all holiday authorities
1672 static wxHolidayAuthoritiesArray ms_authorities;
1673};
1674
1675// the holidays for this class are all Saturdays and Sundays
bddd7a8d 1676class WXDLLIMPEXP_BASE wxDateTimeWorkDays : public wxDateTimeHolidayAuthority
4f6aed9c
VZ
1677{
1678protected:
1679 virtual bool DoIsHoliday(const wxDateTime& dt) const;
1680 virtual size_t DoGetHolidaysInRange(const wxDateTime& dtStart,
1681 const wxDateTime& dtEnd,
1682 wxDateTimeArray& holidays) const;
1683};
0979c962 1684
2f02cb89
VZ
1685// ============================================================================
1686// inline functions implementation
1687// ============================================================================
1688
df5168c4
MB
1689// ----------------------------------------------------------------------------
1690// private macros
1691// ----------------------------------------------------------------------------
1692
1693#define MILLISECONDS_PER_DAY 86400000l
1694
1695// some broken compilers (HP-UX CC) refuse to compile the "normal" version, but
1696// using a temp variable always might prevent other compilers from optimising
1697// it away - hence use of this ugly macro
1698#ifndef __HPUX__
1699 #define MODIFY_AND_RETURN(op) return wxDateTime(*this).op
1700#else
1701 #define MODIFY_AND_RETURN(op) wxDateTime dt(*this); dt.op; return dt
1702#endif
1703
1704// ----------------------------------------------------------------------------
1705// wxDateTime construction
1706// ----------------------------------------------------------------------------
1707
1708inline bool wxDateTime::IsInStdRange() const
1709{
57563c71
VZ
1710 // currently we don't know what is the real type of time_t so prefer to err
1711 // on the safe side and limit it to 32 bit values which is safe everywhere
1712 return m_time >= 0l && (m_time / TIME_T_FACTOR) < wxINT32_MAX;
df5168c4 1713}
2f02cb89 1714
df5168c4
MB
1715/* static */
1716inline wxDateTime wxDateTime::Now()
1717{
a452689b
SN
1718 struct tm tmstruct;
1719 return wxDateTime(*GetTmNow(&tmstruct));
df5168c4
MB
1720}
1721
1722/* static */
1723inline wxDateTime wxDateTime::Today()
1724{
cb1ef833
VZ
1725 wxDateTime dt(Now());
1726 dt.ResetTime();
df5168c4 1727
cb1ef833 1728 return dt;
df5168c4
MB
1729}
1730
1731#if (!(defined(__VISAGECPP__) && __IBMCPP__ >= 400))
1732inline wxDateTime& wxDateTime::Set(time_t timet)
1733{
1734 // assign first to avoid long multiplication overflow!
1735 m_time = timet - WX_TIME_BASE_OFFSET ;
1736 m_time *= TIME_T_FACTOR;
1737
1738 return *this;
1739}
2f02cb89
VZ
1740#endif
1741
df5168c4
MB
1742inline wxDateTime& wxDateTime::SetToCurrent()
1743{
1744 *this = Now();
1745 return *this;
1746}
1747
1748#if (!(defined(__VISAGECPP__) && __IBMCPP__ >= 400))
1749inline wxDateTime::wxDateTime(time_t timet)
1750{
1751 Set(timet);
1752}
dc84437e 1753#endif
2f02cb89 1754
df5168c4
MB
1755inline wxDateTime::wxDateTime(const struct tm& tm)
1756{
1757 Set(tm);
1758}
1759
1760inline wxDateTime::wxDateTime(const Tm& tm)
1761{
1762 Set(tm);
1763}
1764
1765inline wxDateTime::wxDateTime(double jdn)
1766{
1767 Set(jdn);
1768}
1769
1770inline wxDateTime& wxDateTime::Set(const Tm& tm)
1771{
9a83f860 1772 wxASSERT_MSG( tm.IsValid(), wxT("invalid broken down date/time") );
df5168c4 1773
271f6072
VZ
1774 return Set(tm.mday, (Month)tm.mon, tm.year,
1775 tm.hour, tm.min, tm.sec, tm.msec);
df5168c4
MB
1776}
1777
1778inline wxDateTime::wxDateTime(wxDateTime_t hour,
1779 wxDateTime_t minute,
1780 wxDateTime_t second,
1781 wxDateTime_t millisec)
1782{
1783 Set(hour, minute, second, millisec);
1784}
1785
1786inline wxDateTime::wxDateTime(wxDateTime_t day,
1787 Month month,
1788 int year,
1789 wxDateTime_t hour,
1790 wxDateTime_t minute,
1791 wxDateTime_t second,
1792 wxDateTime_t millisec)
1793{
1794 Set(day, month, year, hour, minute, second, millisec);
1795}
1796
1797// ----------------------------------------------------------------------------
1798// wxDateTime accessors
1799// ----------------------------------------------------------------------------
1800
1801inline wxLongLong wxDateTime::GetValue() const
1802{
9a83f860 1803 wxASSERT_MSG( IsValid(), wxT("invalid wxDateTime"));
df5168c4
MB
1804
1805 return m_time;
1806}
1807
1808inline time_t wxDateTime::GetTicks() const
1809{
9a83f860 1810 wxASSERT_MSG( IsValid(), wxT("invalid wxDateTime"));
df5168c4
MB
1811 if ( !IsInStdRange() )
1812 {
1813 return (time_t)-1;
1814 }
1815
d3c58c7e 1816 return (time_t)((m_time / (long)TIME_T_FACTOR).ToLong()) + WX_TIME_BASE_OFFSET;
df5168c4
MB
1817}
1818
1819inline bool wxDateTime::SetToLastWeekDay(WeekDay weekday,
1820 Month month,
1821 int year)
1822{
1823 return SetToWeekDay(weekday, -1, month, year);
1824}
1825
fc7a2a60
VZ
1826inline wxDateTime
1827wxDateTime::GetWeekDayInSameWeek(WeekDay weekday,
1828 WeekFlags WXUNUSED(flags)) const
df5168c4
MB
1829{
1830 MODIFY_AND_RETURN( SetToWeekDayInSameWeek(weekday) );
1831}
1832
1833inline wxDateTime wxDateTime::GetNextWeekDay(WeekDay weekday) const
1834{
1835 MODIFY_AND_RETURN( SetToNextWeekDay(weekday) );
1836}
1837
1838inline wxDateTime wxDateTime::GetPrevWeekDay(WeekDay weekday) const
1839{
1840 MODIFY_AND_RETURN( SetToPrevWeekDay(weekday) );
1841}
1842
1843inline wxDateTime wxDateTime::GetWeekDay(WeekDay weekday,
1844 int n,
1845 Month month,
1846 int year) const
1847{
1848 wxDateTime dt(*this);
1849
1850 return dt.SetToWeekDay(weekday, n, month, year) ? dt : wxInvalidDateTime;
1851}
1852
1853inline wxDateTime wxDateTime::GetLastWeekDay(WeekDay weekday,
1854 Month month,
1855 int year)
1856{
1857 wxDateTime dt(*this);
1858
1859 return dt.SetToLastWeekDay(weekday, month, year) ? dt : wxInvalidDateTime;
1860}
1861
df5168c4
MB
1862inline wxDateTime wxDateTime::GetLastMonthDay(Month month, int year) const
1863{
1864 MODIFY_AND_RETURN( SetToLastMonthDay(month, year) );
1865}
1866
1867inline wxDateTime wxDateTime::GetYearDay(wxDateTime_t yday) const
1868{
1869 MODIFY_AND_RETURN( SetToYearDay(yday) );
1870}
1871
1872// ----------------------------------------------------------------------------
1873// wxDateTime comparison
1874// ----------------------------------------------------------------------------
1875
1876inline bool wxDateTime::IsEqualTo(const wxDateTime& datetime) const
1877{
9a83f860 1878 wxASSERT_MSG( IsValid() && datetime.IsValid(), wxT("invalid wxDateTime"));
df5168c4
MB
1879
1880 return m_time == datetime.m_time;
1881}
1882
1883inline bool wxDateTime::IsEarlierThan(const wxDateTime& datetime) const
1884{
9a83f860 1885 wxASSERT_MSG( IsValid() && datetime.IsValid(), wxT("invalid wxDateTime"));
df5168c4
MB
1886
1887 return m_time < datetime.m_time;
1888}
1889
1890inline bool wxDateTime::IsLaterThan(const wxDateTime& datetime) const
1891{
9a83f860 1892 wxASSERT_MSG( IsValid() && datetime.IsValid(), wxT("invalid wxDateTime"));
df5168c4
MB
1893
1894 return m_time > datetime.m_time;
1895}
1896
1897inline bool wxDateTime::IsStrictlyBetween(const wxDateTime& t1,
1898 const wxDateTime& t2) const
1899{
1900 // no need for assert, will be checked by the functions we call
1901 return IsLaterThan(t1) && IsEarlierThan(t2);
1902}
1903
1904inline bool wxDateTime::IsBetween(const wxDateTime& t1,
1905 const wxDateTime& t2) const
1906{
1907 // no need for assert, will be checked by the functions we call
1908 return IsEqualTo(t1) || IsEqualTo(t2) || IsStrictlyBetween(t1, t2);
1909}
1910
1911inline bool wxDateTime::IsSameDate(const wxDateTime& dt) const
1912{
1913 Tm tm1 = GetTm(),
1914 tm2 = dt.GetTm();
1915
1916 return tm1.year == tm2.year &&
1917 tm1.mon == tm2.mon &&
1918 tm1.mday == tm2.mday;
1919}
1920
1921inline bool wxDateTime::IsSameTime(const wxDateTime& dt) const
1922{
1923 // notice that we can't do something like this:
1924 //
1925 // m_time % MILLISECONDS_PER_DAY == dt.m_time % MILLISECONDS_PER_DAY
1926 //
1927 // because we have also to deal with (possibly) different DST settings!
1928 Tm tm1 = GetTm(),
1929 tm2 = dt.GetTm();
1930
1931 return tm1.hour == tm2.hour &&
1932 tm1.min == tm2.min &&
1933 tm1.sec == tm2.sec &&
1934 tm1.msec == tm2.msec;
1935}
1936
1937inline bool wxDateTime::IsEqualUpTo(const wxDateTime& dt,
1938 const wxTimeSpan& ts) const
1939{
1940 return IsBetween(dt.Subtract(ts), dt.Add(ts));
1941}
1942
1943// ----------------------------------------------------------------------------
1944// wxDateTime arithmetics
1945// ----------------------------------------------------------------------------
1946
1947inline wxDateTime wxDateTime::Add(const wxTimeSpan& diff) const
1948{
9a83f860 1949 wxASSERT_MSG( IsValid(), wxT("invalid wxDateTime"));
df5168c4
MB
1950
1951 return wxDateTime(m_time + diff.GetValue());
1952}
1953
1954inline wxDateTime& wxDateTime::Add(const wxTimeSpan& diff)
1955{
9a83f860 1956 wxASSERT_MSG( IsValid(), wxT("invalid wxDateTime"));
df5168c4
MB
1957
1958 m_time += diff.GetValue();
1959
1960 return *this;
1961}
1962
1963inline wxDateTime& wxDateTime::operator+=(const wxTimeSpan& diff)
1964{
1965 return Add(diff);
1966}
1967
1968inline wxDateTime wxDateTime::Subtract(const wxTimeSpan& diff) const
1969{
9a83f860 1970 wxASSERT_MSG( IsValid(), wxT("invalid wxDateTime"));
df5168c4
MB
1971
1972 return wxDateTime(m_time - diff.GetValue());
1973}
1974
1975inline wxDateTime& wxDateTime::Subtract(const wxTimeSpan& diff)
1976{
9a83f860 1977 wxASSERT_MSG( IsValid(), wxT("invalid wxDateTime"));
df5168c4
MB
1978
1979 m_time -= diff.GetValue();
1980
1981 return *this;
1982}
1983
1984inline wxDateTime& wxDateTime::operator-=(const wxTimeSpan& diff)
1985{
1986 return Subtract(diff);
1987}
1988
1989inline wxTimeSpan wxDateTime::Subtract(const wxDateTime& datetime) const
1990{
9a83f860 1991 wxASSERT_MSG( IsValid() && datetime.IsValid(), wxT("invalid wxDateTime"));
df5168c4
MB
1992
1993 return wxTimeSpan(GetValue() - datetime.GetValue());
1994}
1995
26364344
WS
1996inline wxTimeSpan wxDateTime::operator-(const wxDateTime& dt2) const
1997{
1998 return this->Subtract(dt2);
1999}
2000
df5168c4
MB
2001inline wxDateTime wxDateTime::Add(const wxDateSpan& diff) const
2002{
2003 return wxDateTime(*this).Add(diff);
2004}
2005
2006inline wxDateTime& wxDateTime::Subtract(const wxDateSpan& diff)
2007{
2008 return Add(diff.Negate());
2009}
2010
2011inline wxDateTime wxDateTime::Subtract(const wxDateSpan& diff) const
2012{
2013 return wxDateTime(*this).Subtract(diff);
2014}
2015
2016inline wxDateTime& wxDateTime::operator-=(const wxDateSpan& diff)
2017{
2018 return Subtract(diff);
2019}
2020
2021inline wxDateTime& wxDateTime::operator+=(const wxDateSpan& diff)
2022{
2023 return Add(diff);
2024}
2025
2026// ----------------------------------------------------------------------------
2027// wxDateTime and timezones
2028// ----------------------------------------------------------------------------
2029
d26adb9d
VZ
2030inline wxDateTime
2031wxDateTime::ToTimezone(const wxDateTime::TimeZone& tz, bool noDST) const
df5168c4
MB
2032{
2033 MODIFY_AND_RETURN( MakeTimezone(tz, noDST) );
2034}
2035
d26adb9d
VZ
2036inline wxDateTime
2037wxDateTime::FromTimezone(const wxDateTime::TimeZone& tz, bool noDST) const
2038{
2039 MODIFY_AND_RETURN( MakeFromTimezone(tz, noDST) );
2040}
2041
df5168c4
MB
2042// ----------------------------------------------------------------------------
2043// wxTimeSpan construction
2044// ----------------------------------------------------------------------------
2045
2046inline wxTimeSpan::wxTimeSpan(long hours,
2047 long minutes,
9c21e80b
VZ
2048 wxLongLong seconds,
2049 wxLongLong milliseconds)
df5168c4
MB
2050{
2051 // assign first to avoid precision loss
2052 m_diff = hours;
2053 m_diff *= 60l;
2054 m_diff += minutes;
2055 m_diff *= 60l;
2056 m_diff += seconds;
2057 m_diff *= 1000l;
2058 m_diff += milliseconds;
2059}
2060
2061// ----------------------------------------------------------------------------
2062// wxTimeSpan accessors
2063// ----------------------------------------------------------------------------
2064
2065inline wxLongLong wxTimeSpan::GetSeconds() const
2066{
2067 return m_diff / 1000l;
2068}
2069
2070inline int wxTimeSpan::GetMinutes() const
2071{
18c7af7e
VZ
2072 // explicit cast to int suppresses a warning with CodeWarrior and possibly
2073 // others (changing the return type to long from int is impossible in 2.8)
2074 return (int)((GetSeconds() / 60l).GetLo());
df5168c4
MB
2075}
2076
2077inline int wxTimeSpan::GetHours() const
2078{
2079 return GetMinutes() / 60;
2080}
2081
2082inline int wxTimeSpan::GetDays() const
2083{
2084 return GetHours() / 24;
2085}
2086
2087inline int wxTimeSpan::GetWeeks() const
2088{
2089 return GetDays() / 7;
2090}
2091
2092// ----------------------------------------------------------------------------
2093// wxTimeSpan arithmetics
2094// ----------------------------------------------------------------------------
2095
2096inline wxTimeSpan wxTimeSpan::Add(const wxTimeSpan& diff) const
2097{
2098 return wxTimeSpan(m_diff + diff.GetValue());
2099}
2100
2101inline wxTimeSpan& wxTimeSpan::Add(const wxTimeSpan& diff)
2102{
2103 m_diff += diff.GetValue();
2104
2105 return *this;
2106}
2107
2108inline wxTimeSpan wxTimeSpan::Subtract(const wxTimeSpan& diff) const
2109{
2110 return wxTimeSpan(m_diff - diff.GetValue());
2111}
2112
2113inline wxTimeSpan& wxTimeSpan::Subtract(const wxTimeSpan& diff)
2114{
2115 m_diff -= diff.GetValue();
2116
2117 return *this;
2118}
2119
2120inline wxTimeSpan& wxTimeSpan::Multiply(int n)
2121{
2122 m_diff *= (long)n;
2123
2124 return *this;
2125}
2126
2127inline wxTimeSpan wxTimeSpan::Multiply(int n) const
2128{
2129 return wxTimeSpan(m_diff * (long)n);
2130}
2131
2132inline wxTimeSpan wxTimeSpan::Abs() const
2133{
2134 return wxTimeSpan(GetValue().Abs());
2135}
2136
2137inline bool wxTimeSpan::IsEqualTo(const wxTimeSpan& ts) const
2138{
2139 return GetValue() == ts.GetValue();
2140}
2141
2142inline bool wxTimeSpan::IsLongerThan(const wxTimeSpan& ts) const
2143{
2144 return GetValue().Abs() > ts.GetValue().Abs();
f7541d48
VZ
2145}
2146
2147inline bool wxTimeSpan::IsShorterThan(const wxTimeSpan& ts) const
2148{
2149 return GetValue().Abs() < ts.GetValue().Abs();
df5168c4
MB
2150}
2151
2152// ----------------------------------------------------------------------------
2153// wxDateSpan
2154// ----------------------------------------------------------------------------
2155
2156inline wxDateSpan& wxDateSpan::operator+=(const wxDateSpan& other)
2157{
2158 m_years += other.m_years;
2159 m_months += other.m_months;
2160 m_weeks += other.m_weeks;
2161 m_days += other.m_days;
2162
2163 return *this;
2164}
2165
2166inline wxDateSpan& wxDateSpan::Add(const wxDateSpan& other)
2167{
2168 return *this += other;
2169}
2170
2171inline wxDateSpan wxDateSpan::Add(const wxDateSpan& other) const
2172{
2173 wxDateSpan ds(*this);
2174 ds.Add(other);
2175 return ds;
2176}
2177
2178inline wxDateSpan& wxDateSpan::Multiply(int factor)
2179{
2180 m_years *= factor;
2181 m_months *= factor;
2182 m_weeks *= factor;
2183 m_days *= factor;
2184
2185 return *this;
2186}
2187
2188inline wxDateSpan wxDateSpan::Multiply(int factor) const
2189{
2190 wxDateSpan ds(*this);
2191 ds.Multiply(factor);
2192 return ds;
2193}
2194
2195inline wxDateSpan wxDateSpan::Negate() const
2196{
2197 return wxDateSpan(-m_years, -m_months, -m_weeks, -m_days);
2198}
2199
2200inline wxDateSpan& wxDateSpan::Neg()
2201{
2202 m_years = -m_years;
2203 m_months = -m_months;
2204 m_weeks = -m_weeks;
2205 m_days = -m_days;
2206
2207 return *this;
2208}
2209
2210inline wxDateSpan& wxDateSpan::operator-=(const wxDateSpan& other)
2211{
2212 return *this += other.Negate();
2213}
2214
2215inline wxDateSpan& wxDateSpan::Subtract(const wxDateSpan& other)
2216{
2217 return *this -= other;
2218}
2219
2220inline wxDateSpan wxDateSpan::Subtract(const wxDateSpan& other) const
2221{
2222 wxDateSpan ds(*this);
2223 ds.Subtract(other);
2224 return ds;
2225}
2226
2227#undef MILLISECONDS_PER_DAY
2228
2229#undef MODIFY_AND_RETURN
2230
0979c962
VZ
2231// ============================================================================
2232// binary operators
2233// ============================================================================
2234
0979c962
VZ
2235// ----------------------------------------------------------------------------
2236// wxTimeSpan operators
2237// ----------------------------------------------------------------------------
2238
26364344 2239wxTimeSpan WXDLLIMPEXP_BASE operator*(int n, const wxTimeSpan& ts);
0979c962
VZ
2240
2241// ----------------------------------------------------------------------------
2242// wxDateSpan
2243// ----------------------------------------------------------------------------
2244
26364344 2245wxDateSpan WXDLLIMPEXP_BASE operator*(int n, const wxDateSpan& ds);
cd0b1709
VZ
2246
2247// ============================================================================
2248// other helper functions
2249// ============================================================================
2250
2251// ----------------------------------------------------------------------------
2252// iteration helpers: can be used to write a for loop over enum variable like
2253// this:
2254// for ( m = wxDateTime::Jan; m < wxDateTime::Inv_Month; wxNextMonth(m) )
2255// ----------------------------------------------------------------------------
2256
26364344
WS
2257WXDLLIMPEXP_BASE void wxNextMonth(wxDateTime::Month& m);
2258WXDLLIMPEXP_BASE void wxPrevMonth(wxDateTime::Month& m);
2259WXDLLIMPEXP_BASE void wxNextWDay(wxDateTime::WeekDay& wd);
2260WXDLLIMPEXP_BASE void wxPrevWDay(wxDateTime::WeekDay& wd);
0979c962 2261
e421922f
VZ
2262#endif // wxUSE_DATETIME
2263
2f02cb89 2264#endif // _WX_DATETIME_H