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