]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/_datetime.i
Version
[wxWidgets.git] / wxPython / src / _datetime.i
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: _datetime.i
3 // Purpose: SWIG interface for wxDateTime and etc.
4 //
5 // Author: Robin Dunn
6 //
7 // Created: 25-Nov-1998
8 // RCS-ID: $Id$
9 // Copyright: (c) 2003 by Total Control Software
10 // Licence: wxWindows license
11 /////////////////////////////////////////////////////////////////////////////
12
13 // Not a %module
14
15
16 //---------------------------------------------------------------------------
17 %newgroup
18
19 %{
20 #include <wx/datetime.h>
21 %}
22
23 MAKE_CONST_WXSTRING(DefaultDateTimeFormat);
24 MAKE_CONST_WXSTRING(DefaultTimeSpanFormat);
25
26 //---------------------------------------------------------------------------
27
28
29 %typemap(in) wxDateTime::TimeZone& (bool temp=false) {
30 $1 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong($input));
31 temp = true;
32 }
33 %typemap(python,freearg) wxDateTime::TimeZone& {
34 if (temp$argnum) delete $1;
35 }
36
37
38 %{
39 #define LOCAL_TZ wxDateTime::Local
40 %}
41
42
43 // Convert a wxLongLong to a Python Long by getting the hi/lo dwords, then
44 // shifting and oring them together
45 %typemap(python, out) wxLongLong {
46 PyObject *hi, *lo, *shifter, *shifted;
47 hi = PyLong_FromLong( $1.GetHi() );
48 lo = PyLong_FromLong( $1.GetLo() );
49 shifter = PyLong_FromLong(32);
50 shifted = PyNumber_Lshift(hi, shifter);
51 $result = PyNumber_Or(shifted, lo);
52 Py_DECREF(hi);
53 Py_DECREF(lo);
54 Py_DECREF(shifter);
55 Py_DECREF(shifted);
56 }
57
58
59 //---------------------------------------------------------------------------
60
61 //typedef unsigned short wxDateTime_t;
62 #define wxDateTime_t int
63
64 // wxDateTime represents an absolute moment in the time
65 class wxDateTime {
66 public:
67
68 enum TZ
69 {
70 // the time in the current time zone
71 Local,
72
73 // zones from GMT (= Greenwhich Mean Time): they're guaranteed to be
74 // consequent numbers, so writing something like `GMT0 + offset' is
75 // safe if abs(offset) <= 12
76 // underscore stands for minus
77 GMT_12, GMT_11, GMT_10, GMT_9, GMT_8, GMT_7,
78 GMT_6, GMT_5, GMT_4, GMT_3, GMT_2, GMT_1,
79 GMT0,
80 GMT1, GMT2, GMT3, GMT4, GMT5, GMT6,
81 GMT7, GMT8, GMT9, GMT10, GMT11, GMT12,
82
83 // Europe
84 WET = GMT0, // Western Europe Time
85 WEST = GMT1, // Western Europe Summer Time
86 CET = GMT1, // Central Europe Time
87 CEST = GMT2, // Central Europe Summer Time
88 EET = GMT2, // Eastern Europe Time
89 EEST = GMT3, // Eastern Europe Summer Time
90 MSK = GMT3, // Moscow Time
91 MSD = GMT4, // Moscow Summer Time
92
93 // US and Canada
94 AST = GMT_4, // Atlantic Standard Time
95 ADT = GMT_3, // Atlantic Daylight Time
96 EST = GMT_5, // Eastern Standard Time
97 EDT = GMT_4, // Eastern Daylight Saving Time
98 CST = GMT_6, // Central Standard Time
99 CDT = GMT_5, // Central Daylight Saving Time
100 MST = GMT_7, // Mountain Standard Time
101 MDT = GMT_6, // Mountain Daylight Saving Time
102 PST = GMT_8, // Pacific Standard Time
103 PDT = GMT_7, // Pacific Daylight Saving Time
104 HST = GMT_10, // Hawaiian Standard Time
105 AKST = GMT_9, // Alaska Standard Time
106 AKDT = GMT_8, // Alaska Daylight Saving Time
107
108 // Australia
109
110 A_WST = GMT8, // Western Standard Time
111 A_CST = GMT12 + 1, // Central Standard Time (+9.5)
112 A_EST = GMT10, // Eastern Standard Time
113 A_ESST = GMT11, // Eastern Summer Time
114
115 // Universal Coordinated Time = the new and politically correct name
116 // for GMT
117 UTC = GMT0
118 };
119
120
121 // the calendar systems we know about: notice that it's valid (for
122 // this classes purpose anyhow) to work with any of these calendars
123 // even with the dates before the historical appearance of the
124 // calendar
125 enum Calendar
126 {
127 Gregorian, // current calendar
128 Julian // calendar in use since -45 until the 1582 (or later)
129 };
130
131 // these values only are used to identify the different dates of
132 // adoption of the Gregorian calendar (see IsGregorian())
133 //
134 // All data and comments taken verbatim from "The Calendar FAQ (v 2.0)"
135 // by Claus Tøndering, http://www.pip.dknet.dk/~c-t/calendar.html
136 // except for the comments "we take".
137 //
138 // Symbol "->" should be read as "was followed by" in the comments
139 // which follow.
140 enum GregorianAdoption
141 {
142 Gr_Unknown, // no data for this country or it's too uncertain to use
143 Gr_Standard, // on the day 0 of Gregorian calendar: 15 Oct 1582
144
145 Gr_Alaska, // Oct 1867 when Alaska became part of the USA
146 Gr_Albania, // Dec 1912
147
148 Gr_Austria = Gr_Unknown, // Different regions on different dates
149 Gr_Austria_Brixen, // 5 Oct 1583 -> 16 Oct 1583
150 Gr_Austria_Salzburg = Gr_Austria_Brixen,
151 Gr_Austria_Tyrol = Gr_Austria_Brixen,
152 Gr_Austria_Carinthia, // 14 Dec 1583 -> 25 Dec 1583
153 Gr_Austria_Styria = Gr_Austria_Carinthia,
154
155 Gr_Belgium, // Then part of the Netherlands
156
157 Gr_Bulgaria = Gr_Unknown, // Unknown precisely (from 1915 to 1920)
158 Gr_Bulgaria_1, // 18 Mar 1916 -> 1 Apr 1916
159 Gr_Bulgaria_2, // 31 Mar 1916 -> 14 Apr 1916
160 Gr_Bulgaria_3, // 3 Sep 1920 -> 17 Sep 1920
161
162 Gr_Canada = Gr_Unknown, // Different regions followed the changes in
163 // Great Britain or France
164
165 Gr_China = Gr_Unknown, // Different authorities say:
166 Gr_China_1, // 18 Dec 1911 -> 1 Jan 1912
167 Gr_China_2, // 18 Dec 1928 -> 1 Jan 1929
168
169 Gr_Czechoslovakia, // (Bohemia and Moravia) 6 Jan 1584 -> 17 Jan 1584
170 Gr_Denmark, // (including Norway) 18 Feb 1700 -> 1 Mar 1700
171 Gr_Egypt, // 1875
172 Gr_Estonia, // 1918
173 Gr_Finland, // Then part of Sweden
174
175 Gr_France, // 9 Dec 1582 -> 20 Dec 1582
176 Gr_France_Alsace, // 4 Feb 1682 -> 16 Feb 1682
177 Gr_France_Lorraine, // 16 Feb 1760 -> 28 Feb 1760
178 Gr_France_Strasbourg, // February 1682
179
180 Gr_Germany = Gr_Unknown, // Different states on different dates:
181 Gr_Germany_Catholic, // 1583-1585 (we take 1584)
182 Gr_Germany_Prussia, // 22 Aug 1610 -> 2 Sep 1610
183 Gr_Germany_Protestant, // 18 Feb 1700 -> 1 Mar 1700
184
185 Gr_GreatBritain, // 2 Sep 1752 -> 14 Sep 1752 (use 'cal(1)')
186
187 Gr_Greece, // 9 Mar 1924 -> 23 Mar 1924
188 Gr_Hungary, // 21 Oct 1587 -> 1 Nov 1587
189 Gr_Ireland = Gr_GreatBritain,
190 Gr_Italy = Gr_Standard,
191
192 Gr_Japan = Gr_Unknown, // Different authorities say:
193 Gr_Japan_1, // 19 Dec 1872 -> 1 Jan 1873
194 Gr_Japan_2, // 19 Dec 1892 -> 1 Jan 1893
195 Gr_Japan_3, // 18 Dec 1918 -> 1 Jan 1919
196
197 Gr_Latvia, // 1915-1918 (we take 1915)
198 Gr_Lithuania, // 1915
199 Gr_Luxemburg, // 14 Dec 1582 -> 25 Dec 1582
200 Gr_Netherlands = Gr_Belgium, // (including Belgium) 1 Jan 1583
201
202 // this is too weird to take into account: the Gregorian calendar was
203 // introduced twice in Groningen, first time 28 Feb 1583 was followed
204 // by 11 Mar 1583, then it has gone back to Julian in the summer of
205 // 1584 and then 13 Dec 1700 -> 12 Jan 1701 - which is
206 // the date we take here
207 Gr_Netherlands_Groningen, // 13 Dec 1700 -> 12 Jan 1701
208 Gr_Netherlands_Gelderland, // 30 Jun 1700 -> 12 Jul 1700
209 Gr_Netherlands_Utrecht, // (and Overijssel) 30 Nov 1700->12 Dec 1700
210 Gr_Netherlands_Friesland, // (and Drenthe) 31 Dec 1700 -> 12 Jan 1701
211
212 Gr_Norway = Gr_Denmark, // Then part of Denmark
213 Gr_Poland = Gr_Standard,
214 Gr_Portugal = Gr_Standard,
215 Gr_Romania, // 31 Mar 1919 -> 14 Apr 1919
216 Gr_Russia, // 31 Jan 1918 -> 14 Feb 1918
217 Gr_Scotland = Gr_GreatBritain,
218 Gr_Spain = Gr_Standard,
219
220 // Sweden has a curious history. Sweden decided to make a gradual
221 // change from the Julian to the Gregorian calendar. By dropping every
222 // leap year from 1700 through 1740 the eleven superfluous days would
223 // be omitted and from 1 Mar 1740 they would be in sync with the
224 // Gregorian calendar. (But in the meantime they would be in sync with
225 // nobody!)
226 //
227 // So 1700 (which should have been a leap year in the Julian calendar)
228 // was not a leap year in Sweden. However, by mistake 1704 and 1708
229 // became leap years. This left Sweden out of synchronisation with
230 // both the Julian and the Gregorian world, so they decided to go back
231 // to the Julian calendar. In order to do this, they inserted an extra
232 // day in 1712, making that year a double leap year! So in 1712,
233 // February had 30 days in Sweden.
234 //
235 // Later, in 1753, Sweden changed to the Gregorian calendar by
236 // dropping 11 days like everyone else.
237 Gr_Sweden = Gr_Finland, // 17 Feb 1753 -> 1 Mar 1753
238
239 Gr_Switzerland = Gr_Unknown,// Different cantons used different dates
240 Gr_Switzerland_Catholic, // 1583, 1584 or 1597 (we take 1584)
241 Gr_Switzerland_Protestant, // 31 Dec 1700 -> 12 Jan 1701
242
243 Gr_Turkey, // 1 Jan 1927
244 Gr_USA = Gr_GreatBritain,
245 Gr_Wales = Gr_GreatBritain,
246 Gr_Yugoslavia // 1919
247 };
248
249
250
251 // the country parameter is used so far for calculating the start and
252 // the end of DST period and for deciding whether the date is a work
253 // day or not
254 enum Country
255 {
256 Country_Unknown, // no special information for this country
257 Country_Default, // set the default country with SetCountry() method
258 // or use the default country with any other
259
260 // Western European countries: we assume that they all follow the same
261 // DST rules (True or False?)
262 Country_WesternEurope_Start,
263 Country_EEC = Country_WesternEurope_Start,
264 France,
265 Germany,
266 UK,
267 Country_WesternEurope_End = UK,
268
269 Russia,
270
271 USA
272 };
273
274 // symbolic names for the months
275 enum Month
276 {
277 Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec, Inv_Month
278 };
279
280 // symbolic names for the weekdays
281 enum WeekDay
282 {
283 Sun, Mon, Tue, Wed, Thu, Fri, Sat, Inv_WeekDay
284 };
285
286 // invalid value for the year
287 enum Year
288 {
289 Inv_Year = SHRT_MIN // should hold in wxDateTime_t
290 };
291
292 // flags for GetWeekDayName and GetMonthName
293 enum NameFlags
294 {
295 Name_Full = 0x01, // return full name
296 Name_Abbr = 0x02 // return abbreviated name
297 };
298
299 // flags for GetWeekOfYear and GetWeekOfMonth
300 enum WeekFlags
301 {
302 Default_First, // Sunday_First for US, Monday_First for the rest
303 Monday_First, // week starts with a Monday
304 Sunday_First // week starts with a Sunday
305 };
306
307
308 //** Nested class TimeZone is handled by a typemap instead
309
310 //** Is nested class Tm needed?
311
312
313 // static methods
314 // ------------------------------------------------------------------------
315
316 // set the current country
317 static void SetCountry(Country country);
318
319 // get the current country
320 static Country GetCountry();
321
322 // return True if the country is a West European one (in practice,
323 // this means that the same DST rules as for EEC apply)
324 static bool IsWestEuropeanCountry(Country country = Country_Default);
325
326 // return the current year
327 static int GetCurrentYear(Calendar cal = Gregorian);
328
329 // convert the year as returned by wxDateTime::GetYear() to a year
330 // suitable for BC/AD notation. The difference is that BC year 1
331 // corresponds to the year 0 (while BC year 0 didn't exist) and AD
332 // year N is just year N.
333 static int ConvertYearToBC(int year);
334
335 // return the current month
336 static Month GetCurrentMonth(Calendar cal = Gregorian);
337
338 // returns True if the given year is a leap year in the given calendar
339 static bool IsLeapYear(int year = Inv_Year, Calendar cal = Gregorian);
340
341 // get the century (19 for 1999, 20 for 2000 and -5 for 492 BC)
342 static int GetCentury(int year = Inv_Year);
343
344 // returns the number of days in this year (356 or 355 for Gregorian
345 // calendar usually :-)
346 %Rename(GetNumberOfDaysinYear,
347 static wxDateTime_t, GetNumberOfDays(int year, Calendar cal = Gregorian));
348
349 // get the number of the days in the given month (default value for
350 // the year means the current one)
351 %Rename(GetNumberOfDaysInMonth,
352 static wxDateTime_t, GetNumberOfDays(Month month,
353 int year = Inv_Year,
354 Calendar cal = Gregorian));
355
356 // get the full (default) or abbreviated month name in the current
357 // locale, returns empty string on error
358 static wxString GetMonthName(Month month,
359 NameFlags flags = Name_Full);
360
361 // get the full (default) or abbreviated weekday name in the current
362 // locale, returns empty string on error
363 static wxString GetWeekDayName(WeekDay weekday,
364 NameFlags flags = Name_Full);
365
366 DocDeclAStr(
367 static void, GetAmPmStrings(wxString *OUTPUT, wxString *OUTPUT),
368 "GetAmPmStrings() -> (am, pm)",
369 "Get the AM and PM strings in the current locale (may be empty)", "");
370
371 // return True if the given country uses DST for this year
372 static bool IsDSTApplicable(int year = Inv_Year,
373 Country country = Country_Default);
374
375 // get the beginning of DST for this year, will return invalid object
376 // if no DST applicable in this year. The default value of the
377 // parameter means to take the current year.
378 static wxDateTime GetBeginDST(int year = Inv_Year,
379 Country country = Country_Default);
380 // get the end of DST for this year, will return invalid object
381 // if no DST applicable in this year. The default value of the
382 // parameter means to take the current year.
383 static wxDateTime GetEndDST(int year = Inv_Year,
384 Country country = Country_Default);
385
386 // return the wxDateTime object for the current time
387 static inline wxDateTime Now();
388
389 // return the wxDateTime object for the current time with millisecond
390 // precision (if available on this platform)
391 static wxDateTime UNow();
392
393 // return the wxDateTime object for today midnight: i.e. as Now() but
394 // with time set to 0
395 static inline wxDateTime Today();
396
397
398
399 // ------------------------------------------------------------------------
400 // constructors
401
402 wxDateTime();
403 %RenameCtor(DateTimeFromTimeT, wxDateTime(time_t timet));
404 %RenameCtor(DateTimeFromJDN, wxDateTime(double jdn));
405 %RenameCtor(DateTimeFromHMS, wxDateTime(wxDateTime_t hour,
406 wxDateTime_t minute = 0,
407 wxDateTime_t second = 0,
408 wxDateTime_t millisec = 0));
409 %RenameCtor(DateTimeFromDMY, wxDateTime(wxDateTime_t day,
410 Month month = Inv_Month,
411 int year = Inv_Year,
412 wxDateTime_t hour = 0,
413 wxDateTime_t minute = 0,
414 wxDateTime_t second = 0,
415 wxDateTime_t millisec = 0));
416
417 ~wxDateTime();
418
419 // ------------------------------------------------------------------------
420 // Set methods
421
422 wxDateTime& SetToCurrent();
423
424 // set to given time_t value
425 %Rename(SetTimeT, wxDateTime&, Set(time_t timet));
426
427 // set to given JDN (beware of rounding errors)
428 %Rename(SetJDN, wxDateTime&, Set(double jdn));
429
430 // set to given time, date = today
431 %Rename(SetHMS, wxDateTime&, Set(wxDateTime_t hour,
432 wxDateTime_t minute = 0,
433 wxDateTime_t second = 0,
434 wxDateTime_t millisec = 0));
435
436 // from separate values for each component with explicit date
437 // (defaults for month and year are the current values)
438 wxDateTime& Set(wxDateTime_t day,
439 Month month = Inv_Month,
440 int year = Inv_Year, // 1999, not 99 please!
441 wxDateTime_t hour = 0,
442 wxDateTime_t minute = 0,
443 wxDateTime_t second = 0,
444 wxDateTime_t millisec = 0);
445
446 // resets time to 00:00:00, doesn't change the date
447 wxDateTime& ResetTime();
448
449 // the following functions don't change the values of the other
450 // fields, i.e. SetMinute() won't change either hour or seconds value
451
452 // set the year
453 wxDateTime& SetYear(int year);
454 // set the month
455 wxDateTime& SetMonth(Month month);
456 // set the day of the month
457 wxDateTime& SetDay(wxDateTime_t day);
458 // set hour
459 wxDateTime& SetHour(wxDateTime_t hour);
460 // set minute
461 wxDateTime& SetMinute(wxDateTime_t minute);
462 // set second
463 wxDateTime& SetSecond(wxDateTime_t second);
464 // set millisecond
465 wxDateTime& SetMillisecond(wxDateTime_t millisecond);
466
467
468 // ------------------------------------------------------------------------
469 // calendar calculations
470
471 // set to the given week day in the same week as this one
472 wxDateTime& SetToWeekDayInSameWeek(WeekDay weekday, WeekFlags flags = Monday_First);
473 wxDateTime GetWeekDayInSameWeek(WeekDay weekday, WeekFlags flags = Monday_First);
474
475 // set to the next week day following this one
476 wxDateTime& SetToNextWeekDay(WeekDay weekday);
477 wxDateTime GetNextWeekDay(WeekDay weekday);
478
479 // set to the previous week day before this one
480 wxDateTime& SetToPrevWeekDay(WeekDay weekday);
481 wxDateTime GetPrevWeekDay(WeekDay weekday);
482
483 // set to Nth occurence of given weekday in the given month of the
484 // given year (time is set to 0), return True on success and False on
485 // failure. n may be positive (1..5) or negative to count from the end
486 // of the month (see helper function SetToLastWeekDay())
487 bool SetToWeekDay(WeekDay weekday,
488 int n = 1,
489 Month month = Inv_Month,
490 int year = Inv_Year);
491 // wxDateTime GetWeekDay(WeekDay weekday,
492 // int n = 1,
493 // Month month = Inv_Month,
494 // int year = Inv_Year);
495
496 // sets to the last weekday in the given month, year
497 bool SetToLastWeekDay(WeekDay weekday,
498 Month month = Inv_Month,
499 int year = Inv_Year);
500 wxDateTime GetLastWeekDay(WeekDay weekday,
501 Month month = Inv_Month,
502 int year = Inv_Year);
503
504 // sets the date to the given day of the given week in the year,
505 // returns True on success and False if given date doesn't exist (e.g.
506 // numWeek is > 53)
507 bool SetToTheWeek(wxDateTime_t numWeek, WeekDay weekday = Mon, WeekFlags flags = Monday_First);
508 wxDateTime GetWeek(wxDateTime_t numWeek, WeekDay weekday = Mon, WeekFlags flags = Monday_First);
509
510 %pythoncode {
511 SetToTheWeek = wx._deprecated(SetToTheWeek, "SetToTheWeek is deprecated, use (static) SetToWeekOfYear instead")
512 GetWeek = wx._deprecated(GetWeek, "GetWeek is deprecated, use GetWeekOfYear instead")
513 }
514
515 // returns the date corresponding to the given week day of the given
516 // week (in ISO notation) of the specified year
517 static wxDateTime SetToWeekOfYear(int year,
518 wxDateTime_t numWeek,
519 WeekDay weekday = Mon);
520
521 // sets the date to the last day of the given (or current) month or the
522 // given (or current) year
523 wxDateTime& SetToLastMonthDay(Month month = Inv_Month,
524 int year = Inv_Year);
525 wxDateTime GetLastMonthDay(Month month = Inv_Month,
526 int year = Inv_Year);
527
528 // sets to the given year day (1..365 or 366)
529 wxDateTime& SetToYearDay(wxDateTime_t yday);
530 wxDateTime GetYearDay(wxDateTime_t yday);
531
532 // The definitions below were taken verbatim from
533 //
534 // http://www.capecod.net/~pbaum/date/date0.htm
535 //
536 // (Peter Baum's home page)
537 //
538 // definition: The Julian Day Number, Julian Day, or JD of a
539 // particular instant of time is the number of days and fractions of a
540 // day since 12 hours Universal Time (Greenwich mean noon) on January
541 // 1 of the year -4712, where the year is given in the Julian
542 // proleptic calendar. The idea of using this reference date was
543 // originally proposed by Joseph Scalizer in 1582 to count years but
544 // it was modified by 19th century astronomers to count days. One
545 // could have equivalently defined the reference time to be noon of
546 // November 24, -4713 if were understood that Gregorian calendar rules
547 // were applied. Julian days are Julian Day Numbers and are not to be
548 // confused with Julian dates.
549 //
550 // definition: The Rata Die number is a date specified as the number
551 // of days relative to a base date of December 31 of the year 0. Thus
552 // January 1 of the year 1 is Rata Die day 1.
553
554 // get the Julian Day number (the fractional part specifies the time of
555 // the day, related to noon - beware of rounding errors!)
556 double GetJulianDayNumber();
557 double GetJDN();
558
559 // get the Modified Julian Day number: it is equal to JDN - 2400000.5
560 // and so integral MJDs correspond to the midnights (and not noons).
561 // MJD 0 is Nov 17, 1858
562 double GetModifiedJulianDayNumber() const { return GetJDN() - 2400000.5; }
563 double GetMJD();
564
565 // get the Rata Die number
566 double GetRataDie();
567
568
569 // ------------------------------------------------------------------------
570 // timezone stuff
571
572 // transform to any given timezone
573 wxDateTime ToTimezone(const wxDateTime::TimeZone& tz, bool noDST = false);
574 wxDateTime& MakeTimezone(const wxDateTime::TimeZone& tz, bool noDST = false);
575
576 // transform to GMT/UTC
577 wxDateTime ToGMT(bool noDST = false);
578 wxDateTime& MakeGMT(bool noDST = false);
579
580 // is daylight savings time in effect at this moment according to the
581 // rules of the specified country?
582 //
583 // Return value is > 0 if DST is in effect, 0 if it is not and -1 if
584 // the information is not available (this is compatible with ANSI C)
585 int IsDST(Country country = Country_Default);
586
587
588
589 // ------------------------------------------------------------------------
590 // accessors
591
592 // is the date valid (True even for non initialized objects)?
593 inline bool IsValid() const;
594 %pythoncode { Ok = IsValid }
595 %pythoncode { def __nonzero__(self): return self.Ok() };
596
597
598 // get the number of seconds since the Unix epoch - returns (time_t)-1
599 // if the value is out of range
600 inline time_t GetTicks() const;
601
602 // get the year (returns Inv_Year if date is invalid)
603 int GetYear(const wxDateTime::TimeZone& tz = LOCAL_TZ) const;
604
605 // get the month (Inv_Month if date is invalid)
606 Month GetMonth(const wxDateTime::TimeZone& tz = LOCAL_TZ) const;
607
608 // get the month day (in 1..31 range, 0 if date is invalid)
609 wxDateTime_t GetDay(const wxDateTime::TimeZone& tz = LOCAL_TZ) const;
610
611 // get the day of the week (Inv_WeekDay if date is invalid)
612 WeekDay GetWeekDay(const wxDateTime::TimeZone& tz = LOCAL_TZ) const;
613
614 // get the hour of the day
615 wxDateTime_t GetHour(const wxDateTime::TimeZone& tz = LOCAL_TZ) const;
616
617 // get the minute
618 wxDateTime_t GetMinute(const wxDateTime::TimeZone& tz = LOCAL_TZ) const;
619
620 // get the second
621 wxDateTime_t GetSecond(const wxDateTime::TimeZone& tz = LOCAL_TZ) const;
622
623 // get milliseconds
624 wxDateTime_t GetMillisecond(const wxDateTime::TimeZone& tz = LOCAL_TZ) const;
625
626
627 // get the day since the year start (1..366, 0 if date is invalid)
628 wxDateTime_t GetDayOfYear(const wxDateTime::TimeZone& tz = LOCAL_TZ) const;
629 // get the week number since the year start (1..52 or 53, 0 if date is
630 // invalid)
631 wxDateTime_t GetWeekOfYear(WeekFlags flags = Monday_First,
632 const wxDateTime::TimeZone& tz = LOCAL_TZ) const;
633 // get the week number since the month start (1..5, 0 if date is
634 // invalid)
635 wxDateTime_t GetWeekOfMonth(WeekFlags flags = Monday_First,
636 const wxDateTime::TimeZone& tz = LOCAL_TZ) const;
637
638 // is this date a work day? This depends on a country, of course,
639 // because the holidays are different in different countries
640 bool IsWorkDay(Country country = Country_Default) const;
641
642 // is this date later than Gregorian calendar introduction for the
643 // given country (see enum GregorianAdoption)?
644 //
645 // NB: this function shouldn't be considered as absolute authority in
646 // the matter. Besides, for some countries the exact date of
647 // adoption of the Gregorian calendar is simply unknown.
648 // bool IsGregorianDate(GregorianAdoption country = Gr_Standard) const;
649
650
651 // ------------------------------------------------------------------------
652 // comparison (see also functions below for operator versions)
653
654 // returns True if the two moments are strictly identical
655 inline bool IsEqualTo(const wxDateTime& datetime) const;
656
657 // returns True if the date is strictly earlier than the given one
658 inline bool IsEarlierThan(const wxDateTime& datetime) const;
659
660 // returns True if the date is strictly later than the given one
661 inline bool IsLaterThan(const wxDateTime& datetime) const;
662
663 // returns True if the date is strictly in the given range
664 inline bool IsStrictlyBetween(const wxDateTime& t1,
665 const wxDateTime& t2) const;
666
667 // returns True if the date is in the given range
668 inline bool IsBetween(const wxDateTime& t1, const wxDateTime& t2) const;
669
670 // do these two objects refer to the same date?
671 inline bool IsSameDate(const wxDateTime& dt) const;
672
673 // do these two objects have the same time?
674 inline bool IsSameTime(const wxDateTime& dt) const;
675
676 // are these two objects equal up to given timespan?
677 inline bool IsEqualUpTo(const wxDateTime& dt, const wxTimeSpan& ts) const;
678
679
680 // ------------------------------------------------------------------------
681 // arithmetics with dates (see also below for more operators)
682
683 // add a time span (positive or negative)
684 %Rename(AddTS, wxDateTime&, Add(const wxTimeSpan& diff));
685 // add a date span (positive or negative)
686 %Rename(AddDS, wxDateTime&, Add(const wxDateSpan& diff));
687
688 // subtract a time span (positive or negative)
689 %Rename(SubtractTS, wxDateTime&, Subtract(const wxTimeSpan& diff));
690
691 // subtract a date span (positive or negative)
692 %Rename(SubtractDS, wxDateTime&, Subtract(const wxDateSpan& diff));
693
694 // return the difference between two dates
695 wxTimeSpan Subtract(const wxDateTime& dt) const;
696
697
698 %nokwargs operator+=;
699 // add a time span (positive or negative)
700 inline wxDateTime& operator+=(const wxTimeSpan& diff);
701 // add a date span (positive or negative)
702 inline wxDateTime& operator+=(const wxDateSpan& diff);
703
704 %nokwargs operator-=;
705 // subtract a time span (positive or negative)
706 inline wxDateTime& operator-=(const wxTimeSpan& diff);
707 // subtract a date span (positive or negative)
708 inline wxDateTime& operator-=(const wxDateSpan& diff);
709
710
711 // inline bool operator<(const wxDateTime& dt) const;
712 // inline bool operator<=(const wxDateTime& dt) const;
713 // inline bool operator>(const wxDateTime& dt) const;
714 // inline bool operator>=(const wxDateTime& dt) const;
715 // inline bool operator==(const wxDateTime& dt) const;
716 // inline bool operator!=(const wxDateTime& dt) const;
717
718 %nokwargs __add__;
719 %nokwargs __sub__;
720 %extend {
721 wxDateTime __add__(const wxTimeSpan& other) { return *self + other; }
722 wxDateTime __add__(const wxDateSpan& other) { return *self + other; }
723
724 wxTimeSpan __sub__(const wxDateTime& other) { return *self - other; }
725 wxDateTime __sub__(const wxTimeSpan& other) { return *self - other; }
726 wxDateTime __sub__(const wxDateSpan& other) { return *self - other; }
727
728 // These fall back to just comparing pointers if other is NULL, or if
729 // either operand is invalid. This allows Python comparrisons to None
730 // to not assert and to return a sane value for the compare.
731 bool __lt__(const wxDateTime* other) {
732 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
733 return (*self < *other);
734 }
735 bool __le__(const wxDateTime* other) {
736 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
737 return (*self <= *other);
738 }
739 bool __gt__(const wxDateTime* other) {
740 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
741 return (*self > *other);
742 }
743 bool __ge__(const wxDateTime* other) {
744 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
745 return (*self >= *other);
746 }
747
748 bool __eq__(const wxDateTime* other) {
749 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
750 return (*self == *other);
751 }
752 bool __ne__(const wxDateTime* other) {
753 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
754 return (*self != *other);
755 }
756 }
757
758
759
760
761
762 // ------------------------------------------------------------------------
763 // conversion from text: all conversions from text return -1 on failure,
764 // or the index in the string where the next character following the date
765 // specification (i.e. the one where the scan had to stop) is located.
766
767 %extend {
768
769 // parse a string in RFC 822 format (found e.g. in mail headers and
770 // having the form "Wed, 10 Feb 1999 19:07:07 +0100")
771 int ParseRfc822Date(const wxString& date) {
772 const wxChar* rv;
773 const wxChar* _date = date;
774 rv = self->ParseRfc822Date(_date);
775 if (rv == NULL) return -1;
776 return rv - _date;
777 }
778
779
780 // parse a date/time in the given format (see strptime(3)), fill in
781 // the missing (in the string) fields with the values of dateDef (by
782 // default, they will not change if they had valid values or will
783 // default to Today() otherwise)
784 int ParseFormat(const wxString& date,
785 const wxString& format = wxPyDefaultDateTimeFormat,
786 const wxDateTime& dateDef = wxDefaultDateTime) {
787 const wxChar* rv;
788 const wxChar* _date = date;
789 rv = self->ParseFormat(_date, format, dateDef);
790 if (rv == NULL) return -1;
791 return rv - _date;
792 }
793
794 // parse a string containing the date/time in "free" format, this
795 // function will try to make an educated guess at the string contents
796 int ParseDateTime(const wxString& datetime) {
797 const wxChar* rv;
798 const wxChar* _datetime = datetime;
799 rv = self->ParseDateTime(_datetime);
800 if (rv == NULL) return -1;
801 return rv - _datetime;
802 }
803
804
805 // parse a string containing the date only in "free" format (less
806 // flexible than ParseDateTime)
807 int ParseDate(const wxString& date) {
808 const wxChar* rv;
809 const wxChar* _date = date;
810 rv = self->ParseDate(_date);
811 if (rv == NULL) return -1;
812 return rv - _date;
813 }
814
815 // parse a string containing the time only in "free" format
816 int ParseTime(const wxString& time) {
817 const wxChar* rv;
818 const wxChar* _time = time;
819 rv = self->ParseTime(_time);
820 if (rv == NULL) return -1;
821 return rv - _time;
822 }
823 }
824
825
826 // this function accepts strftime()-like format string (default
827 // argument corresponds to the preferred date and time representation
828 // for the current locale) and returns the string containing the
829 // resulting text representation
830 wxString Format(const wxString& format = wxPyDefaultDateTimeFormat,
831 const wxDateTime::TimeZone& tz = LOCAL_TZ) const;
832
833 // preferred date representation for the current locale
834 wxString FormatDate() const;
835
836 // preferred time representation for the current locale
837 wxString FormatTime() const;
838
839 // returns the string representing the date in ISO 8601 format
840 // (YYYY-MM-DD)
841 wxString FormatISODate() const;
842
843 // returns the string representing the time in ISO 8601 format
844 // (HH:MM:SS)
845 wxString FormatISOTime() const;
846
847 %pythoncode {
848 def __repr__(self):
849 if self.IsValid():
850 return '<wx.DateTime: \"%s\" at %s>' % ( self.Format(), self.this)
851 else:
852 return '<wx.DateTime: \"INVALID\" at %s>' % self.this
853 def __str__(self):
854 if self.IsValid():
855 return self.Format()
856 else:
857 return "INVALID DateTime"
858 }
859 };
860
861 //---------------------------------------------------------------------------
862 //---------------------------------------------------------------------------
863
864
865 // This class contains a difference between 2 wxDateTime values, so it makes
866 // sense to add it to wxDateTime and it is the result of subtraction of 2
867 // objects of that class. See also wxDateSpan.
868 class wxTimeSpan
869 {
870 public:
871
872 // return the timespan for the given number of seconds
873 static wxTimeSpan Seconds(long sec);
874 static wxTimeSpan Second();
875
876 // return the timespan for the given number of minutes
877 static wxTimeSpan Minutes(long min);
878 static wxTimeSpan Minute();
879
880 // return the timespan for the given number of hours
881 static wxTimeSpan Hours(long hours);
882 static wxTimeSpan Hour();
883
884 // return the timespan for the given number of days
885 static wxTimeSpan Days(long days);
886 static wxTimeSpan Day();
887
888 // return the timespan for the given number of weeks
889 static wxTimeSpan Weeks(long days);
890 static wxTimeSpan Week();
891
892 // ------------------------------------------------------------------------
893 // constructors
894
895 // from separate values for each component, date set to 0 (hours are
896 // not restricted to 0..24 range, neither are minutes, seconds or
897 // milliseconds)
898 wxTimeSpan(long hours = 0,
899 long minutes = 0,
900 long seconds = 0,
901 long milliseconds = 0);
902
903 ~wxTimeSpan();
904
905 // ------------------------------------------------------------------------
906 // arithmetics with time spans
907
908 // add two timespans together
909 inline wxTimeSpan& Add(const wxTimeSpan& diff);
910
911 // subtract another timespan
912 inline wxTimeSpan& Subtract(const wxTimeSpan& diff);
913
914 // multiply timespan by a scalar
915 inline wxTimeSpan& Multiply(int n);
916
917 // negate the value of the timespan
918 wxTimeSpan& Neg();
919
920 // return the absolute value of the timespan: does _not_ modify the
921 // object
922 inline wxTimeSpan Abs() const;
923
924
925 wxTimeSpan& operator+=(const wxTimeSpan& diff);
926 wxTimeSpan& operator-=(const wxTimeSpan& diff);
927 wxTimeSpan& operator*=(int n);
928 wxTimeSpan& operator-();
929
930 %extend {
931 wxTimeSpan __add__(const wxTimeSpan& other) { return *self + other; }
932 wxTimeSpan __sub__(const wxTimeSpan& other) { return *self - other; }
933 wxTimeSpan __mul__(int n) { return *self * n; }
934 wxTimeSpan __rmul__(int n) { return n * *self; }
935
936 bool __lt__(const wxTimeSpan* other) { return other ? (*self < *other) : false; }
937 bool __le__(const wxTimeSpan* other) { return other ? (*self <= *other) : false; }
938 bool __gt__(const wxTimeSpan* other) { return other ? (*self > *other) : true; }
939 bool __ge__(const wxTimeSpan* other) { return other ? (*self >= *other) : true; }
940 bool __eq__(const wxTimeSpan* other) { return other ? (*self == *other) : false; }
941 bool __ne__(const wxTimeSpan* other) { return other ? (*self != *other) : true; }
942 }
943
944
945
946 // ------------------------------------------------------------------------
947
948 // is the timespan null?
949 bool IsNull() const;
950
951 // is the timespan positive?
952 bool IsPositive() const;
953
954 // is the timespan negative?
955 bool IsNegative() const;
956
957 // are two timespans equal?
958 inline bool IsEqualTo(const wxTimeSpan& ts) const;
959
960 // compare two timestamps: works with the absolute values, i.e. -2
961 // hours is longer than 1 hour. Also, it will return False if the
962 // timespans are equal in absolute value.
963 inline bool IsLongerThan(const wxTimeSpan& ts) const;
964
965 // compare two timestamps: works with the absolute values, i.e. 1
966 // hour is shorter than -2 hours. Also, it will return False if the
967 // timespans are equal in absolute value.
968 bool IsShorterThan(const wxTimeSpan& t) const;
969
970 // ------------------------------------------------------------------------
971 // breaking into days, hours, minutes and seconds
972
973 // get the max number of weeks in this timespan
974 inline int GetWeeks() const;
975 // get the max number of days in this timespan
976 inline int GetDays() const;
977 // get the max number of hours in this timespan
978 inline int GetHours() const;
979 // get the max number of minutes in this timespan
980 inline int GetMinutes() const;
981
982
983 // get the max number of seconds in this timespan
984 inline wxLongLong GetSeconds() const;
985 // get the number of milliseconds in this timespan
986 wxLongLong GetMilliseconds() const;
987
988 // ------------------------------------------------------------------------
989 // conversion to text
990
991 // this function accepts strftime()-like format string (default
992 // argument corresponds to the preferred date and time representation
993 // for the current locale) and returns the string containing the
994 // resulting text representation. Notice that only some of format
995 // specifiers valid for wxDateTime are valid for wxTimeSpan: hours,
996 // minutes and seconds make sense, but not "PM/AM" string for example.
997 wxString Format(const wxString& format = wxPyDefaultTimeSpanFormat) const;
998
999 %pythoncode {
1000 def __repr__(self):
1001 return '<wx.TimeSpan: \"%s\" at %s>' % ( self.Format(), self.this)
1002 def __str__(self):
1003 return self.Format()
1004 }
1005 };
1006
1007
1008 //---------------------------------------------------------------------------
1009 //---------------------------------------------------------------------------
1010
1011 // This class is a "logical time span" and is useful for implementing program
1012 // logic for such things as "add one month to the date" which, in general,
1013 // doesn't mean to add 60*60*24*31 seconds to it, but to take the same date
1014 // the next month (to understand that this is indeed different consider adding
1015 // one month to Feb, 15 - we want to get Mar, 15, of course).
1016 //
1017 // When adding a month to the date, all lesser components (days, hours, ...)
1018 // won't be changed unless the resulting date would be invalid: for example,
1019 // Jan 31 + 1 month will be Feb 28, not (non existing) Feb 31.
1020 //
1021 // Because of this feature, adding and subtracting back again the same
1022 // wxDateSpan will *not*, in general give back the original date: Feb 28 - 1
1023 // month will be Jan 28, not Jan 31!
1024 //
1025 // wxDateSpan can be either positive or negative. They may be
1026 // multiplied by scalars which multiply all deltas by the scalar: i.e. 2*(1
1027 // month and 1 day) is 2 months and 2 days. They can be added together and
1028 // with wxDateTime or wxTimeSpan, but the type of result is different for each
1029 // case.
1030 //
1031 // Beware about weeks: if you specify both weeks and days, the total number of
1032 // days added will be 7*weeks + days! See also GetTotalDays() function.
1033 //
1034 // Equality operators are defined for wxDateSpans. Two datespans are equal if
1035 // they both give the same target date when added to *every* source date.
1036 // Thus wxDateSpan::Months(1) is not equal to wxDateSpan::Days(30), because
1037 // they not give the same date when added to 1 Feb. But wxDateSpan::Days(14) is
1038 // equal to wxDateSpan::Weeks(2)
1039 //
1040 // Finally, notice that for adding hours, minutes &c you don't need this
1041 // class: wxTimeSpan will do the job because there are no subtleties
1042 // associated with those.
1043 class wxDateSpan
1044 {
1045 public:
1046 // this many years/months/weeks/days
1047 wxDateSpan(int years = 0, int months = 0, int weeks = 0, int days = 0)
1048 {
1049 m_years = years;
1050 m_months = months;
1051 m_weeks = weeks;
1052 m_days = days;
1053 }
1054
1055 ~wxDateSpan();
1056
1057 // get an object for the given number of days
1058 static wxDateSpan Days(int days);
1059 static wxDateSpan Day();
1060
1061 // get an object for the given number of weeks
1062 static wxDateSpan Weeks(int weeks);
1063 static wxDateSpan Week();
1064
1065 // get an object for the given number of months
1066 static wxDateSpan Months(int mon);
1067 static wxDateSpan Month();
1068
1069 // get an object for the given number of years
1070 static wxDateSpan Years(int years);
1071 static wxDateSpan Year();
1072
1073
1074 // ------------------------------------------------------------------------
1075
1076 // set number of years
1077 wxDateSpan& SetYears(int n);
1078 // set number of months
1079 wxDateSpan& SetMonths(int n);
1080 // set number of weeks
1081 wxDateSpan& SetWeeks(int n);
1082 // set number of days
1083 wxDateSpan& SetDays(int n);
1084
1085 // get number of years
1086 int GetYears() const;
1087 // get number of months
1088 int GetMonths() const;
1089 // get number of weeks
1090 int GetWeeks() const;
1091 // get number of days
1092 int GetDays() const;
1093 // returns 7*GetWeeks() + GetDays()
1094 int GetTotalDays() const;
1095
1096
1097 // ------------------------------------------------------------------------
1098
1099 // add another wxDateSpan to us
1100 inline wxDateSpan& Add(const wxDateSpan& other);
1101
1102 // subtract another wxDateSpan from us
1103 inline wxDateSpan& Subtract(const wxDateSpan& other);
1104
1105 // inverse the sign of this timespan
1106 inline wxDateSpan& Neg();
1107
1108 // multiply all components by a (signed) number
1109 inline wxDateSpan& Multiply(int factor);
1110
1111 inline wxDateSpan& operator+=(const wxDateSpan& other);
1112 inline wxDateSpan& operator-=(const wxDateSpan& other);
1113 wxDateSpan& operator-() { return Neg(); }
1114 inline wxDateSpan& operator*=(int factor) { return Multiply(factor); }
1115
1116 %extend {
1117 wxDateSpan __add__(const wxDateSpan& other) { return *self + other; }
1118 wxDateSpan __sub__(const wxDateSpan& other) { return *self - other; }
1119 wxDateSpan __mul__(int n) { return *self * n; }
1120 wxDateSpan __rmul__(int n) { return n * *self; }
1121
1122 // bool __lt__(const wxDateSpan* other) { return other ? (*self < *other) : false; }
1123 // bool __le__(const wxDateSpan* other) { return other ? (*self <= *other) : false; }
1124 // bool __gt__(const wxDateSpan* other) { return other ? (*self > *other) : true; }
1125 // bool __ge__(const wxDateSpan* other) { return other ? (*self >= *other) : true; }
1126
1127 bool __eq__(const wxDateSpan* other) { return other ? (*self == *other) : false; }
1128 bool __ne__(const wxDateSpan* other) { return other ? (*self != *other) : true; }
1129 }
1130 };
1131
1132
1133 //---------------------------------------------------------------------------
1134
1135 // TODO: wxDateTimeHolidayAuthority
1136
1137 //---------------------------------------------------------------------------
1138
1139 long wxGetLocalTime();
1140 long wxGetUTCTime();
1141 long wxGetCurrentTime();
1142 wxLongLong wxGetLocalTimeMillis();
1143
1144 %immutable;
1145 const wxDateTime wxDefaultDateTime;
1146 %mutable;
1147
1148 //---------------------------------------------------------------------------
1149 //---------------------------------------------------------------------------