]>
Commit | Line | Data |
---|---|---|
2ef31e80 VZ |
1 | /////////////////////////////////////////////////////////////////////////////// |
2 | // Name: generic/calctrl.cpp | |
3 | // Purpose: implementation fo the generic wxCalendarCtrl | |
4 | // Author: Vadim Zeitlin | |
5 | // Modified by: | |
6 | // Created: 29.12.99 | |
7 | // RCS-ID: $Id$ | |
8 | // Copyright: (c) 1999 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr> | |
65571936 | 9 | // Licence: wxWindows licence |
2ef31e80 VZ |
10 | /////////////////////////////////////////////////////////////////////////////// |
11 | ||
12 | // ============================================================================ | |
13 | // declarations | |
14 | // ============================================================================ | |
15 | ||
16 | // ---------------------------------------------------------------------------- | |
17 | // headers | |
18 | // ---------------------------------------------------------------------------- | |
19 | ||
14f355c2 | 20 | #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA) |
2ef31e80 VZ |
21 | #pragma implementation "calctrl.h" |
22 | #endif | |
23 | ||
24 | // For compilers that support precompilation, includes "wx.h". | |
25 | #include "wx/wxprec.h" | |
26 | ||
27 | #ifdef __BORLANDC__ | |
28 | #pragma hdrstop | |
29 | #endif | |
30 | ||
31 | #ifndef WX_PRECOMP | |
9d9b7755 VZ |
32 | #include "wx/dcclient.h" |
33 | #include "wx/settings.h" | |
34 | #include "wx/brush.h" | |
4f6aed9c | 35 | #include "wx/combobox.h" |
5f89b543 | 36 | #include "wx/listbox.h" |
bc385ba9 | 37 | #include "wx/stattext.h" |
25f430fc | 38 | #include "wx/textctrl.h" |
2ef31e80 VZ |
39 | #endif //WX_PRECOMP |
40 | ||
1e6feb95 | 41 | #if wxUSE_CALENDARCTRL |
2fa7c206 | 42 | |
f0d5e7a2 VZ |
43 | #include "wx/spinctrl.h" |
44 | ||
ab9cf636 VZ |
45 | // if wxDatePickerCtrl code doesn't define the date event, do it here as we |
46 | // need it as well | |
47 | #if !wxUSE_DATEPICKCTRL | |
48 | #define _WX_DEFINE_DATE_EVENTS_ | |
49 | #endif | |
50 | ||
9d9b7755 | 51 | #include "wx/calctrl.h" |
2ef31e80 | 52 | |
882a8f40 VZ |
53 | #define DEBUG_PAINT 0 |
54 | ||
55 | // ---------------------------------------------------------------------------- | |
56 | // private classes | |
57 | // ---------------------------------------------------------------------------- | |
58 | ||
59 | class wxMonthComboBox : public wxComboBox | |
60 | { | |
61 | public: | |
62 | wxMonthComboBox(wxCalendarCtrl *cal); | |
63 | ||
64 | void OnMonthChange(wxCommandEvent& event) { m_cal->OnMonthChange(event); } | |
65 | ||
66 | private: | |
67 | wxCalendarCtrl *m_cal; | |
68 | ||
69 | DECLARE_EVENT_TABLE() | |
22f3361e | 70 | DECLARE_NO_COPY_CLASS(wxMonthComboBox) |
882a8f40 VZ |
71 | }; |
72 | ||
73 | class wxYearSpinCtrl : public wxSpinCtrl | |
74 | { | |
75 | public: | |
76 | wxYearSpinCtrl(wxCalendarCtrl *cal); | |
77 | ||
ca65c044 | 78 | void OnYearTextChange(wxCommandEvent& event) |
605dfd91 JS |
79 | { |
80 | m_cal->SetUserChangedYear(); | |
81 | m_cal->OnYearChange(event); | |
82 | } | |
882a8f40 VZ |
83 | void OnYearChange(wxSpinEvent& event) { m_cal->OnYearChange(event); } |
84 | ||
85 | private: | |
86 | wxCalendarCtrl *m_cal; | |
87 | ||
88 | DECLARE_EVENT_TABLE() | |
22f3361e | 89 | DECLARE_NO_COPY_CLASS(wxYearSpinCtrl) |
882a8f40 VZ |
90 | }; |
91 | ||
2ef31e80 VZ |
92 | // ---------------------------------------------------------------------------- |
93 | // wxWin macros | |
94 | // ---------------------------------------------------------------------------- | |
95 | ||
96 | BEGIN_EVENT_TABLE(wxCalendarCtrl, wxControl) | |
97 | EVT_PAINT(wxCalendarCtrl::OnPaint) | |
98 | ||
9d9b7755 VZ |
99 | EVT_CHAR(wxCalendarCtrl::OnChar) |
100 | ||
2ef31e80 | 101 | EVT_LEFT_DOWN(wxCalendarCtrl::OnClick) |
0185cd09 | 102 | EVT_LEFT_DCLICK(wxCalendarCtrl::OnDClick) |
882a8f40 VZ |
103 | END_EVENT_TABLE() |
104 | ||
105 | BEGIN_EVENT_TABLE(wxMonthComboBox, wxComboBox) | |
ca65c044 | 106 | EVT_COMBOBOX(wxID_ANY, wxMonthComboBox::OnMonthChange) |
882a8f40 | 107 | END_EVENT_TABLE() |
9d9b7755 | 108 | |
882a8f40 | 109 | BEGIN_EVENT_TABLE(wxYearSpinCtrl, wxSpinCtrl) |
ca65c044 WS |
110 | EVT_TEXT(wxID_ANY, wxYearSpinCtrl::OnYearTextChange) |
111 | EVT_SPINCTRL(wxID_ANY, wxYearSpinCtrl::OnYearChange) | |
2ef31e80 VZ |
112 | END_EVENT_TABLE() |
113 | ||
b0a877ec | 114 | #if wxUSE_EXTENDED_RTTI |
73c36334 JS |
115 | WX_DEFINE_FLAGS( wxCalendarCtrlStyle ) |
116 | ||
3ff066a4 | 117 | wxBEGIN_FLAGS( wxCalendarCtrlStyle ) |
73c36334 JS |
118 | // new style border flags, we put them first to |
119 | // use them for streaming out | |
3ff066a4 SC |
120 | wxFLAGS_MEMBER(wxBORDER_SIMPLE) |
121 | wxFLAGS_MEMBER(wxBORDER_SUNKEN) | |
122 | wxFLAGS_MEMBER(wxBORDER_DOUBLE) | |
123 | wxFLAGS_MEMBER(wxBORDER_RAISED) | |
124 | wxFLAGS_MEMBER(wxBORDER_STATIC) | |
125 | wxFLAGS_MEMBER(wxBORDER_NONE) | |
ca65c044 | 126 | |
73c36334 | 127 | // old style border flags |
3ff066a4 SC |
128 | wxFLAGS_MEMBER(wxSIMPLE_BORDER) |
129 | wxFLAGS_MEMBER(wxSUNKEN_BORDER) | |
130 | wxFLAGS_MEMBER(wxDOUBLE_BORDER) | |
131 | wxFLAGS_MEMBER(wxRAISED_BORDER) | |
132 | wxFLAGS_MEMBER(wxSTATIC_BORDER) | |
cb0afb26 | 133 | wxFLAGS_MEMBER(wxBORDER) |
73c36334 JS |
134 | |
135 | // standard window styles | |
3ff066a4 SC |
136 | wxFLAGS_MEMBER(wxTAB_TRAVERSAL) |
137 | wxFLAGS_MEMBER(wxCLIP_CHILDREN) | |
138 | wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW) | |
139 | wxFLAGS_MEMBER(wxWANTS_CHARS) | |
cb0afb26 | 140 | wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE) |
3ff066a4 SC |
141 | wxFLAGS_MEMBER(wxALWAYS_SHOW_SB ) |
142 | wxFLAGS_MEMBER(wxVSCROLL) | |
143 | wxFLAGS_MEMBER(wxHSCROLL) | |
144 | ||
145 | wxFLAGS_MEMBER(wxCAL_SUNDAY_FIRST) | |
146 | wxFLAGS_MEMBER(wxCAL_MONDAY_FIRST) | |
147 | wxFLAGS_MEMBER(wxCAL_SHOW_HOLIDAYS) | |
148 | wxFLAGS_MEMBER(wxCAL_NO_YEAR_CHANGE) | |
149 | wxFLAGS_MEMBER(wxCAL_NO_MONTH_CHANGE) | |
150 | wxFLAGS_MEMBER(wxCAL_SEQUENTIAL_MONTH_SELECTION) | |
151 | wxFLAGS_MEMBER(wxCAL_SHOW_SURROUNDING_WEEKS) | |
152 | ||
153 | wxEND_FLAGS( wxCalendarCtrlStyle ) | |
73c36334 | 154 | |
b0a877ec SC |
155 | IMPLEMENT_DYNAMIC_CLASS_XTI(wxCalendarCtrl, wxControl,"wx/calctrl.h") |
156 | ||
3ff066a4 SC |
157 | wxBEGIN_PROPERTIES_TABLE(wxCalendarCtrl) |
158 | wxEVENT_RANGE_PROPERTY( Updated , wxEVT_CALENDAR_SEL_CHANGED , wxEVT_CALENDAR_WEEKDAY_CLICKED , wxCalendarEvent ) | |
159 | wxHIDE_PROPERTY( Children ) | |
ca65c044 | 160 | wxPROPERTY( Date,wxDateTime, SetDate , GetDate, , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) |
3ff066a4 SC |
161 | wxPROPERTY_FLAGS( WindowStyle , wxCalendarCtrlStyle , long , SetWindowStyleFlag , GetWindowStyleFlag , , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style |
162 | wxEND_PROPERTIES_TABLE() | |
b0a877ec | 163 | |
3ff066a4 SC |
164 | wxBEGIN_HANDLERS_TABLE(wxCalendarCtrl) |
165 | wxEND_HANDLERS_TABLE() | |
b0a877ec | 166 | |
ca65c044 | 167 | wxCONSTRUCTOR_6( wxCalendarCtrl , wxWindow* , Parent , wxWindowID , Id , wxDateTime , Date , wxPoint , Position , wxSize , Size , long , WindowStyle ) |
b0a877ec | 168 | #else |
2ef31e80 | 169 | IMPLEMENT_DYNAMIC_CLASS(wxCalendarCtrl, wxControl) |
b0a877ec | 170 | #endif |
feb72429 | 171 | IMPLEMENT_DYNAMIC_CLASS(wxCalendarEvent, wxDateEvent) |
2ef31e80 | 172 | |
2e4df4bf VZ |
173 | // ---------------------------------------------------------------------------- |
174 | // events | |
175 | // ---------------------------------------------------------------------------- | |
176 | ||
177 | DEFINE_EVENT_TYPE(wxEVT_CALENDAR_SEL_CHANGED) | |
178 | DEFINE_EVENT_TYPE(wxEVT_CALENDAR_DAY_CHANGED) | |
179 | DEFINE_EVENT_TYPE(wxEVT_CALENDAR_MONTH_CHANGED) | |
180 | DEFINE_EVENT_TYPE(wxEVT_CALENDAR_YEAR_CHANGED) | |
181 | DEFINE_EVENT_TYPE(wxEVT_CALENDAR_DOUBLECLICKED) | |
182 | DEFINE_EVENT_TYPE(wxEVT_CALENDAR_WEEKDAY_CLICKED) | |
183 | ||
2ef31e80 VZ |
184 | // ============================================================================ |
185 | // implementation | |
186 | // ============================================================================ | |
187 | ||
882a8f40 VZ |
188 | // ---------------------------------------------------------------------------- |
189 | // wxMonthComboBox and wxYearSpinCtrl | |
190 | // ---------------------------------------------------------------------------- | |
191 | ||
192 | wxMonthComboBox::wxMonthComboBox(wxCalendarCtrl *cal) | |
ca65c044 | 193 | : wxComboBox(cal->GetParent(), wxID_ANY, |
882a8f40 VZ |
194 | wxEmptyString, |
195 | wxDefaultPosition, | |
196 | wxDefaultSize, | |
197 | 0, NULL, | |
fdda2df6 | 198 | wxCB_READONLY | wxCLIP_SIBLINGS) |
882a8f40 VZ |
199 | { |
200 | m_cal = cal; | |
201 | ||
202 | wxDateTime::Month m; | |
203 | for ( m = wxDateTime::Jan; m < wxDateTime::Inv_Month; wxNextMonth(m) ) | |
204 | { | |
205 | Append(wxDateTime::GetMonthName(m)); | |
206 | } | |
207 | ||
208 | SetSelection(m_cal->GetDate().GetMonth()); | |
422d0ff0 WS |
209 | SetSize(wxDefaultCoord, |
210 | wxDefaultCoord, | |
211 | wxDefaultCoord, | |
212 | wxDefaultCoord, | |
ca65c044 | 213 | wxSIZE_AUTO_WIDTH|wxSIZE_AUTO_HEIGHT); |
882a8f40 VZ |
214 | } |
215 | ||
216 | wxYearSpinCtrl::wxYearSpinCtrl(wxCalendarCtrl *cal) | |
ca65c044 | 217 | : wxSpinCtrl(cal->GetParent(), wxID_ANY, |
882a8f40 VZ |
218 | cal->GetDate().Format(_T("%Y")), |
219 | wxDefaultPosition, | |
220 | wxDefaultSize, | |
fdda2df6 | 221 | wxSP_ARROW_KEYS | wxCLIP_SIBLINGS, |
882a8f40 | 222 | -4300, 10000, cal->GetDate().GetYear()) |
95bcc40c | 223 | |
882a8f40 VZ |
224 | { |
225 | m_cal = cal; | |
226 | } | |
227 | ||
2ef31e80 VZ |
228 | // ---------------------------------------------------------------------------- |
229 | // wxCalendarCtrl | |
230 | // ---------------------------------------------------------------------------- | |
231 | ||
2b5f62a0 VZ |
232 | wxCalendarCtrl::wxCalendarCtrl(wxWindow *parent, |
233 | wxWindowID id, | |
234 | const wxDateTime& date, | |
235 | const wxPoint& pos, | |
236 | const wxSize& size, | |
237 | long style, | |
238 | const wxString& name) | |
239 | { | |
240 | Init(); | |
ca65c044 | 241 | |
2b5f62a0 VZ |
242 | (void)Create(parent, id, date, pos, size, style, name); |
243 | } | |
244 | ||
2ef31e80 VZ |
245 | void wxCalendarCtrl::Init() |
246 | { | |
247 | m_comboMonth = NULL; | |
248 | m_spinYear = NULL; | |
1882f416 JS |
249 | m_staticYear = NULL; |
250 | m_staticMonth = NULL; | |
2ef31e80 | 251 | |
ca65c044 | 252 | m_userChangedYear = false; |
f0d5e7a2 | 253 | |
2ef31e80 VZ |
254 | m_widthCol = |
255 | m_heightRow = 0; | |
9d9b7755 VZ |
256 | |
257 | wxDateTime::WeekDay wd; | |
258 | for ( wd = wxDateTime::Sun; wd < wxDateTime::Inv_WeekDay; wxNextWDay(wd) ) | |
259 | { | |
260 | m_weekdays[wd] = wxDateTime::GetWeekDayName(wd, wxDateTime::Name_Abbr); | |
261 | } | |
3965571c | 262 | |
4f6aed9c VZ |
263 | for ( size_t n = 0; n < WXSIZEOF(m_attrs); n++ ) |
264 | { | |
265 | m_attrs[n] = NULL; | |
266 | } | |
267 | ||
7516ed26 VZ |
268 | m_colHighlightFg = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT); |
269 | m_colHighlightBg = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT); | |
4f6aed9c VZ |
270 | |
271 | m_colHolidayFg = *wxRED; | |
272 | // don't set m_colHolidayBg - by default, same as our bg colour | |
273 | ||
274 | m_colHeaderFg = *wxBLUE; | |
275 | m_colHeaderBg = *wxLIGHT_GREY; | |
2ef31e80 VZ |
276 | } |
277 | ||
4965c3d7 VZ |
278 | bool wxCalendarCtrl::Create(wxWindow *parent, |
279 | wxWindowID id, | |
2ef31e80 | 280 | const wxDateTime& date, |
4965c3d7 | 281 | const wxPoint& pos, |
2ef31e80 VZ |
282 | const wxSize& size, |
283 | long style, | |
4965c3d7 | 284 | const wxString& name) |
2ef31e80 | 285 | { |
4965c3d7 | 286 | if ( !wxControl::Create(parent, id, pos, size, |
fdda2df6 VZ |
287 | style | wxCLIP_CHILDREN | wxWANTS_CHARS, |
288 | wxDefaultValidator, name) ) | |
4965c3d7 | 289 | { |
ca65c044 | 290 | return false; |
4965c3d7 VZ |
291 | } |
292 | ||
bc385ba9 VZ |
293 | // needed to get the arrow keys normally used for the dialog navigation |
294 | SetWindowStyle(style | wxWANTS_CHARS); | |
2ef31e80 | 295 | |
882a8f40 | 296 | m_date = date.IsValid() ? date : wxDateTime::Today(); |
9d9b7755 | 297 | |
37df1f33 VZ |
298 | m_lowdate = wxDefaultDateTime; |
299 | m_highdate = wxDefaultDateTime; | |
bc385ba9 | 300 | |
bb61a983 | 301 | if ( !HasFlag(wxCAL_SEQUENTIAL_MONTH_SELECTION) ) |
37df1f33 VZ |
302 | { |
303 | m_spinYear = new wxYearSpinCtrl(this); | |
ca65c044 | 304 | m_staticYear = new wxStaticText(GetParent(), wxID_ANY, m_date.Format(_T("%Y")), |
37df1f33 VZ |
305 | wxDefaultPosition, wxDefaultSize, |
306 | wxALIGN_CENTRE); | |
307 | ||
308 | m_comboMonth = new wxMonthComboBox(this); | |
ca65c044 | 309 | m_staticMonth = new wxStaticText(GetParent(), wxID_ANY, m_date.Format(_T("%B")), |
37df1f33 VZ |
310 | wxDefaultPosition, wxDefaultSize, |
311 | wxALIGN_CENTRE); | |
312 | } | |
bc385ba9 VZ |
313 | |
314 | ShowCurrentControls(); | |
9d9b7755 | 315 | |
bb61a983 VZ |
316 | // we need to set the position as well because the main control position |
317 | // is not the same as the one specified in pos if we have the controls | |
318 | // above it | |
ab473127 RD |
319 | SetBestSize(size); |
320 | SetPosition(pos); | |
85fab316 RD |
321 | |
322 | // Since we don't paint the whole background make sure that the platform | |
323 | // will use the right one. | |
324 | SetBackgroundColour(GetBackgroundColour()); | |
2997ca30 | 325 | |
4f6aed9c VZ |
326 | SetHolidayAttrs(); |
327 | ||
ca65c044 | 328 | return true; |
2ef31e80 VZ |
329 | } |
330 | ||
882a8f40 VZ |
331 | wxCalendarCtrl::~wxCalendarCtrl() |
332 | { | |
4f6aed9c VZ |
333 | for ( size_t n = 0; n < WXSIZEOF(m_attrs); n++ ) |
334 | { | |
335 | delete m_attrs[n]; | |
336 | } | |
882a8f40 VZ |
337 | } |
338 | ||
339 | // ---------------------------------------------------------------------------- | |
340 | // forward wxWin functions to subcontrols | |
341 | // ---------------------------------------------------------------------------- | |
342 | ||
b70462f4 MB |
343 | bool wxCalendarCtrl::Destroy() |
344 | { | |
f0d5e7a2 VZ |
345 | if ( m_staticYear ) |
346 | m_staticYear->Destroy(); | |
347 | if ( m_spinYear ) | |
348 | m_spinYear->Destroy(); | |
349 | if ( m_comboMonth ) | |
350 | m_comboMonth->Destroy(); | |
351 | if ( m_staticMonth ) | |
352 | m_staticMonth->Destroy(); | |
353 | ||
354 | m_staticYear = NULL; | |
355 | m_spinYear = NULL; | |
356 | m_comboMonth = NULL; | |
357 | m_staticMonth = NULL; | |
b70462f4 MB |
358 | |
359 | return wxControl::Destroy(); | |
360 | } | |
361 | ||
882a8f40 VZ |
362 | bool wxCalendarCtrl::Show(bool show) |
363 | { | |
364 | if ( !wxControl::Show(show) ) | |
365 | { | |
ca65c044 | 366 | return false; |
882a8f40 VZ |
367 | } |
368 | ||
37df1f33 VZ |
369 | if ( !(GetWindowStyle() & wxCAL_SEQUENTIAL_MONTH_SELECTION) ) |
370 | { | |
371 | if ( GetMonthControl() ) | |
372 | { | |
373 | GetMonthControl()->Show(show); | |
374 | GetYearControl()->Show(show); | |
375 | } | |
376 | } | |
882a8f40 | 377 | |
ca65c044 | 378 | return true; |
882a8f40 VZ |
379 | } |
380 | ||
381 | bool wxCalendarCtrl::Enable(bool enable) | |
382 | { | |
383 | if ( !wxControl::Enable(enable) ) | |
384 | { | |
ca65c044 | 385 | return false; |
882a8f40 VZ |
386 | } |
387 | ||
37df1f33 VZ |
388 | if ( !(GetWindowStyle() & wxCAL_SEQUENTIAL_MONTH_SELECTION) ) |
389 | { | |
390 | GetMonthControl()->Enable(enable); | |
391 | GetYearControl()->Enable(enable); | |
392 | } | |
882a8f40 | 393 | |
ca65c044 | 394 | return true; |
882a8f40 VZ |
395 | } |
396 | ||
bc385ba9 VZ |
397 | // ---------------------------------------------------------------------------- |
398 | // enable/disable month/year controls | |
399 | // ---------------------------------------------------------------------------- | |
400 | ||
401 | void wxCalendarCtrl::ShowCurrentControls() | |
402 | { | |
bb61a983 | 403 | if ( !HasFlag(wxCAL_SEQUENTIAL_MONTH_SELECTION) ) |
bc385ba9 | 404 | { |
37df1f33 | 405 | if ( AllowMonthChange() ) |
bc385ba9 | 406 | { |
37df1f33 VZ |
407 | m_comboMonth->Show(); |
408 | m_staticMonth->Hide(); | |
409 | ||
410 | if ( AllowYearChange() ) | |
411 | { | |
412 | m_spinYear->Show(); | |
413 | m_staticYear->Hide(); | |
bc385ba9 | 414 | |
37df1f33 VZ |
415 | // skip the rest |
416 | return; | |
417 | } | |
418 | } | |
419 | else | |
420 | { | |
421 | m_comboMonth->Hide(); | |
422 | m_staticMonth->Show(); | |
bc385ba9 | 423 | } |
bc385ba9 | 424 | |
37df1f33 VZ |
425 | // year change not allowed here |
426 | m_spinYear->Hide(); | |
427 | m_staticYear->Show(); | |
428 | } | |
bc385ba9 VZ |
429 | } |
430 | ||
431 | wxControl *wxCalendarCtrl::GetMonthControl() const | |
432 | { | |
380d9d62 | 433 | return AllowMonthChange() ? (wxControl *)m_comboMonth : (wxControl *)m_staticMonth; |
bc385ba9 VZ |
434 | } |
435 | ||
436 | wxControl *wxCalendarCtrl::GetYearControl() const | |
437 | { | |
380d9d62 | 438 | return AllowYearChange() ? (wxControl *)m_spinYear : (wxControl *)m_staticYear; |
bc385ba9 VZ |
439 | } |
440 | ||
441 | void wxCalendarCtrl::EnableYearChange(bool enable) | |
442 | { | |
443 | if ( enable != AllowYearChange() ) | |
444 | { | |
445 | long style = GetWindowStyle(); | |
446 | if ( enable ) | |
447 | style &= ~wxCAL_NO_YEAR_CHANGE; | |
448 | else | |
449 | style |= wxCAL_NO_YEAR_CHANGE; | |
450 | SetWindowStyle(style); | |
451 | ||
452 | ShowCurrentControls(); | |
37df1f33 VZ |
453 | if ( GetWindowStyle() & wxCAL_SEQUENTIAL_MONTH_SELECTION ) |
454 | { | |
455 | Refresh(); | |
456 | } | |
bc385ba9 VZ |
457 | } |
458 | } | |
459 | ||
460 | void wxCalendarCtrl::EnableMonthChange(bool enable) | |
461 | { | |
462 | if ( enable != AllowMonthChange() ) | |
463 | { | |
464 | long style = GetWindowStyle(); | |
465 | if ( enable ) | |
466 | style &= ~wxCAL_NO_MONTH_CHANGE; | |
467 | else | |
468 | style |= wxCAL_NO_MONTH_CHANGE; | |
469 | SetWindowStyle(style); | |
1bcf0c7d | 470 | |
bc385ba9 | 471 | ShowCurrentControls(); |
37df1f33 VZ |
472 | if ( GetWindowStyle() & wxCAL_SEQUENTIAL_MONTH_SELECTION ) |
473 | { | |
474 | Refresh(); | |
475 | } | |
bc385ba9 VZ |
476 | } |
477 | } | |
478 | ||
9d9b7755 VZ |
479 | // ---------------------------------------------------------------------------- |
480 | // changing date | |
481 | // ---------------------------------------------------------------------------- | |
482 | ||
37df1f33 | 483 | bool wxCalendarCtrl::SetDate(const wxDateTime& date) |
9d9b7755 | 484 | { |
ca65c044 | 485 | bool retval = true; |
37df1f33 | 486 | |
bc385ba9 VZ |
487 | bool sameMonth = m_date.GetMonth() == date.GetMonth(), |
488 | sameYear = m_date.GetYear() == date.GetYear(); | |
489 | ||
37df1f33 | 490 | if ( IsDateInRange(date) ) |
9d9b7755 | 491 | { |
37df1f33 | 492 | if ( sameMonth && sameYear ) |
bc385ba9 | 493 | { |
37df1f33 | 494 | // just change the day |
37df1f33 | 495 | ChangeDay(date); |
bc385ba9 | 496 | } |
37df1f33 VZ |
497 | else |
498 | { | |
f0d5e7a2 | 499 | if ( AllowMonthChange() && (AllowYearChange() || sameYear) ) |
37df1f33 | 500 | { |
f0d5e7a2 VZ |
501 | // change everything |
502 | m_date = date; | |
bc385ba9 | 503 | |
f0d5e7a2 | 504 | if ( !(GetWindowStyle() & wxCAL_SEQUENTIAL_MONTH_SELECTION) ) |
37df1f33 | 505 | { |
f0d5e7a2 VZ |
506 | // update the controls |
507 | m_comboMonth->SetSelection(m_date.GetMonth()); | |
508 | ||
509 | if ( AllowYearChange() ) | |
510 | { | |
511 | if ( !m_userChangedYear ) | |
512 | m_spinYear->SetValue(m_date.Format(_T("%Y"))); | |
f0d5e7a2 | 513 | } |
37df1f33 | 514 | } |
9d9b7755 | 515 | |
f0d5e7a2 VZ |
516 | // as the month changed, holidays did too |
517 | SetHolidayAttrs(); | |
0de868d9 | 518 | |
f0d5e7a2 VZ |
519 | // update the calendar |
520 | Refresh(); | |
521 | } | |
522 | else | |
523 | { | |
524 | // forbidden | |
ca65c044 | 525 | retval = false; |
f0d5e7a2 | 526 | } |
37df1f33 | 527 | } |
9d9b7755 | 528 | } |
37df1f33 | 529 | |
ca65c044 WS |
530 | m_userChangedYear = false; |
531 | ||
37df1f33 | 532 | return retval; |
9d9b7755 VZ |
533 | } |
534 | ||
535 | void wxCalendarCtrl::ChangeDay(const wxDateTime& date) | |
536 | { | |
537 | if ( m_date != date ) | |
538 | { | |
539 | // we need to refresh the row containing the old date and the one | |
540 | // containing the new one | |
541 | wxDateTime dateOld = m_date; | |
542 | m_date = date; | |
543 | ||
544 | RefreshDate(dateOld); | |
545 | ||
546 | // if the date is in the same row, it was already drawn correctly | |
547 | if ( GetWeek(m_date) != GetWeek(dateOld) ) | |
548 | { | |
549 | RefreshDate(m_date); | |
550 | } | |
551 | } | |
552 | } | |
553 | ||
554 | void wxCalendarCtrl::SetDateAndNotify(const wxDateTime& date) | |
555 | { | |
556 | wxDateTime::Tm tm1 = m_date.GetTm(), | |
557 | tm2 = date.GetTm(); | |
558 | ||
559 | wxEventType type; | |
560 | if ( tm1.year != tm2.year ) | |
561 | type = wxEVT_CALENDAR_YEAR_CHANGED; | |
562 | else if ( tm1.mon != tm2.mon ) | |
563 | type = wxEVT_CALENDAR_MONTH_CHANGED; | |
564 | else if ( tm1.mday != tm2.mday ) | |
565 | type = wxEVT_CALENDAR_DAY_CHANGED; | |
566 | else | |
567 | return; | |
568 | ||
37df1f33 VZ |
569 | if ( SetDate(date) ) |
570 | { | |
571 | GenerateEvents(type, wxEVT_CALENDAR_SEL_CHANGED); | |
572 | } | |
573 | } | |
574 | ||
575 | // ---------------------------------------------------------------------------- | |
576 | // date range | |
577 | // ---------------------------------------------------------------------------- | |
578 | ||
579 | bool wxCalendarCtrl::SetLowerDateLimit(const wxDateTime& date /* = wxDefaultDateTime */) | |
580 | { | |
ca65c044 | 581 | bool retval = true; |
37df1f33 | 582 | |
ca65c044 | 583 | if ( !(date.IsValid()) || ( ( m_highdate.IsValid() ) ? ( date <= m_highdate ) : true ) ) |
37df1f33 VZ |
584 | { |
585 | m_lowdate = date; | |
586 | } | |
587 | else | |
588 | { | |
ca65c044 | 589 | retval = false; |
37df1f33 | 590 | } |
9d9b7755 | 591 | |
37df1f33 VZ |
592 | return retval; |
593 | } | |
594 | ||
595 | bool wxCalendarCtrl::SetUpperDateLimit(const wxDateTime& date /* = wxDefaultDateTime */) | |
596 | { | |
ca65c044 | 597 | bool retval = true; |
37df1f33 | 598 | |
ca65c044 | 599 | if ( !(date.IsValid()) || ( ( m_lowdate.IsValid() ) ? ( date >= m_lowdate ) : true ) ) |
37df1f33 VZ |
600 | { |
601 | m_highdate = date; | |
602 | } | |
603 | else | |
604 | { | |
ca65c044 | 605 | retval = false; |
37df1f33 VZ |
606 | } |
607 | ||
608 | return retval; | |
609 | } | |
610 | ||
611 | bool wxCalendarCtrl::SetDateRange(const wxDateTime& lowerdate /* = wxDefaultDateTime */, const wxDateTime& upperdate /* = wxDefaultDateTime */) | |
612 | { | |
ca65c044 | 613 | bool retval = true; |
37df1f33 VZ |
614 | |
615 | if ( | |
ca65c044 WS |
616 | ( !( lowerdate.IsValid() ) || ( ( upperdate.IsValid() ) ? ( lowerdate <= upperdate ) : true ) ) && |
617 | ( !( upperdate.IsValid() ) || ( ( lowerdate.IsValid() ) ? ( upperdate >= lowerdate ) : true ) ) ) | |
37df1f33 VZ |
618 | { |
619 | m_lowdate = lowerdate; | |
620 | m_highdate = upperdate; | |
621 | } | |
622 | else | |
623 | { | |
ca65c044 | 624 | retval = false; |
37df1f33 | 625 | } |
1bcf0c7d | 626 | |
37df1f33 | 627 | return retval; |
9d9b7755 VZ |
628 | } |
629 | ||
2ef31e80 VZ |
630 | // ---------------------------------------------------------------------------- |
631 | // date helpers | |
632 | // ---------------------------------------------------------------------------- | |
633 | ||
634 | wxDateTime wxCalendarCtrl::GetStartDate() const | |
635 | { | |
636 | wxDateTime::Tm tm = m_date.GetTm(); | |
637 | ||
638 | wxDateTime date = wxDateTime(1, tm.mon, tm.year); | |
9d9b7755 | 639 | |
1a8557b1 VZ |
640 | // rewind back |
641 | date.SetToPrevWeekDay(GetWindowStyle() & wxCAL_MONDAY_FIRST | |
642 | ? wxDateTime::Mon : wxDateTime::Sun); | |
643 | ||
37df1f33 VZ |
644 | if ( GetWindowStyle() & wxCAL_SHOW_SURROUNDING_WEEKS ) |
645 | { | |
646 | // We want to offset the calendar if we start on the first.. | |
647 | if ( date.GetDay() == 1 ) | |
648 | { | |
649 | date -= wxDateSpan::Week(); | |
650 | } | |
651 | } | |
652 | ||
2ef31e80 VZ |
653 | return date; |
654 | } | |
655 | ||
656 | bool wxCalendarCtrl::IsDateShown(const wxDateTime& date) const | |
657 | { | |
37df1f33 VZ |
658 | if ( !(GetWindowStyle() & wxCAL_SHOW_SURROUNDING_WEEKS) ) |
659 | { | |
660 | return date.GetMonth() == m_date.GetMonth(); | |
661 | } | |
662 | else | |
663 | { | |
ca65c044 | 664 | return true; |
37df1f33 VZ |
665 | } |
666 | } | |
667 | ||
668 | bool wxCalendarCtrl::IsDateInRange(const wxDateTime& date) const | |
669 | { | |
37df1f33 | 670 | // Check if the given date is in the range specified |
ca65c044 WS |
671 | return ( ( ( m_lowdate.IsValid() ) ? ( date >= m_lowdate ) : true ) |
672 | && ( ( m_highdate.IsValid() ) ? ( date <= m_highdate ) : true ) ); | |
37df1f33 VZ |
673 | } |
674 | ||
675 | bool wxCalendarCtrl::ChangeYear(wxDateTime* target) const | |
676 | { | |
ca65c044 | 677 | bool retval = false; |
37df1f33 VZ |
678 | |
679 | if ( !(IsDateInRange(*target)) ) | |
680 | { | |
681 | if ( target->GetYear() < m_date.GetYear() ) | |
682 | { | |
683 | if ( target->GetYear() >= GetLowerDateLimit().GetYear() ) | |
684 | { | |
685 | *target = GetLowerDateLimit(); | |
ca65c044 | 686 | retval = true; |
37df1f33 VZ |
687 | } |
688 | else | |
689 | { | |
690 | *target = m_date; | |
691 | } | |
692 | } | |
693 | else | |
694 | { | |
695 | if ( target->GetYear() <= GetUpperDateLimit().GetYear() ) | |
696 | { | |
697 | *target = GetUpperDateLimit(); | |
ca65c044 | 698 | retval = true; |
37df1f33 VZ |
699 | } |
700 | else | |
701 | { | |
702 | *target = m_date; | |
703 | } | |
704 | } | |
705 | } | |
706 | else | |
707 | { | |
ca65c044 | 708 | retval = true; |
37df1f33 VZ |
709 | } |
710 | ||
711 | return retval; | |
712 | } | |
713 | ||
714 | bool wxCalendarCtrl::ChangeMonth(wxDateTime* target) const | |
715 | { | |
ca65c044 | 716 | bool retval = true; |
37df1f33 VZ |
717 | |
718 | if ( !(IsDateInRange(*target)) ) | |
719 | { | |
ca65c044 | 720 | retval = false; |
37df1f33 VZ |
721 | |
722 | if ( target->GetMonth() < m_date.GetMonth() ) | |
723 | { | |
724 | *target = GetLowerDateLimit(); | |
725 | } | |
726 | else | |
727 | { | |
728 | *target = GetUpperDateLimit(); | |
729 | } | |
730 | } | |
731 | ||
732 | return retval; | |
2ef31e80 VZ |
733 | } |
734 | ||
9d9b7755 VZ |
735 | size_t wxCalendarCtrl::GetWeek(const wxDateTime& date) const |
736 | { | |
37df1f33 VZ |
737 | size_t retval = date.GetWeekOfMonth(GetWindowStyle() & wxCAL_MONDAY_FIRST |
738 | ? wxDateTime::Monday_First | |
739 | : wxDateTime::Sunday_First); | |
740 | ||
741 | if ( (GetWindowStyle() & wxCAL_SHOW_SURROUNDING_WEEKS) ) | |
742 | { | |
743 | // we need to offset an extra week if we "start" on the 1st of the month | |
744 | wxDateTime::Tm tm = date.GetTm(); | |
745 | ||
746 | wxDateTime datetest = wxDateTime(1, tm.mon, tm.year); | |
747 | ||
748 | // rewind back | |
749 | datetest.SetToPrevWeekDay(GetWindowStyle() & wxCAL_MONDAY_FIRST | |
750 | ? wxDateTime::Mon : wxDateTime::Sun); | |
1bcf0c7d | 751 | |
37df1f33 VZ |
752 | if ( datetest.GetDay() == 1 ) |
753 | { | |
754 | retval += 1; | |
755 | } | |
756 | } | |
1bcf0c7d | 757 | |
37df1f33 | 758 | return retval; |
9d9b7755 VZ |
759 | } |
760 | ||
2ef31e80 VZ |
761 | // ---------------------------------------------------------------------------- |
762 | // size management | |
763 | // ---------------------------------------------------------------------------- | |
764 | ||
9d9b7755 VZ |
765 | // this is a composite control and it must arrange its parts each time its |
766 | // size or position changes: the combobox and spinctrl are along the top of | |
767 | // the available area and the calendar takes up therest of the space | |
768 | ||
bc385ba9 VZ |
769 | // the static controls are supposed to be always smaller than combo/spin so we |
770 | // always use the latter for size calculations and position the static to take | |
771 | // the same space | |
772 | ||
9d9b7755 VZ |
773 | // the constants used for the layout |
774 | #define VERT_MARGIN 5 // distance between combo and calendar | |
81b6ccf1 SC |
775 | #ifdef __WXMAC__ |
776 | #define HORZ_MARGIN 5 // spin | |
777 | #else | |
9d9b7755 | 778 | #define HORZ_MARGIN 15 // spin |
81b6ccf1 | 779 | #endif |
2ef31e80 VZ |
780 | wxSize wxCalendarCtrl::DoGetBestSize() const |
781 | { | |
9d9b7755 VZ |
782 | // calc the size of the calendar |
783 | ((wxCalendarCtrl *)this)->RecalcGeometry(); // const_cast | |
784 | ||
785 | wxCoord width = 7*m_widthCol, | |
bb61a983 | 786 | height = 7*m_heightRow + m_rowOffset + VERT_MARGIN; |
9d9b7755 | 787 | |
bb61a983 | 788 | if ( !HasFlag(wxCAL_SEQUENTIAL_MONTH_SELECTION) ) |
37df1f33 | 789 | { |
bb61a983 VZ |
790 | // the combobox doesn't report its height correctly (it returns the |
791 | // height including the drop down list) so don't use it | |
792 | height += m_spinYear->GetBestSize().y; | |
37df1f33 VZ |
793 | } |
794 | ||
bb61a983 | 795 | if ( !HasFlag(wxBORDER_NONE) ) |
bc385ba9 VZ |
796 | { |
797 | // the border would clip the last line otherwise | |
f41cb81e | 798 | height += 6; |
37df1f33 | 799 | width += 4; |
bc385ba9 VZ |
800 | } |
801 | ||
ab473127 RD |
802 | wxSize best(width, height); |
803 | CacheBestSize(best); | |
2997ca30 | 804 | return best; |
2ef31e80 VZ |
805 | } |
806 | ||
807 | void wxCalendarCtrl::DoSetSize(int x, int y, | |
808 | int width, int height, | |
809 | int sizeFlags) | |
810 | { | |
811 | wxControl::DoSetSize(x, y, width, height, sizeFlags); | |
812 | } | |
813 | ||
814 | void wxCalendarCtrl::DoMoveWindow(int x, int y, int width, int height) | |
815 | { | |
bb61a983 | 816 | int yDiff; |
2ef31e80 | 817 | |
bb61a983 | 818 | if ( !HasFlag(wxCAL_SEQUENTIAL_MONTH_SELECTION) ) |
37df1f33 VZ |
819 | { |
820 | wxSize sizeCombo = m_comboMonth->GetSize(); | |
821 | wxSize sizeStatic = m_staticMonth->GetSize(); | |
95bcc40c | 822 | wxSize sizeSpin = m_spinYear->GetSize(); |
37df1f33 | 823 | int dy = (sizeCombo.y - sizeStatic.y) / 2; |
e910c000 JS |
824 | m_comboMonth->Move(x, y); |
825 | m_staticMonth->SetSize(x, y + dy, sizeCombo.x, sizeStatic.y); | |
37df1f33 | 826 | |
e910c000 JS |
827 | int xDiff = sizeCombo.x + HORZ_MARGIN; |
828 | ||
829 | m_spinYear->SetSize(x + xDiff, y, width - xDiff, sizeCombo.y); | |
830 | m_staticYear->SetSize(x + xDiff, y + dy, width - xDiff, sizeStatic.y); | |
50807f90 | 831 | |
37df1f33 VZ |
832 | yDiff = wxMax(sizeSpin.y, sizeCombo.y) + VERT_MARGIN; |
833 | } | |
bb61a983 VZ |
834 | else // no controls on the top |
835 | { | |
836 | yDiff = 0; | |
837 | } | |
9d9b7755 VZ |
838 | |
839 | wxControl::DoMoveWindow(x, y + yDiff, width, height - yDiff); | |
840 | } | |
841 | ||
882a8f40 VZ |
842 | void wxCalendarCtrl::DoGetPosition(int *x, int *y) const |
843 | { | |
844 | wxControl::DoGetPosition(x, y); | |
845 | ||
37df1f33 | 846 | if ( !(GetWindowStyle() & wxCAL_SEQUENTIAL_MONTH_SELECTION) ) |
882a8f40 | 847 | { |
37df1f33 VZ |
848 | // our real top corner is not in this position |
849 | if ( y ) | |
850 | { | |
851 | *y -= GetMonthControl()->GetSize().y + VERT_MARGIN; | |
852 | } | |
882a8f40 VZ |
853 | } |
854 | } | |
855 | ||
856 | void wxCalendarCtrl::DoGetSize(int *width, int *height) const | |
857 | { | |
858 | wxControl::DoGetSize(width, height); | |
859 | ||
37df1f33 | 860 | if ( !(GetWindowStyle() & wxCAL_SEQUENTIAL_MONTH_SELECTION) ) |
882a8f40 | 861 | { |
37df1f33 | 862 | // our real height is bigger |
5b3610da | 863 | if ( height && GetMonthControl()) |
37df1f33 VZ |
864 | { |
865 | *height += GetMonthControl()->GetSize().y + VERT_MARGIN; | |
866 | } | |
882a8f40 VZ |
867 | } |
868 | } | |
869 | ||
9d9b7755 | 870 | void wxCalendarCtrl::RecalcGeometry() |
2ef31e80 | 871 | { |
9d9b7755 | 872 | wxClientDC dc(this); |
3965571c | 873 | |
ab473127 | 874 | dc.SetFont(GetFont()); |
3965571c | 875 | |
2ef31e80 VZ |
876 | // determine the column width (we assume that the weekday names are always |
877 | // wider (in any language) than the numbers) | |
878 | m_widthCol = 0; | |
9d9b7755 | 879 | wxDateTime::WeekDay wd; |
2ef31e80 VZ |
880 | for ( wd = wxDateTime::Sun; wd < wxDateTime::Inv_WeekDay; wxNextWDay(wd) ) |
881 | { | |
2ef31e80 | 882 | wxCoord width; |
9d9b7755 | 883 | dc.GetTextExtent(m_weekdays[wd], &width, &m_heightRow); |
2ef31e80 VZ |
884 | if ( width > m_widthCol ) |
885 | { | |
886 | m_widthCol = width; | |
887 | } | |
888 | } | |
3965571c | 889 | |
2ef31e80 VZ |
890 | // leave some margins |
891 | m_widthCol += 2; | |
892 | m_heightRow += 2; | |
37df1f33 VZ |
893 | |
894 | m_rowOffset = (GetWindowStyle() & wxCAL_SEQUENTIAL_MONTH_SELECTION) ? m_heightRow : 0; // conditional in relation to style | |
9d9b7755 VZ |
895 | } |
896 | ||
897 | // ---------------------------------------------------------------------------- | |
898 | // drawing | |
899 | // ---------------------------------------------------------------------------- | |
900 | ||
13111b2a | 901 | void wxCalendarCtrl::OnPaint(wxPaintEvent& WXUNUSED(event)) |
9d9b7755 | 902 | { |
07e87221 | 903 | wxPaintDC dc(this); |
3965571c | 904 | |
ab473127 | 905 | dc.SetFont(GetFont()); |
9d9b7755 | 906 | |
3965571c | 907 | RecalcGeometry(); |
9d9b7755 | 908 | |
882a8f40 | 909 | #if DEBUG_PAINT |
f6bcfd97 | 910 | wxLogDebug("--- starting to paint, selection: %s, week %u\n", |
9d9b7755 VZ |
911 | m_date.Format("%a %d-%m-%Y %H:%M:%S").c_str(), |
912 | GetWeek(m_date)); | |
882a8f40 | 913 | #endif |
2ef31e80 | 914 | |
37df1f33 VZ |
915 | wxCoord y = 0; |
916 | ||
bb61a983 | 917 | if ( HasFlag(wxCAL_SEQUENTIAL_MONTH_SELECTION) ) |
37df1f33 VZ |
918 | { |
919 | // draw the sequential month-selector | |
920 | ||
921 | dc.SetBackgroundMode(wxTRANSPARENT); | |
922 | dc.SetTextForeground(*wxBLACK); | |
923 | dc.SetBrush(wxBrush(m_colHeaderBg, wxSOLID)); | |
924 | dc.SetPen(wxPen(m_colHeaderBg, 1, wxSOLID)); | |
eaf6274c | 925 | dc.DrawRectangle(0, y, GetClientSize().x, m_heightRow); |
37df1f33 VZ |
926 | |
927 | // Get extent of month-name + year | |
928 | wxCoord monthw, monthh; | |
50d0b061 | 929 | wxString headertext = m_date.Format(wxT("%B %Y")); |
37df1f33 VZ |
930 | dc.GetTextExtent(headertext, &monthw, &monthh); |
931 | ||
932 | // draw month-name centered above weekdays | |
933 | wxCoord monthx = ((m_widthCol * 7) - monthw) / 2; | |
934 | wxCoord monthy = ((m_heightRow - monthh) / 2) + y; | |
1bcf0c7d | 935 | dc.DrawText(headertext, monthx, monthy); |
37df1f33 VZ |
936 | |
937 | // calculate the "month-arrows" | |
938 | wxPoint leftarrow[3]; | |
939 | wxPoint rightarrow[3]; | |
940 | ||
941 | int arrowheight = monthh / 2; | |
1bcf0c7d | 942 | |
37df1f33 VZ |
943 | leftarrow[0] = wxPoint(0, arrowheight / 2); |
944 | leftarrow[1] = wxPoint(arrowheight / 2, 0); | |
945 | leftarrow[2] = wxPoint(arrowheight / 2, arrowheight - 1); | |
946 | ||
c47addef | 947 | rightarrow[0] = wxPoint(0,0); |
37df1f33 VZ |
948 | rightarrow[1] = wxPoint(arrowheight / 2, arrowheight / 2); |
949 | rightarrow[2] = wxPoint(0, arrowheight - 1); | |
950 | ||
951 | // draw the "month-arrows" | |
952 | ||
953 | wxCoord arrowy = (m_heightRow - arrowheight) / 2; | |
954 | wxCoord larrowx = (m_widthCol - (arrowheight / 2)) / 2; | |
955 | wxCoord rarrowx = ((m_widthCol - (arrowheight / 2)) / 2) + m_widthCol*6; | |
c47addef | 956 | m_leftArrowRect = m_rightArrowRect = wxRect(0,0,0,0); |
37df1f33 VZ |
957 | |
958 | if ( AllowMonthChange() ) | |
959 | { | |
960 | wxDateTime ldpm = wxDateTime(1,m_date.GetMonth(), m_date.GetYear()) - wxDateSpan::Day(); // last day prev month | |
961 | // Check if range permits change | |
ca65c044 | 962 | if ( IsDateInRange(ldpm) && ( ( ldpm.GetYear() == m_date.GetYear() ) ? true : AllowYearChange() ) ) |
37df1f33 VZ |
963 | { |
964 | m_leftArrowRect = wxRect(larrowx - 3, arrowy - 3, (arrowheight / 2) + 8, (arrowheight + 6)); | |
965 | dc.SetBrush(wxBrush(*wxBLACK, wxSOLID)); | |
966 | dc.SetPen(wxPen(*wxBLACK, 1, wxSOLID)); | |
967 | dc.DrawPolygon(3, leftarrow, larrowx , arrowy, wxWINDING_RULE); | |
968 | dc.SetBrush(*wxTRANSPARENT_BRUSH); | |
969 | dc.DrawRectangle(m_leftArrowRect); | |
970 | } | |
971 | wxDateTime fdnm = wxDateTime(1,m_date.GetMonth(), m_date.GetYear()) + wxDateSpan::Month(); // first day next month | |
ca65c044 | 972 | if ( IsDateInRange(fdnm) && ( ( fdnm.GetYear() == m_date.GetYear() ) ? true : AllowYearChange() ) ) |
37df1f33 VZ |
973 | { |
974 | m_rightArrowRect = wxRect(rarrowx - 4, arrowy - 3, (arrowheight / 2) + 8, (arrowheight + 6)); | |
975 | dc.SetBrush(wxBrush(*wxBLACK, wxSOLID)); | |
976 | dc.SetPen(wxPen(*wxBLACK, 1, wxSOLID)); | |
977 | dc.DrawPolygon(3, rightarrow, rarrowx , arrowy, wxWINDING_RULE); | |
978 | dc.SetBrush(*wxTRANSPARENT_BRUSH); | |
979 | dc.DrawRectangle(m_rightArrowRect); | |
980 | } | |
981 | } | |
982 | ||
983 | y += m_heightRow; | |
984 | } | |
985 | ||
2ef31e80 | 986 | // first draw the week days |
37df1f33 | 987 | if ( IsExposed(0, y, 7*m_widthCol, m_heightRow) ) |
2ef31e80 | 988 | { |
882a8f40 | 989 | #if DEBUG_PAINT |
f6bcfd97 | 990 | wxLogDebug("painting the header"); |
882a8f40 | 991 | #endif |
9d9b7755 | 992 | |
9d9b7755 | 993 | dc.SetBackgroundMode(wxTRANSPARENT); |
4f6aed9c VZ |
994 | dc.SetTextForeground(m_colHeaderFg); |
995 | dc.SetBrush(wxBrush(m_colHeaderBg, wxSOLID)); | |
996 | dc.SetPen(wxPen(m_colHeaderBg, 1, wxSOLID)); | |
bb61a983 | 997 | dc.DrawRectangle(0, y, GetClientSize().x, m_heightRow); |
1a8557b1 VZ |
998 | |
999 | bool startOnMonday = (GetWindowStyle() & wxCAL_MONDAY_FIRST) != 0; | |
1000 | for ( size_t wd = 0; wd < 7; wd++ ) | |
9d9b7755 | 1001 | { |
1a8557b1 VZ |
1002 | size_t n; |
1003 | if ( startOnMonday ) | |
1004 | n = wd == 6 ? 0 : wd + 1; | |
1005 | else | |
1006 | n = wd; | |
37df1f33 VZ |
1007 | wxCoord dayw, dayh; |
1008 | dc.GetTextExtent(m_weekdays[n], &dayw, &dayh); | |
37df1f33 | 1009 | dc.DrawText(m_weekdays[n], (wd*m_widthCol) + ((m_widthCol- dayw) / 2), y); // center the day-name |
9d9b7755 | 1010 | } |
2ef31e80 VZ |
1011 | } |
1012 | ||
1013 | // then the calendar itself | |
1014 | dc.SetTextForeground(*wxBLACK); | |
1015 | //dc.SetFont(*wxNORMAL_FONT); | |
1016 | ||
37df1f33 | 1017 | y += m_heightRow; |
2ef31e80 | 1018 | wxDateTime date = GetStartDate(); |
37df1f33 | 1019 | |
882a8f40 | 1020 | #if DEBUG_PAINT |
f6bcfd97 | 1021 | wxLogDebug("starting calendar from %s\n", |
9d9b7755 | 1022 | date.Format("%a %d-%m-%Y %H:%M:%S").c_str()); |
882a8f40 | 1023 | #endif |
9d9b7755 | 1024 | |
2ef31e80 | 1025 | dc.SetBackgroundMode(wxSOLID); |
9d9b7755 | 1026 | for ( size_t nWeek = 1; nWeek <= 6; nWeek++, y += m_heightRow ) |
2ef31e80 | 1027 | { |
9d9b7755 | 1028 | // if the update region doesn't intersect this row, don't paint it |
15807266 | 1029 | if ( !IsExposed(0, y, 7*m_widthCol, m_heightRow - 1) ) |
9d9b7755 VZ |
1030 | { |
1031 | date += wxDateSpan::Week(); | |
1032 | ||
1033 | continue; | |
1034 | } | |
882a8f40 | 1035 | |
1a8557b1 | 1036 | #if DEBUG_PAINT |
f6bcfd97 | 1037 | wxLogDebug("painting week %d at y = %d\n", nWeek, y); |
882a8f40 | 1038 | #endif |
9d9b7755 | 1039 | |
1a8557b1 | 1040 | for ( size_t wd = 0; wd < 7; wd++ ) |
2ef31e80 VZ |
1041 | { |
1042 | if ( IsDateShown(date) ) | |
1043 | { | |
882a8f40 | 1044 | // don't use wxDate::Format() which prepends 0s |
4f6aed9c VZ |
1045 | unsigned int day = date.GetDay(); |
1046 | wxString dayStr = wxString::Format(_T("%u"), day); | |
3965571c | 1047 | wxCoord width; |
4f6aed9c VZ |
1048 | dc.GetTextExtent(dayStr, &width, (wxCoord *)NULL); |
1049 | ||
ca65c044 WS |
1050 | bool changedColours = false, |
1051 | changedFont = false; | |
4f6aed9c | 1052 | |
ca65c044 | 1053 | bool isSel = false; |
37df1f33 | 1054 | wxCalendarDateAttr *attr = NULL; |
2ef31e80 | 1055 | |
37df1f33 | 1056 | if ( date.GetMonth() != m_date.GetMonth() || !IsDateInRange(date) ) |
2ef31e80 | 1057 | { |
37df1f33 VZ |
1058 | // surrounding week or out-of-range |
1059 | // draw "disabled" | |
1060 | dc.SetTextForeground(*wxLIGHT_GREY); | |
ca65c044 | 1061 | changedColours = true; |
4f6aed9c | 1062 | } |
37df1f33 | 1063 | else |
4f6aed9c | 1064 | { |
37df1f33 VZ |
1065 | isSel = date.IsSameDate(m_date); |
1066 | attr = m_attrs[day - 1]; | |
4f6aed9c | 1067 | |
37df1f33 | 1068 | if ( isSel ) |
4f6aed9c | 1069 | { |
37df1f33 VZ |
1070 | dc.SetTextForeground(m_colHighlightFg); |
1071 | dc.SetTextBackground(m_colHighlightBg); | |
4f6aed9c | 1072 | |
ca65c044 | 1073 | changedColours = true; |
4f6aed9c | 1074 | } |
37df1f33 | 1075 | else if ( attr ) |
4f6aed9c | 1076 | { |
37df1f33 VZ |
1077 | wxColour colFg, colBg; |
1078 | ||
1079 | if ( attr->IsHoliday() ) | |
1080 | { | |
1081 | colFg = m_colHolidayFg; | |
1082 | colBg = m_colHolidayBg; | |
1083 | } | |
1084 | else | |
1085 | { | |
1086 | colFg = attr->GetTextColour(); | |
1087 | colBg = attr->GetBackgroundColour(); | |
1088 | } | |
1089 | ||
1090 | if ( colFg.Ok() ) | |
1091 | { | |
1092 | dc.SetTextForeground(colFg); | |
ca65c044 | 1093 | changedColours = true; |
37df1f33 VZ |
1094 | } |
1095 | ||
1096 | if ( colBg.Ok() ) | |
1097 | { | |
1098 | dc.SetTextBackground(colBg); | |
ca65c044 | 1099 | changedColours = true; |
37df1f33 VZ |
1100 | } |
1101 | ||
1102 | if ( attr->HasFont() ) | |
1103 | { | |
1104 | dc.SetFont(attr->GetFont()); | |
ca65c044 | 1105 | changedFont = true; |
37df1f33 | 1106 | } |
4f6aed9c | 1107 | } |
2ef31e80 VZ |
1108 | } |
1109 | ||
4f6aed9c VZ |
1110 | wxCoord x = wd*m_widthCol + (m_widthCol - width) / 2; |
1111 | dc.DrawText(dayStr, x, y + 1); | |
2ef31e80 | 1112 | |
4f6aed9c VZ |
1113 | if ( !isSel && attr && attr->HasBorder() ) |
1114 | { | |
1115 | wxColour colBorder; | |
1116 | if ( attr->HasBorderColour() ) | |
1117 | { | |
1118 | colBorder = attr->GetBorderColour(); | |
1119 | } | |
1120 | else | |
1121 | { | |
ab473127 | 1122 | colBorder = GetForegroundColour(); |
4f6aed9c VZ |
1123 | } |
1124 | ||
1125 | wxPen pen(colBorder, 1, wxSOLID); | |
1126 | dc.SetPen(pen); | |
1127 | dc.SetBrush(*wxTRANSPARENT_BRUSH); | |
1128 | ||
1129 | switch ( attr->GetBorder() ) | |
1130 | { | |
1131 | case wxCAL_BORDER_SQUARE: | |
1132 | dc.DrawRectangle(x - 2, y, | |
1133 | width + 4, m_heightRow); | |
1134 | break; | |
1135 | ||
1136 | case wxCAL_BORDER_ROUND: | |
1137 | dc.DrawEllipse(x - 2, y, | |
1138 | width + 4, m_heightRow); | |
1139 | break; | |
1140 | ||
1141 | default: | |
1142 | wxFAIL_MSG(_T("unknown border type")); | |
1143 | } | |
1144 | } | |
1145 | ||
1146 | if ( changedColours ) | |
2ef31e80 | 1147 | { |
ab473127 RD |
1148 | dc.SetTextForeground(GetForegroundColour()); |
1149 | dc.SetTextBackground(GetBackgroundColour()); | |
2ef31e80 | 1150 | } |
4f6aed9c VZ |
1151 | |
1152 | if ( changedFont ) | |
1153 | { | |
ab473127 | 1154 | dc.SetFont(GetFont()); |
4f6aed9c | 1155 | } |
2ef31e80 VZ |
1156 | } |
1157 | //else: just don't draw it | |
1158 | ||
1159 | date += wxDateSpan::Day(); | |
1160 | } | |
2ef31e80 | 1161 | } |
37df1f33 VZ |
1162 | |
1163 | // Greying out out-of-range background | |
1164 | bool showSurrounding = (GetWindowStyle() & wxCAL_SHOW_SURROUNDING_WEEKS) != 0; | |
1165 | ||
1166 | date = ( showSurrounding ) ? GetStartDate() : wxDateTime(1, m_date.GetMonth(), m_date.GetYear()); | |
1167 | if ( !IsDateInRange(date) ) | |
1168 | { | |
1169 | wxDateTime firstOOR = GetLowerDateLimit() - wxDateSpan::Day(); // first out-of-range | |
1170 | ||
1171 | wxBrush oorbrush = *wxLIGHT_GREY_BRUSH; | |
1172 | oorbrush.SetStyle(wxFDIAGONAL_HATCH); | |
1173 | ||
1174 | HighlightRange(&dc, date, firstOOR, wxTRANSPARENT_PEN, &oorbrush); | |
1175 | } | |
1176 | ||
1177 | date = ( showSurrounding ) ? GetStartDate() + wxDateSpan::Weeks(6) - wxDateSpan::Day() : wxDateTime().SetToLastMonthDay(m_date.GetMonth(), m_date.GetYear()); | |
1178 | if ( !IsDateInRange(date) ) | |
1179 | { | |
1180 | wxDateTime firstOOR = GetUpperDateLimit() + wxDateSpan::Day(); // first out-of-range | |
1bcf0c7d | 1181 | |
37df1f33 VZ |
1182 | wxBrush oorbrush = *wxLIGHT_GREY_BRUSH; |
1183 | oorbrush.SetStyle(wxFDIAGONAL_HATCH); | |
1184 | ||
1185 | HighlightRange(&dc, firstOOR, date, wxTRANSPARENT_PEN, &oorbrush); | |
1186 | } | |
1187 | ||
882a8f40 | 1188 | #if DEBUG_PAINT |
f6bcfd97 | 1189 | wxLogDebug("+++ finished painting"); |
882a8f40 | 1190 | #endif |
9d9b7755 VZ |
1191 | } |
1192 | ||
1193 | void wxCalendarCtrl::RefreshDate(const wxDateTime& date) | |
1194 | { | |
1195 | RecalcGeometry(); | |
1196 | ||
1197 | wxRect rect; | |
1198 | ||
1199 | // always refresh the whole row at once because our OnPaint() will draw | |
1200 | // the whole row anyhow - and this allows the small optimisation in | |
1201 | // OnClick() below to work | |
1202 | rect.x = 0; | |
37df1f33 VZ |
1203 | |
1204 | rect.y = (m_heightRow * GetWeek(date)) + m_rowOffset; | |
1205 | ||
9d9b7755 VZ |
1206 | rect.width = 7*m_widthCol; |
1207 | rect.height = m_heightRow; | |
1208 | ||
f6bcfd97 BP |
1209 | #ifdef __WXMSW__ |
1210 | // VZ: for some reason, the selected date seems to occupy more space under | |
1211 | // MSW - this is probably some bug in the font size calculations, but I | |
1212 | // don't know where exactly. This fix is ugly and leads to more | |
1213 | // refreshes than really needed, but without it the selected days | |
1214 | // leaves even more ugly underscores on screen. | |
1215 | rect.Inflate(0, 1); | |
1216 | #endif // MSW | |
1217 | ||
882a8f40 | 1218 | #if DEBUG_PAINT |
f6bcfd97 | 1219 | wxLogDebug("*** refreshing week %d at (%d, %d)-(%d, %d)\n", |
9d9b7755 VZ |
1220 | GetWeek(date), |
1221 | rect.x, rect.y, | |
1222 | rect.x + rect.width, rect.y + rect.height); | |
882a8f40 | 1223 | #endif |
9d9b7755 | 1224 | |
ca65c044 | 1225 | Refresh(true, &rect); |
2ef31e80 VZ |
1226 | } |
1227 | ||
37df1f33 VZ |
1228 | void wxCalendarCtrl::HighlightRange(wxPaintDC* pDC, const wxDateTime& fromdate, const wxDateTime& todate, wxPen* pPen, wxBrush* pBrush) |
1229 | { | |
1230 | // Highlights the given range using pen and brush | |
1231 | // Does nothing if todate < fromdate | |
1232 | ||
1233 | ||
1234 | #if DEBUG_PAINT | |
1235 | wxLogDebug("+++ HighlightRange: (%s) - (%s) +++", fromdate.Format("%d %m %Y"), todate.Format("%d %m %Y")); | |
1236 | #endif | |
1237 | ||
1238 | if ( todate >= fromdate ) | |
1239 | { | |
1240 | // do stuff | |
1241 | // date-coordinates | |
1bcf0c7d | 1242 | int fd, fw; |
37df1f33 VZ |
1243 | int td, tw; |
1244 | ||
1245 | // implicit: both dates must be currently shown - checked by GetDateCoord | |
1246 | if ( GetDateCoord(fromdate, &fd, &fw) && GetDateCoord(todate, &td, &tw) ) | |
1247 | { | |
1248 | #if DEBUG_PAINT | |
1249 | wxLogDebug("Highlight range: (%i, %i) - (%i, %i)", fd, fw, td, tw); | |
1250 | #endif | |
1251 | if ( ( (tw - fw) == 1 ) && ( td < fd ) ) | |
1252 | { | |
1253 | // special case: interval 7 days or less not in same week | |
1254 | // split in two seperate intervals | |
1255 | wxDateTime tfd = fromdate + wxDateSpan::Days(7-fd); | |
1256 | wxDateTime ftd = tfd + wxDateSpan::Day(); | |
1257 | #if DEBUG_PAINT | |
1258 | wxLogDebug("Highlight: Seperate segments"); | |
1259 | #endif | |
1260 | // draw seperately | |
1261 | HighlightRange(pDC, fromdate, tfd, pPen, pBrush); | |
1262 | HighlightRange(pDC, ftd, todate, pPen, pBrush); | |
1263 | } | |
1264 | else | |
1265 | { | |
1266 | int numpoints; | |
1267 | wxPoint corners[8]; // potentially 8 corners in polygon | |
1268 | ||
1269 | if ( fw == tw ) | |
1270 | { | |
1271 | // simple case: same week | |
1272 | numpoints = 4; | |
1273 | corners[0] = wxPoint((fd - 1) * m_widthCol, (fw * m_heightRow) + m_rowOffset); | |
1274 | corners[1] = wxPoint((fd - 1) * m_widthCol, ((fw + 1 ) * m_heightRow) + m_rowOffset); | |
1275 | corners[2] = wxPoint(td * m_widthCol, ((tw + 1) * m_heightRow) + m_rowOffset); | |
1276 | corners[3] = wxPoint(td * m_widthCol, (tw * m_heightRow) + m_rowOffset); | |
1277 | } | |
1278 | else | |
1279 | { | |
1280 | int cidx = 0; | |
1281 | // "complex" polygon | |
1282 | corners[cidx] = wxPoint((fd - 1) * m_widthCol, (fw * m_heightRow) + m_rowOffset); cidx++; | |
1bcf0c7d | 1283 | |
37df1f33 VZ |
1284 | if ( fd > 1 ) |
1285 | { | |
1286 | corners[cidx] = wxPoint((fd - 1) * m_widthCol, ((fw + 1) * m_heightRow) + m_rowOffset); cidx++; | |
1287 | corners[cidx] = wxPoint(0, ((fw + 1) * m_heightRow) + m_rowOffset); cidx++; | |
1288 | } | |
1289 | ||
1290 | corners[cidx] = wxPoint(0, ((tw + 1) * m_heightRow) + m_rowOffset); cidx++; | |
1291 | corners[cidx] = wxPoint(td * m_widthCol, ((tw + 1) * m_heightRow) + m_rowOffset); cidx++; | |
1292 | ||
1293 | if ( td < 7 ) | |
1294 | { | |
1295 | corners[cidx] = wxPoint(td * m_widthCol, (tw * m_heightRow) + m_rowOffset); cidx++; | |
1296 | corners[cidx] = wxPoint(7 * m_widthCol, (tw * m_heightRow) + m_rowOffset); cidx++; | |
1297 | } | |
1298 | ||
1299 | corners[cidx] = wxPoint(7 * m_widthCol, (fw * m_heightRow) + m_rowOffset); cidx++; | |
1bcf0c7d | 1300 | |
37df1f33 VZ |
1301 | numpoints = cidx; |
1302 | } | |
1303 | ||
1304 | // draw the polygon | |
1305 | pDC->SetBrush(*pBrush); | |
1306 | pDC->SetPen(*pPen); | |
1307 | pDC->DrawPolygon(numpoints, corners); | |
1308 | } | |
1309 | } | |
1310 | } | |
1311 | // else do nothing | |
1312 | #if DEBUG_PAINT | |
1313 | wxLogDebug("--- HighlightRange ---"); | |
1314 | #endif | |
1315 | } | |
1316 | ||
1317 | bool wxCalendarCtrl::GetDateCoord(const wxDateTime& date, int *day, int *week) const | |
1318 | { | |
ca65c044 | 1319 | bool retval = true; |
37df1f33 VZ |
1320 | |
1321 | #if DEBUG_PAINT | |
1322 | wxLogDebug("+++ GetDateCoord: (%s) +++", date.Format("%d %m %Y")); | |
1323 | #endif | |
1324 | ||
1325 | if ( IsDateShown(date) ) | |
1326 | { | |
1327 | bool startOnMonday = ( GetWindowStyle() & wxCAL_MONDAY_FIRST ) != 0; | |
1bcf0c7d | 1328 | |
37df1f33 VZ |
1329 | // Find day |
1330 | *day = date.GetWeekDay(); | |
1bcf0c7d | 1331 | |
37df1f33 VZ |
1332 | if ( *day == 0 ) // sunday |
1333 | { | |
1334 | *day = ( startOnMonday ) ? 7 : 1; | |
1335 | } | |
1336 | else | |
1337 | { | |
999836aa | 1338 | *day += ( startOnMonday ) ? 0 : 1; |
37df1f33 VZ |
1339 | } |
1340 | ||
1341 | int targetmonth = date.GetMonth() + (12 * date.GetYear()); | |
1342 | int thismonth = m_date.GetMonth() + (12 * m_date.GetYear()); | |
1343 | ||
1344 | // Find week | |
1345 | if ( targetmonth == thismonth ) | |
1346 | { | |
1347 | *week = GetWeek(date); | |
1348 | } | |
1349 | else | |
1350 | { | |
1351 | if ( targetmonth < thismonth ) | |
1352 | { | |
1353 | *week = 1; // trivial | |
1354 | } | |
1355 | else // targetmonth > thismonth | |
1356 | { | |
1357 | wxDateTime ldcm; | |
1358 | int lastweek; | |
1359 | int lastday; | |
1360 | ||
1361 | // get the datecoord of the last day in the month currently shown | |
1362 | #if DEBUG_PAINT | |
1363 | wxLogDebug(" +++ LDOM +++"); | |
1364 | #endif | |
1365 | GetDateCoord(ldcm.SetToLastMonthDay(m_date.GetMonth(), m_date.GetYear()), &lastday, &lastweek); | |
1366 | #if DEBUG_PAINT | |
1367 | wxLogDebug(" --- LDOM ---"); | |
1368 | #endif | |
1369 | ||
1370 | wxTimeSpan span = date - ldcm; | |
1371 | ||
1372 | int daysfromlast = span.GetDays(); | |
1373 | #if DEBUG_PAINT | |
1374 | wxLogDebug("daysfromlast: %i", daysfromlast); | |
1375 | #endif | |
1376 | if ( daysfromlast + lastday > 7 ) // past week boundary | |
1377 | { | |
1378 | int wholeweeks = (daysfromlast / 7); | |
1379 | *week = wholeweeks + lastweek; | |
1380 | if ( (daysfromlast - (7 * wholeweeks) + lastday) > 7 ) | |
1381 | { | |
1382 | *week += 1; | |
1383 | } | |
1384 | } | |
1385 | else | |
1386 | { | |
1387 | *week = lastweek; | |
1388 | } | |
1389 | } | |
1390 | } | |
1391 | } | |
1392 | else | |
1393 | { | |
1394 | *day = -1; | |
1395 | *week = -1; | |
ca65c044 | 1396 | retval = false; |
37df1f33 VZ |
1397 | } |
1398 | ||
1399 | #if DEBUG_PAINT | |
1400 | wxLogDebug("--- GetDateCoord: (%s) = (%i, %i) ---", date.Format("%d %m %Y"), *day, *week); | |
1401 | #endif | |
1402 | ||
1403 | return retval; | |
1404 | } | |
1405 | ||
2ef31e80 VZ |
1406 | // ---------------------------------------------------------------------------- |
1407 | // mouse handling | |
1408 | // ---------------------------------------------------------------------------- | |
1409 | ||
0185cd09 | 1410 | void wxCalendarCtrl::OnDClick(wxMouseEvent& event) |
2ef31e80 | 1411 | { |
0185cd09 | 1412 | if ( HitTest(event.GetPosition()) != wxCAL_HITTEST_DAY ) |
2ef31e80 VZ |
1413 | { |
1414 | event.Skip(); | |
1415 | } | |
1416 | else | |
1417 | { | |
4f6aed9c | 1418 | GenerateEvent(wxEVT_CALENDAR_DOUBLECLICKED); |
0185cd09 VZ |
1419 | } |
1420 | } | |
1421 | ||
1422 | void wxCalendarCtrl::OnClick(wxMouseEvent& event) | |
1423 | { | |
1424 | wxDateTime date; | |
1425 | wxDateTime::WeekDay wday; | |
1426 | switch ( HitTest(event.GetPosition(), &date, &wday) ) | |
1427 | { | |
1428 | case wxCAL_HITTEST_DAY: | |
37df1f33 VZ |
1429 | if ( IsDateInRange(date) ) |
1430 | { | |
1431 | ChangeDay(date); | |
2ef31e80 | 1432 | |
37df1f33 VZ |
1433 | GenerateEvents(wxEVT_CALENDAR_DAY_CHANGED, |
1434 | wxEVT_CALENDAR_SEL_CHANGED); | |
1435 | } | |
0185cd09 VZ |
1436 | break; |
1437 | ||
1438 | case wxCAL_HITTEST_HEADER: | |
1439 | { | |
1440 | wxCalendarEvent event(this, wxEVT_CALENDAR_WEEKDAY_CLICKED); | |
1441 | event.m_wday = wday; | |
1442 | (void)GetEventHandler()->ProcessEvent(event); | |
1443 | } | |
1444 | break; | |
1445 | ||
37df1f33 VZ |
1446 | case wxCAL_HITTEST_DECMONTH: |
1447 | case wxCAL_HITTEST_INCMONTH: | |
1448 | case wxCAL_HITTEST_SURROUNDING_WEEK: | |
1449 | SetDateAndNotify(date); // we probably only want to refresh the control. No notification.. (maybe as an option?) | |
1450 | break; | |
1451 | ||
0185cd09 VZ |
1452 | default: |
1453 | wxFAIL_MSG(_T("unknown hittest code")); | |
1454 | // fall through | |
1455 | ||
1456 | case wxCAL_HITTEST_NOWHERE: | |
1457 | event.Skip(); | |
1458 | break; | |
2ef31e80 VZ |
1459 | } |
1460 | } | |
1461 | ||
0185cd09 VZ |
1462 | wxCalendarHitTestResult wxCalendarCtrl::HitTest(const wxPoint& pos, |
1463 | wxDateTime *date, | |
1464 | wxDateTime::WeekDay *wd) | |
2ef31e80 | 1465 | { |
9d9b7755 VZ |
1466 | RecalcGeometry(); |
1467 | ||
2ef31e80 | 1468 | wxCoord y = pos.y; |
37df1f33 VZ |
1469 | |
1470 | /////////////////////////////////////////////////////////////////////////////////////////////////////// | |
1471 | if ( (GetWindowStyle() & wxCAL_SEQUENTIAL_MONTH_SELECTION) ) | |
0185cd09 | 1472 | { |
37df1f33 | 1473 | // Header: month |
1bcf0c7d | 1474 | |
37df1f33 VZ |
1475 | // we need to find out if the hit is on left arrow, on month or on right arrow |
1476 | // left arrow? | |
1477 | if ( wxRegion(m_leftArrowRect).Contains(pos) == wxInRegion ) | |
0185cd09 | 1478 | { |
37df1f33 | 1479 | if ( date ) |
0185cd09 | 1480 | { |
37df1f33 VZ |
1481 | if ( IsDateInRange(m_date - wxDateSpan::Month()) ) |
1482 | { | |
1483 | *date = m_date - wxDateSpan::Month(); | |
1484 | } | |
1485 | else | |
1486 | { | |
1487 | *date = GetLowerDateLimit(); | |
1488 | } | |
1489 | } | |
1490 | ||
1491 | return wxCAL_HITTEST_DECMONTH; | |
1492 | } | |
1493 | ||
1494 | if ( wxRegion(m_rightArrowRect).Contains(pos) == wxInRegion ) | |
1495 | { | |
1496 | if ( date ) | |
1497 | { | |
1498 | if ( IsDateInRange(m_date + wxDateSpan::Month()) ) | |
1499 | { | |
1500 | *date = m_date + wxDateSpan::Month(); | |
1501 | } | |
1502 | else | |
1503 | { | |
1504 | *date = GetUpperDateLimit(); | |
1505 | } | |
0185cd09 VZ |
1506 | } |
1507 | ||
37df1f33 | 1508 | return wxCAL_HITTEST_INCMONTH; |
0185cd09 | 1509 | } |
2ef31e80 | 1510 | |
0185cd09 | 1511 | } |
2ef31e80 | 1512 | |
37df1f33 VZ |
1513 | /////////////////////////////////////////////////////////////////////////////////////////////////////// |
1514 | // Header: Days | |
1515 | int wday = pos.x / m_widthCol; | |
1516 | // if ( y < m_heightRow ) | |
1517 | if ( y < (m_heightRow + m_rowOffset) ) | |
1518 | { | |
1519 | if ( y > m_rowOffset ) | |
1520 | { | |
1521 | if ( wd ) | |
1522 | { | |
1523 | if ( GetWindowStyle() & wxCAL_MONDAY_FIRST ) | |
1524 | { | |
1525 | wday = wday == 6 ? 0 : wday + 1; | |
1526 | } | |
1527 | ||
1528 | *wd = (wxDateTime::WeekDay)wday; | |
1529 | } | |
1530 | ||
1531 | return wxCAL_HITTEST_HEADER; | |
1532 | } | |
1533 | else | |
1534 | { | |
1535 | return wxCAL_HITTEST_NOWHERE; | |
1536 | } | |
1537 | } | |
1538 | ||
1539 | // int week = (y - m_heightRow) / m_heightRow; | |
1540 | int week = (y - (m_heightRow + m_rowOffset)) / m_heightRow; | |
2ef31e80 | 1541 | if ( week >= 6 || wday >= 7 ) |
0185cd09 VZ |
1542 | { |
1543 | return wxCAL_HITTEST_NOWHERE; | |
1544 | } | |
2ef31e80 | 1545 | |
0185cd09 | 1546 | wxDateTime dt = GetStartDate() + wxDateSpan::Days(7*week + wday); |
2ef31e80 | 1547 | |
0185cd09 VZ |
1548 | if ( IsDateShown(dt) ) |
1549 | { | |
1550 | if ( date ) | |
1551 | *date = dt; | |
9d9b7755 | 1552 | |
37df1f33 VZ |
1553 | if ( dt.GetMonth() == m_date.GetMonth() ) |
1554 | { | |
1555 | ||
1556 | return wxCAL_HITTEST_DAY; | |
1557 | } | |
1558 | else | |
1559 | { | |
1560 | return wxCAL_HITTEST_SURROUNDING_WEEK; | |
1561 | } | |
0185cd09 VZ |
1562 | } |
1563 | else | |
1564 | { | |
1565 | return wxCAL_HITTEST_NOWHERE; | |
1566 | } | |
2ef31e80 | 1567 | } |
9d9b7755 VZ |
1568 | |
1569 | // ---------------------------------------------------------------------------- | |
1570 | // subcontrols events handling | |
1571 | // ---------------------------------------------------------------------------- | |
1572 | ||
1573 | void wxCalendarCtrl::OnMonthChange(wxCommandEvent& event) | |
1574 | { | |
1575 | wxDateTime::Tm tm = m_date.GetTm(); | |
1576 | ||
1577 | wxDateTime::Month mon = (wxDateTime::Month)event.GetInt(); | |
1578 | if ( tm.mday > wxDateTime::GetNumberOfDays(mon, tm.year) ) | |
1579 | { | |
1580 | tm.mday = wxDateTime::GetNumberOfDays(mon, tm.year); | |
1581 | } | |
1582 | ||
37df1f33 VZ |
1583 | wxDateTime target = wxDateTime(tm.mday, mon, tm.year); |
1584 | ||
1585 | ChangeMonth(&target); | |
1586 | SetDateAndNotify(target); | |
9d9b7755 VZ |
1587 | } |
1588 | ||
f0d5e7a2 | 1589 | void wxCalendarCtrl::OnYearChange(wxCommandEvent& event) |
9d9b7755 | 1590 | { |
f0d5e7a2 VZ |
1591 | int year = (int)event.GetInt(); |
1592 | if ( year == INT_MIN ) | |
1593 | { | |
1594 | // invalid year in the spin control, ignore it | |
1595 | return; | |
1596 | } | |
1597 | ||
9d9b7755 VZ |
1598 | wxDateTime::Tm tm = m_date.GetTm(); |
1599 | ||
9d9b7755 VZ |
1600 | if ( tm.mday > wxDateTime::GetNumberOfDays(tm.mon, year) ) |
1601 | { | |
1602 | tm.mday = wxDateTime::GetNumberOfDays(tm.mon, year); | |
1603 | } | |
1bcf0c7d | 1604 | |
37df1f33 VZ |
1605 | wxDateTime target = wxDateTime(tm.mday, tm.mon, year); |
1606 | ||
1607 | if ( ChangeYear(&target) ) | |
1608 | { | |
1609 | SetDateAndNotify(target); | |
1610 | } | |
1611 | else | |
1612 | { | |
1613 | // In this case we don't want to change the date. That would put us | |
1614 | // inside the same year but a strange number of months forward/back.. | |
1615 | m_spinYear->SetValue(target.GetYear()); | |
1616 | } | |
9d9b7755 VZ |
1617 | } |
1618 | ||
1619 | // ---------------------------------------------------------------------------- | |
1620 | // keyboard interface | |
1621 | // ---------------------------------------------------------------------------- | |
1622 | ||
1623 | void wxCalendarCtrl::OnChar(wxKeyEvent& event) | |
1624 | { | |
37df1f33 | 1625 | wxDateTime target; |
12a3f227 | 1626 | switch ( event.GetKeyCode() ) |
9d9b7755 VZ |
1627 | { |
1628 | case _T('+'): | |
1629 | case WXK_ADD: | |
37df1f33 VZ |
1630 | target = m_date + wxDateSpan::Year(); |
1631 | if ( ChangeYear(&target) ) | |
1632 | { | |
1633 | SetDateAndNotify(target); | |
1634 | } | |
9d9b7755 VZ |
1635 | break; |
1636 | ||
1637 | case _T('-'): | |
1638 | case WXK_SUBTRACT: | |
37df1f33 VZ |
1639 | target = m_date - wxDateSpan::Year(); |
1640 | if ( ChangeYear(&target) ) | |
1641 | { | |
1642 | SetDateAndNotify(target); | |
1643 | } | |
9d9b7755 VZ |
1644 | break; |
1645 | ||
882a8f40 | 1646 | case WXK_PRIOR: |
37df1f33 VZ |
1647 | target = m_date - wxDateSpan::Month(); |
1648 | ChangeMonth(&target); | |
1649 | SetDateAndNotify(target); // always | |
9d9b7755 VZ |
1650 | break; |
1651 | ||
882a8f40 | 1652 | case WXK_NEXT: |
37df1f33 VZ |
1653 | target = m_date + wxDateSpan::Month(); |
1654 | ChangeMonth(&target); | |
1655 | SetDateAndNotify(target); // always | |
9d9b7755 VZ |
1656 | break; |
1657 | ||
1658 | case WXK_RIGHT: | |
1a8557b1 | 1659 | if ( event.ControlDown() ) |
37df1f33 VZ |
1660 | { |
1661 | target = wxDateTime(m_date).SetToNextWeekDay( | |
1a8557b1 | 1662 | GetWindowStyle() & wxCAL_MONDAY_FIRST |
37df1f33 VZ |
1663 | ? wxDateTime::Sun : wxDateTime::Sat); |
1664 | if ( !IsDateInRange(target) ) | |
1665 | { | |
1666 | target = GetUpperDateLimit(); | |
1667 | } | |
1668 | SetDateAndNotify(target); | |
1669 | } | |
1a8557b1 VZ |
1670 | else |
1671 | SetDateAndNotify(m_date + wxDateSpan::Day()); | |
9d9b7755 VZ |
1672 | break; |
1673 | ||
1674 | case WXK_LEFT: | |
1a8557b1 | 1675 | if ( event.ControlDown() ) |
37df1f33 VZ |
1676 | { |
1677 | target = wxDateTime(m_date).SetToPrevWeekDay( | |
1a8557b1 | 1678 | GetWindowStyle() & wxCAL_MONDAY_FIRST |
37df1f33 VZ |
1679 | ? wxDateTime::Mon : wxDateTime::Sun); |
1680 | if ( !IsDateInRange(target) ) | |
1681 | { | |
1682 | target = GetLowerDateLimit(); | |
1683 | } | |
1684 | SetDateAndNotify(target); | |
1685 | } | |
1a8557b1 VZ |
1686 | else |
1687 | SetDateAndNotify(m_date - wxDateSpan::Day()); | |
9d9b7755 VZ |
1688 | break; |
1689 | ||
1690 | case WXK_UP: | |
1691 | SetDateAndNotify(m_date - wxDateSpan::Week()); | |
1692 | break; | |
1693 | ||
1694 | case WXK_DOWN: | |
1695 | SetDateAndNotify(m_date + wxDateSpan::Week()); | |
1696 | break; | |
1697 | ||
1698 | case WXK_HOME: | |
1a8557b1 VZ |
1699 | if ( event.ControlDown() ) |
1700 | SetDateAndNotify(wxDateTime::Today()); | |
1701 | else | |
1702 | SetDateAndNotify(wxDateTime(1, m_date.GetMonth(), m_date.GetYear())); | |
1703 | break; | |
1704 | ||
1705 | case WXK_END: | |
1706 | SetDateAndNotify(wxDateTime(m_date).SetToLastMonthDay()); | |
9d9b7755 VZ |
1707 | break; |
1708 | ||
4f6aed9c VZ |
1709 | case WXK_RETURN: |
1710 | GenerateEvent(wxEVT_CALENDAR_DOUBLECLICKED); | |
1711 | break; | |
1712 | ||
9d9b7755 VZ |
1713 | default: |
1714 | event.Skip(); | |
1715 | } | |
1716 | } | |
1717 | ||
1718 | // ---------------------------------------------------------------------------- | |
4f6aed9c | 1719 | // holidays handling |
9d9b7755 VZ |
1720 | // ---------------------------------------------------------------------------- |
1721 | ||
4f6aed9c | 1722 | void wxCalendarCtrl::EnableHolidayDisplay(bool display) |
9d9b7755 | 1723 | { |
4f6aed9c VZ |
1724 | long style = GetWindowStyle(); |
1725 | if ( display ) | |
1726 | style |= wxCAL_SHOW_HOLIDAYS; | |
1727 | else | |
1728 | style &= ~wxCAL_SHOW_HOLIDAYS; | |
1729 | ||
1730 | SetWindowStyle(style); | |
1731 | ||
1732 | if ( display ) | |
1733 | SetHolidayAttrs(); | |
1734 | else | |
1735 | ResetHolidayAttrs(); | |
1736 | ||
1737 | Refresh(); | |
1738 | } | |
1739 | ||
1740 | void wxCalendarCtrl::SetHolidayAttrs() | |
1741 | { | |
1742 | if ( GetWindowStyle() & wxCAL_SHOW_HOLIDAYS ) | |
1743 | { | |
1744 | ResetHolidayAttrs(); | |
1745 | ||
1746 | wxDateTime::Tm tm = m_date.GetTm(); | |
1747 | wxDateTime dtStart(1, tm.mon, tm.year), | |
1748 | dtEnd = dtStart.GetLastMonthDay(); | |
1749 | ||
1750 | wxDateTimeArray hol; | |
1751 | wxDateTimeHolidayAuthority::GetHolidaysInRange(dtStart, dtEnd, hol); | |
1752 | ||
1753 | size_t count = hol.GetCount(); | |
1754 | for ( size_t n = 0; n < count; n++ ) | |
1755 | { | |
1756 | SetHoliday(hol[n].GetDay()); | |
1757 | } | |
1758 | } | |
1759 | } | |
1760 | ||
1761 | void wxCalendarCtrl::SetHoliday(size_t day) | |
1762 | { | |
1763 | wxCHECK_RET( day > 0 && day < 32, _T("invalid day in SetHoliday") ); | |
0185cd09 | 1764 | |
4f6aed9c VZ |
1765 | wxCalendarDateAttr *attr = GetAttr(day); |
1766 | if ( !attr ) | |
0185cd09 | 1767 | { |
4f6aed9c VZ |
1768 | attr = new wxCalendarDateAttr; |
1769 | } | |
0185cd09 | 1770 | |
ca65c044 | 1771 | attr->SetHoliday(true); |
4f6aed9c VZ |
1772 | |
1773 | // can't use SetAttr() because it would delete this pointer | |
1774 | m_attrs[day - 1] = attr; | |
1775 | } | |
1776 | ||
1777 | void wxCalendarCtrl::ResetHolidayAttrs() | |
1778 | { | |
1779 | for ( size_t day = 0; day < 31; day++ ) | |
1780 | { | |
1781 | if ( m_attrs[day] ) | |
1782 | { | |
ca65c044 | 1783 | m_attrs[day]->SetHoliday(false); |
4f6aed9c | 1784 | } |
0185cd09 VZ |
1785 | } |
1786 | } | |
1787 | ||
ab473127 RD |
1788 | |
1789 | //static | |
1790 | wxVisualAttributes | |
1791 | wxCalendarCtrl::GetClassDefaultAttributes(wxWindowVariant variant) | |
1792 | { | |
1793 | // Use the same color scheme as wxListBox | |
1794 | return wxListBox::GetClassDefaultAttributes(variant); | |
1795 | } | |
1796 | ||
1e6feb95 | 1797 | #endif // wxUSE_CALENDARCTRL |
2fa7c206 | 1798 |