1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: src/generic/calctrlg.cpp
3 // Purpose: implementation of the wxGenericCalendarCtrl
4 // Author: Vadim Zeitlin
8 // Copyright: (c) 1999 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
9 // Licence: wxWindows licence
10 ///////////////////////////////////////////////////////////////////////////////
12 // ============================================================================
14 // ============================================================================
16 // ----------------------------------------------------------------------------
18 // ----------------------------------------------------------------------------
20 // For compilers that support precompilation, includes "wx.h".
21 #include "wx/wxprec.h"
28 #include "wx/dcclient.h"
29 #include "wx/settings.h"
31 #include "wx/combobox.h"
32 #include "wx/listbox.h"
33 #include "wx/stattext.h"
34 #include "wx/textctrl.h"
38 #if wxUSE_CALENDARCTRL
40 #include "wx/spinctrl.h"
41 #include "wx/calctrl.h"
42 #include "wx/generic/calctrlg.h"
46 // ----------------------------------------------------------------------------
48 // ----------------------------------------------------------------------------
50 BEGIN_EVENT_TABLE(wxGenericCalendarCtrl
, wxControl
)
51 EVT_PAINT(wxGenericCalendarCtrl
::OnPaint
)
53 EVT_CHAR(wxGenericCalendarCtrl
::OnChar
)
55 EVT_LEFT_DOWN(wxGenericCalendarCtrl
::OnClick
)
56 EVT_LEFT_DCLICK(wxGenericCalendarCtrl
::OnDClick
)
58 EVT_SYS_COLOUR_CHANGED(wxGenericCalendarCtrl
::OnSysColourChanged
)
61 #if wxUSE_EXTENDED_RTTI
62 WX_DEFINE_FLAGS( wxCalendarCtrlStyle
)
64 wxBEGIN_FLAGS( wxCalendarCtrlStyle
)
65 // new style border flags, we put them first to
66 // use them for streaming out
67 wxFLAGS_MEMBER(wxBORDER_SIMPLE
)
68 wxFLAGS_MEMBER(wxBORDER_SUNKEN
)
69 wxFLAGS_MEMBER(wxBORDER_DOUBLE
)
70 wxFLAGS_MEMBER(wxBORDER_RAISED
)
71 wxFLAGS_MEMBER(wxBORDER_STATIC
)
72 wxFLAGS_MEMBER(wxBORDER_NONE
)
74 // old style border flags
75 wxFLAGS_MEMBER(wxSIMPLE_BORDER
)
76 wxFLAGS_MEMBER(wxSUNKEN_BORDER
)
77 wxFLAGS_MEMBER(wxDOUBLE_BORDER
)
78 wxFLAGS_MEMBER(wxRAISED_BORDER
)
79 wxFLAGS_MEMBER(wxSTATIC_BORDER
)
80 wxFLAGS_MEMBER(wxBORDER
)
82 // standard window styles
83 wxFLAGS_MEMBER(wxTAB_TRAVERSAL
)
84 wxFLAGS_MEMBER(wxCLIP_CHILDREN
)
85 wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW
)
86 wxFLAGS_MEMBER(wxWANTS_CHARS
)
87 wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE
)
88 wxFLAGS_MEMBER(wxALWAYS_SHOW_SB
)
89 wxFLAGS_MEMBER(wxVSCROLL
)
90 wxFLAGS_MEMBER(wxHSCROLL
)
92 wxFLAGS_MEMBER(wxCAL_SUNDAY_FIRST
)
93 wxFLAGS_MEMBER(wxCAL_MONDAY_FIRST
)
94 wxFLAGS_MEMBER(wxCAL_SHOW_HOLIDAYS
)
95 wxFLAGS_MEMBER(wxCAL_NO_YEAR_CHANGE
)
96 wxFLAGS_MEMBER(wxCAL_NO_MONTH_CHANGE
)
97 wxFLAGS_MEMBER(wxCAL_SEQUENTIAL_MONTH_SELECTION
)
98 wxFLAGS_MEMBER(wxCAL_SHOW_SURROUNDING_WEEKS
)
100 wxEND_FLAGS( wxCalendarCtrlStyle
)
102 IMPLEMENT_DYNAMIC_CLASS_XTI(wxGenericCalendarCtrl
, wxControl
,"wx/calctrl.h")
104 wxBEGIN_PROPERTIES_TABLE(wxGenericCalendarCtrl
)
105 wxEVENT_RANGE_PROPERTY( Updated
, wxEVT_CALENDAR_SEL_CHANGED
, wxEVT_CALENDAR_WEEKDAY_CLICKED
, wxCalendarEvent
)
106 wxHIDE_PROPERTY( Children
)
107 wxPROPERTY( Date
,wxDateTime
, SetDate
, GetDate
, , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
108 wxPROPERTY_FLAGS( WindowStyle
, wxCalendarCtrlStyle
, long , SetWindowStyleFlag
, GetWindowStyleFlag
, , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
109 wxEND_PROPERTIES_TABLE()
111 wxBEGIN_HANDLERS_TABLE(wxGenericCalendarCtrl
)
112 wxEND_HANDLERS_TABLE()
114 wxCONSTRUCTOR_6( wxGenericCalendarCtrl
, wxWindow
* , Parent
, wxWindowID
, Id
, wxDateTime
, Date
, wxPoint
, Position
, wxSize
, Size
, long , WindowStyle
)
116 IMPLEMENT_DYNAMIC_CLASS(wxGenericCalendarCtrl
, wxControl
)
119 // ============================================================================
121 // ============================================================================
123 // ----------------------------------------------------------------------------
125 // ----------------------------------------------------------------------------
130 // add attributes that are set in attr
131 void AddAttr(wxCalendarDateAttr
*self
, const wxCalendarDateAttr
& attr
)
133 if (attr
.HasTextColour())
134 self
->SetTextColour(attr
.GetTextColour());
135 if (attr
.HasBackgroundColour())
136 self
->SetBackgroundColour(attr
.GetBackgroundColour());
137 if (attr
.HasBorderColour())
138 self
->SetBorderColour(attr
.GetBorderColour());
140 self
->SetFont(attr
.GetFont());
141 if (attr
.HasBorder())
142 self
->SetBorder(attr
.GetBorder());
143 if (attr
.IsHoliday())
144 self
->SetHoliday(true);
147 // remove attributes that are set in attr
148 void DelAttr(wxCalendarDateAttr
*self
, const wxCalendarDateAttr
&attr
)
150 if (attr
.HasTextColour())
151 self
->SetTextColour(wxNullColour
);
152 if (attr
.HasBackgroundColour())
153 self
->SetBackgroundColour(wxNullColour
);
154 if (attr
.HasBorderColour())
155 self
->SetBorderColour(wxNullColour
);
157 self
->SetFont(wxNullFont
);
158 if (attr
.HasBorder())
159 self
->SetBorder(wxCAL_BORDER_NONE
);
160 if (attr
.IsHoliday())
161 self
->SetHoliday(false);
164 } // anonymous namespace
166 // ----------------------------------------------------------------------------
167 // wxGenericCalendarCtrl
168 // ----------------------------------------------------------------------------
170 wxGenericCalendarCtrl
::wxGenericCalendarCtrl(wxWindow
*parent
,
172 const wxDateTime
& date
,
176 const wxString
& name
)
180 (void)Create(parent
, id
, date
, pos
, size
, style
, name
);
183 void wxGenericCalendarCtrl
::Init()
188 m_staticMonth
= NULL
;
190 m_userChangedYear
= false;
195 wxDateTime
::WeekDay wd
;
196 for ( wd
= wxDateTime
::Sun
; wd
< wxDateTime
::Inv_WeekDay
; wxNextWDay(wd
) )
198 m_weekdays
[wd
] = wxDateTime
::GetWeekDayName(wd
, wxDateTime
::Name_Abbr
);
201 for ( size_t n
= 0; n
< WXSIZEOF(m_attrs
); n
++ )
209 void wxGenericCalendarCtrl
::InitColours()
211 m_colHighlightFg
= wxSystemSettings
::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT
);
212 m_colHighlightBg
= wxSystemSettings
::GetColour(wxSYS_COLOUR_HIGHLIGHT
);
213 m_colBackground
= wxSystemSettings
::GetColour(wxSYS_COLOUR_WINDOW
);
214 m_colSurrounding
= wxSystemSettings
::GetColour(wxSYS_COLOUR_GRAYTEXT
);
216 m_colHolidayFg
= *wxRED
;
217 // don't set m_colHolidayBg - by default, same as our bg colour
219 m_colHeaderFg
= *wxBLUE
;
220 m_colHeaderBg
= *wxLIGHT_GREY
;
223 bool wxGenericCalendarCtrl
::Create(wxWindow
*parent
,
225 const wxDateTime
& date
,
229 const wxString
& name
)
231 if ( !wxControl
::Create(parent
, id
, pos
, size
,
232 style
| wxCLIP_CHILDREN
| wxWANTS_CHARS
| wxFULL_REPAINT_ON_RESIZE
,
233 wxDefaultValidator
, name
) )
238 // needed to get the arrow keys normally used for the dialog navigation
239 SetWindowStyle(style
| wxWANTS_CHARS
);
241 m_date
= date
.IsValid() ? date
: wxDateTime
::Today();
243 m_lowdate
= wxDefaultDateTime
;
244 m_highdate
= wxDefaultDateTime
;
246 if ( !HasFlag(wxCAL_SEQUENTIAL_MONTH_SELECTION
) )
248 CreateYearSpinCtrl();
249 m_staticYear
= new wxStaticText(GetParent(), wxID_ANY
, m_date
.Format(_T("%Y")),
250 wxDefaultPosition
, wxDefaultSize
,
252 CreateMonthComboBox();
253 m_staticMonth
= new wxStaticText(GetParent(), wxID_ANY
, m_date
.Format(_T("%B")),
254 wxDefaultPosition
, wxDefaultSize
,
258 ShowCurrentControls();
260 // we need to set the position as well because the main control position
261 // is not the same as the one specified in pos if we have the controls
263 SetInitialSize(size
);
266 // Since we don't paint the whole background make sure that the platform
267 // will use the right one.
268 SetBackgroundColour(m_colBackground
);
275 wxGenericCalendarCtrl
::~wxGenericCalendarCtrl()
277 for ( size_t n
= 0; n
< WXSIZEOF(m_attrs
); n
++ )
282 if ( !HasFlag(wxCAL_SEQUENTIAL_MONTH_SELECTION
) )
285 delete m_staticMonth
;
291 void wxGenericCalendarCtrl
::SetWindowStyleFlag(long style
)
293 // changing this style doesn't work because the controls are not
294 // created/shown/hidden accordingly
295 wxASSERT_MSG( (style
& wxCAL_SEQUENTIAL_MONTH_SELECTION
) ==
296 (m_windowStyle
& wxCAL_SEQUENTIAL_MONTH_SELECTION
),
297 _T("wxCAL_SEQUENTIAL_MONTH_SELECTION can't be changed after creation") );
299 wxControl
::SetWindowStyleFlag(style
);
302 // ----------------------------------------------------------------------------
303 // Create the wxComboBox and wxSpinCtrl
304 // ----------------------------------------------------------------------------
306 void wxGenericCalendarCtrl
::CreateMonthComboBox()
308 m_comboMonth
= new wxComboBox(GetParent(), wxID_ANY
,
313 wxCB_READONLY
| wxCLIP_SIBLINGS
);
316 for ( m
= wxDateTime
::Jan
; m
< wxDateTime
::Inv_Month
; wxNextMonth(m
) )
318 m_comboMonth
->Append(wxDateTime
::GetMonthName(m
));
321 m_comboMonth
->SetSelection(GetDate().GetMonth());
322 m_comboMonth
->SetSize(wxDefaultCoord
,
326 wxSIZE_AUTO_WIDTH
|wxSIZE_AUTO_HEIGHT
);
328 m_comboMonth
->Connect(m_comboMonth
->GetId(), wxEVT_COMMAND_COMBOBOX_SELECTED
,
329 wxCommandEventHandler(wxGenericCalendarCtrl
::OnMonthChange
),
333 void wxGenericCalendarCtrl
::CreateYearSpinCtrl()
335 m_spinYear
= new wxSpinCtrl(GetParent(), wxID_ANY
,
336 GetDate().Format(_T("%Y")),
339 wxSP_ARROW_KEYS
| wxCLIP_SIBLINGS
,
340 -4300, 10000, GetDate().GetYear());
342 m_spinYear
->SetSize( 90, -1 );
345 m_spinYear
->Connect(m_spinYear
->GetId(), wxEVT_COMMAND_TEXT_UPDATED
,
346 wxCommandEventHandler(wxGenericCalendarCtrl
::OnYearTextChange
),
349 m_spinYear
->Connect(m_spinYear
->GetId(), wxEVT_COMMAND_SPINCTRL_UPDATED
,
350 wxCommandEventHandler(wxGenericCalendarCtrl
::OnYearChange
),
354 // ----------------------------------------------------------------------------
355 // forward wxWin functions to subcontrols
356 // ----------------------------------------------------------------------------
358 bool wxGenericCalendarCtrl
::Destroy()
361 m_staticYear
->Destroy();
363 m_spinYear
->Destroy();
365 m_comboMonth
->Destroy();
367 m_staticMonth
->Destroy();
372 m_staticMonth
= NULL
;
374 return wxControl
::Destroy();
377 bool wxGenericCalendarCtrl
::Show(bool show
)
379 if ( !wxControl
::Show(show
) )
384 if ( !(GetWindowStyle() & wxCAL_SEQUENTIAL_MONTH_SELECTION
) )
386 if ( GetMonthControl() )
388 GetMonthControl()->Show(show
);
389 GetYearControl()->Show(show
);
396 bool wxGenericCalendarCtrl
::Enable(bool enable
)
398 if ( !wxControl
::Enable(enable
) )
403 if ( !(GetWindowStyle() & wxCAL_SEQUENTIAL_MONTH_SELECTION
) )
405 GetMonthControl()->Enable(enable
);
406 GetYearControl()->Enable(enable
);
412 // ----------------------------------------------------------------------------
413 // enable/disable month/year controls
414 // ----------------------------------------------------------------------------
416 void wxGenericCalendarCtrl
::ShowCurrentControls()
418 if ( !HasFlag(wxCAL_SEQUENTIAL_MONTH_SELECTION
) )
420 if ( AllowMonthChange() )
422 m_comboMonth
->Show();
423 m_staticMonth
->Hide();
425 if ( AllowYearChange() )
428 m_staticYear
->Hide();
436 m_comboMonth
->Hide();
437 m_staticMonth
->Show();
440 // year change not allowed here
442 m_staticYear
->Show();
444 //else: these controls are not even created, don't show/hide them
447 wxControl
*wxGenericCalendarCtrl
::GetMonthControl() const
449 return AllowMonthChange() ?
(wxControl
*)m_comboMonth
: (wxControl
*)m_staticMonth
;
452 wxControl
*wxGenericCalendarCtrl
::GetYearControl() const
454 return AllowYearChange() ?
(wxControl
*)m_spinYear
: (wxControl
*)m_staticYear
;
457 void wxGenericCalendarCtrl
::EnableYearChange(bool enable
)
459 if ( enable
!= AllowYearChange() )
461 long style
= GetWindowStyle();
463 style
&= ~wxCAL_NO_YEAR_CHANGE
;
465 style
|= wxCAL_NO_YEAR_CHANGE
;
466 SetWindowStyle(style
);
468 ShowCurrentControls();
469 if ( GetWindowStyle() & wxCAL_SEQUENTIAL_MONTH_SELECTION
)
476 bool wxGenericCalendarCtrl
::EnableMonthChange(bool enable
)
478 if ( !wxCalendarCtrlBase
::EnableMonthChange(enable
) )
481 ShowCurrentControls();
482 if ( GetWindowStyle() & wxCAL_SEQUENTIAL_MONTH_SELECTION
)
488 // ----------------------------------------------------------------------------
490 // ----------------------------------------------------------------------------
492 bool wxGenericCalendarCtrl
::SetDate(const wxDateTime
& date
)
496 bool sameMonth
= m_date
.GetMonth() == date
.GetMonth(),
497 sameYear
= m_date
.GetYear() == date
.GetYear();
499 if ( IsDateInRange(date
) )
501 if ( sameMonth
&& sameYear
)
503 // just change the day
508 if ( AllowMonthChange() && (AllowYearChange() || sameYear
) )
513 if ( !(GetWindowStyle() & wxCAL_SEQUENTIAL_MONTH_SELECTION
) )
515 // update the controls
516 m_comboMonth
->SetSelection(m_date
.GetMonth());
518 if ( AllowYearChange() )
520 if ( !m_userChangedYear
)
521 m_spinYear
->SetValue(m_date
.Format(_T("%Y")));
525 // as the month changed, holidays did too
528 // update the calendar
539 m_userChangedYear
= false;
544 void wxGenericCalendarCtrl
::ChangeDay(const wxDateTime
& date
)
546 if ( m_date
!= date
)
548 // we need to refresh the row containing the old date and the one
549 // containing the new one
550 wxDateTime dateOld
= m_date
;
553 RefreshDate(dateOld
);
555 // if the date is in the same row, it was already drawn correctly
556 if ( GetWeek(m_date
) != GetWeek(dateOld
) )
563 void wxGenericCalendarCtrl
::SetDateAndNotify(const wxDateTime
& date
)
565 const wxDateTime dateOld
= GetDate();
566 if ( date
!= dateOld
&& SetDate(date
) )
568 GenerateAllChangeEvents(dateOld
);
572 // ----------------------------------------------------------------------------
574 // ----------------------------------------------------------------------------
576 bool wxGenericCalendarCtrl
::SetLowerDateLimit(const wxDateTime
& date
/* = wxDefaultDateTime */)
580 if ( !(date
.IsValid()) || ( ( m_highdate
.IsValid() ) ?
( date
<= m_highdate
) : true ) )
592 bool wxGenericCalendarCtrl
::SetUpperDateLimit(const wxDateTime
& date
/* = wxDefaultDateTime */)
596 if ( !(date
.IsValid()) || ( ( m_lowdate
.IsValid() ) ?
( date
>= m_lowdate
) : true ) )
608 bool wxGenericCalendarCtrl
::SetDateRange(const wxDateTime
& lowerdate
/* = wxDefaultDateTime */, const wxDateTime
& upperdate
/* = wxDefaultDateTime */)
613 ( !( lowerdate
.IsValid() ) || ( ( upperdate
.IsValid() ) ?
( lowerdate
<= upperdate
) : true ) ) &&
614 ( !( upperdate
.IsValid() ) || ( ( lowerdate
.IsValid() ) ?
( upperdate
>= lowerdate
) : true ) ) )
616 m_lowdate
= lowerdate
;
617 m_highdate
= upperdate
;
627 bool wxGenericCalendarCtrl
::GetDateRange(wxDateTime
*lowerdate
,
628 wxDateTime
*upperdate
) const
631 *lowerdate
= m_lowdate
;
633 *upperdate
= m_highdate
;
635 return m_lowdate
.IsValid() || m_highdate
.IsValid();
638 // ----------------------------------------------------------------------------
640 // ----------------------------------------------------------------------------
642 wxDateTime wxGenericCalendarCtrl
::GetStartDate() const
644 wxDateTime
::Tm tm
= m_date
.GetTm();
646 wxDateTime date
= wxDateTime(1, tm
.mon
, tm
.year
);
649 date
.SetToPrevWeekDay(GetWindowStyle() & wxCAL_MONDAY_FIRST
650 ? wxDateTime
::Mon
: wxDateTime
::Sun
);
652 if ( GetWindowStyle() & wxCAL_SHOW_SURROUNDING_WEEKS
)
654 // We want to offset the calendar if we start on the first..
655 if ( date
.GetDay() == 1 )
657 date
-= wxDateSpan
::Week();
664 bool wxGenericCalendarCtrl
::IsDateShown(const wxDateTime
& date
) const
666 if ( !(GetWindowStyle() & wxCAL_SHOW_SURROUNDING_WEEKS
) )
668 return date
.GetMonth() == m_date
.GetMonth();
676 bool wxGenericCalendarCtrl
::IsDateInRange(const wxDateTime
& date
) const
678 // Check if the given date is in the range specified
679 return ( ( ( m_lowdate
.IsValid() ) ?
( date
>= m_lowdate
) : true )
680 && ( ( m_highdate
.IsValid() ) ?
( date
<= m_highdate
) : true ) );
683 bool wxGenericCalendarCtrl
::ChangeYear(wxDateTime
* target
) const
687 if ( !(IsDateInRange(*target
)) )
689 if ( target
->GetYear() < m_date
.GetYear() )
691 if ( target
->GetYear() >= GetLowerDateLimit().GetYear() )
693 *target
= GetLowerDateLimit();
703 if ( target
->GetYear() <= GetUpperDateLimit().GetYear() )
705 *target
= GetUpperDateLimit();
722 bool wxGenericCalendarCtrl
::ChangeMonth(wxDateTime
* target
) const
726 if ( !(IsDateInRange(*target
)) )
730 if ( target
->GetMonth() < m_date
.GetMonth() )
732 *target
= GetLowerDateLimit();
736 *target
= GetUpperDateLimit();
743 size_t wxGenericCalendarCtrl
::GetWeek(const wxDateTime
& date
) const
745 size_t retval
= date
.GetWeekOfMonth(GetWindowStyle() & wxCAL_MONDAY_FIRST
746 ? wxDateTime
::Monday_First
747 : wxDateTime
::Sunday_First
);
749 if ( (GetWindowStyle() & wxCAL_SHOW_SURROUNDING_WEEKS
) )
751 // we need to offset an extra week if we "start" on the 1st of the month
752 wxDateTime
::Tm tm
= date
.GetTm();
754 wxDateTime datetest
= wxDateTime(1, tm
.mon
, tm
.year
);
757 datetest
.SetToPrevWeekDay(GetWindowStyle() & wxCAL_MONDAY_FIRST
758 ? wxDateTime
::Mon
: wxDateTime
::Sun
);
760 if ( datetest
.GetDay() == 1 )
769 // ----------------------------------------------------------------------------
771 // ----------------------------------------------------------------------------
773 // this is a composite control and it must arrange its parts each time its
774 // size or position changes: the combobox and spinctrl are along the top of
775 // the available area and the calendar takes up therest of the space
777 // the static controls are supposed to be always smaller than combo/spin so we
778 // always use the latter for size calculations and position the static to take
781 // the constants used for the layout
782 #define VERT_MARGIN 5 // distance between combo and calendar
783 #define HORZ_MARGIN 5 // spin
785 wxSize wxGenericCalendarCtrl
::DoGetBestSize() const
787 // calc the size of the calendar
788 wx_const_cast(wxGenericCalendarCtrl
*, this)->RecalcGeometry();
790 wxCoord width
= 7*m_widthCol
,
791 height
= 7*m_heightRow
+ m_rowOffset
;
793 if ( !HasFlag(wxCAL_SEQUENTIAL_MONTH_SELECTION
) )
795 const wxSize bestSizeCombo
= m_comboMonth
->GetBestSize();
797 height
+= wxMax(bestSizeCombo
.y
, m_spinYear
->GetBestSize().y
)
800 // the spin control get clipped otherwise
804 wxCoord w2
= bestSizeCombo
.x
+ HORZ_MARGIN
+ GetCharWidth()*6;
809 wxSize
best(width
, height
);
810 if ( !HasFlag(wxBORDER_NONE
) )
812 best
+= GetWindowBorderSize();
820 void wxGenericCalendarCtrl
::DoMoveWindow(int x
, int y
, int width
, int height
)
824 if ( !HasFlag(wxCAL_SEQUENTIAL_MONTH_SELECTION
) && m_staticMonth
)
826 wxSize sizeCombo
= m_comboMonth
->GetEffectiveMinSize();
827 wxSize sizeStatic
= m_staticMonth
->GetSize();
828 wxSize sizeSpin
= m_spinYear
->GetSize();
830 int maxHeight
= wxMax(sizeSpin
.y
, sizeCombo
.y
);
831 int dy
= (maxHeight
- sizeStatic
.y
) / 2;
833 m_comboMonth
->Move(x
, y
+ (maxHeight
- sizeCombo
.y
)/2 + 2); // FIXME, something is reporting the wrong size..
835 m_comboMonth
->Move(x
, y
+ (maxHeight
- sizeCombo
.y
)/2);
837 m_staticMonth
->SetSize(x
, y
+ dy
, sizeCombo
.x
, -1, sizeStatic
.y
);
839 int xDiff
= sizeCombo
.x
+ HORZ_MARGIN
;
841 m_spinYear
->SetSize(x
+ xDiff
, y
+ (maxHeight
- sizeSpin
.y
)/2, width
- xDiff
, maxHeight
);
842 m_staticYear
->SetSize(x
+ xDiff
, y
+ dy
, width
- xDiff
, sizeStatic
.y
);
844 yDiff
= maxHeight
+ VERT_MARGIN
;
846 else // no controls on the top
851 wxControl
::DoMoveWindow(x
, y
+ yDiff
, width
, height
- yDiff
);
854 void wxGenericCalendarCtrl
::RecalcGeometry()
858 dc
.SetFont(GetFont());
860 // determine the column width (weekday names are not necessarily wider
861 // than the numbers (in some languages), so let's not assume that they are)
863 for ( int day
= 10; day
<= 31; day
++)
866 dc
.GetTextExtent(wxString
::Format(wxT("%d"), day
), &width
, &m_heightRow
);
867 if ( width
> m_widthCol
)
869 // 1.5 times the width gives nice margins even if the weekday
871 m_widthCol
= width
+width
/2;
874 wxDateTime
::WeekDay wd
;
875 for ( wd
= wxDateTime
::Sun
; wd
< wxDateTime
::Inv_WeekDay
; wxNextWDay(wd
) )
878 dc
.GetTextExtent(m_weekdays
[wd
], &width
, &m_heightRow
);
879 if ( width
> m_widthCol
)
885 // leave some margins
889 m_rowOffset
= HasFlag(wxCAL_SEQUENTIAL_MONTH_SELECTION
) ? m_heightRow
: 0; // conditional in relation to style
892 // ----------------------------------------------------------------------------
894 // ----------------------------------------------------------------------------
896 void wxGenericCalendarCtrl
::OnPaint(wxPaintEvent
& WXUNUSED(event
))
900 dc
.SetFont(GetFont());
905 wxLogDebug("--- starting to paint, selection: %s, week %u\n",
906 m_date
.Format("%a %d-%m-%Y %H:%M:%S").c_str(),
911 wxCoord x0
= wxMax( (GetSize().x
- m_widthCol
*7) /2 , 0 );
913 if ( HasFlag(wxCAL_SEQUENTIAL_MONTH_SELECTION
) )
915 // draw the sequential month-selector
917 dc
.SetBackgroundMode(wxBRUSHSTYLE_TRANSPARENT
);
918 dc
.SetTextForeground(*wxBLACK
);
919 dc
.SetBrush(wxBrush(m_colHeaderBg
, wxBRUSHSTYLE_SOLID
));
920 dc
.SetPen(wxPen(m_colHeaderBg
, 1, wxPENSTYLE_SOLID
));
921 dc
.DrawRectangle(0, y
, GetClientSize().x
, m_heightRow
);
923 // Get extent of month-name + year
924 wxCoord monthw
, monthh
;
925 wxString headertext
= m_date
.Format(wxT("%B %Y"));
926 dc
.GetTextExtent(headertext
, &monthw
, &monthh
);
928 // draw month-name centered above weekdays
929 wxCoord monthx
= ((m_widthCol
* 7) - monthw
) / 2 + x0
;
930 wxCoord monthy
= ((m_heightRow
- monthh
) / 2) + y
;
931 dc
.DrawText(headertext
, monthx
, monthy
);
933 // calculate the "month-arrows"
934 wxPoint leftarrow
[3];
935 wxPoint rightarrow
[3];
937 int arrowheight
= monthh
/ 2;
939 leftarrow
[0] = wxPoint(0, arrowheight
/ 2);
940 leftarrow
[1] = wxPoint(arrowheight
/ 2, 0);
941 leftarrow
[2] = wxPoint(arrowheight
/ 2, arrowheight
- 1);
943 rightarrow
[0] = wxPoint(0,0);
944 rightarrow
[1] = wxPoint(arrowheight
/ 2, arrowheight
/ 2);
945 rightarrow
[2] = wxPoint(0, arrowheight
- 1);
947 // draw the "month-arrows"
949 wxCoord arrowy
= (m_heightRow
- arrowheight
) / 2;
950 wxCoord larrowx
= (m_widthCol
- (arrowheight
/ 2)) / 2 + x0
;
951 wxCoord rarrowx
= ((m_widthCol
- (arrowheight
/ 2)) / 2) + m_widthCol
*6 + x0
;
952 m_leftArrowRect
= m_rightArrowRect
= wxRect(0,0,0,0);
954 if ( AllowMonthChange() )
956 wxDateTime ldpm
= wxDateTime(1,m_date
.GetMonth(), m_date
.GetYear()) - wxDateSpan
::Day(); // last day prev month
957 // Check if range permits change
958 if ( IsDateInRange(ldpm
) && ( ( ldpm
.GetYear() == m_date
.GetYear() ) ?
true : AllowYearChange() ) )
960 m_leftArrowRect
= wxRect(larrowx
- 3, arrowy
- 3, (arrowheight
/ 2) + 8, (arrowheight
+ 6));
961 dc
.SetBrush(*wxBLACK_BRUSH
);
962 dc
.SetPen(*wxBLACK_PEN
);
963 dc
.DrawPolygon(3, leftarrow
, larrowx
, arrowy
, wxWINDING_RULE
);
964 dc
.SetBrush(*wxTRANSPARENT_BRUSH
);
965 dc
.DrawRectangle(m_leftArrowRect
);
967 wxDateTime fdnm
= wxDateTime(1,m_date
.GetMonth(), m_date
.GetYear()) + wxDateSpan
::Month(); // first day next month
968 if ( IsDateInRange(fdnm
) && ( ( fdnm
.GetYear() == m_date
.GetYear() ) ?
true : AllowYearChange() ) )
970 m_rightArrowRect
= wxRect(rarrowx
- 4, arrowy
- 3, (arrowheight
/ 2) + 8, (arrowheight
+ 6));
971 dc
.SetBrush(*wxBLACK_BRUSH
);
972 dc
.SetPen(*wxBLACK_PEN
);
973 dc
.DrawPolygon(3, rightarrow
, rarrowx
, arrowy
, wxWINDING_RULE
);
974 dc
.SetBrush(*wxTRANSPARENT_BRUSH
);
975 dc
.DrawRectangle(m_rightArrowRect
);
982 // first draw the week days
983 if ( IsExposed(x0
, y
, x0
+ 7*m_widthCol
, m_heightRow
) )
986 wxLogDebug("painting the header");
989 dc
.SetBackgroundMode(wxBRUSHSTYLE_TRANSPARENT
);
990 dc
.SetTextForeground(m_colHeaderFg
);
991 dc
.SetBrush(wxBrush(m_colHeaderBg
, wxBRUSHSTYLE_SOLID
));
992 dc
.SetPen(wxPen(m_colHeaderBg
, 1, wxPENSTYLE_SOLID
));
993 dc
.DrawRectangle(0, y
, GetClientSize().x
, m_heightRow
);
995 bool startOnMonday
= (GetWindowStyle() & wxCAL_MONDAY_FIRST
) != 0;
996 for ( int wd
= 0; wd
< 7; wd
++ )
1000 n
= wd
== 6 ?
0 : wd
+ 1;
1004 dc
.GetTextExtent(m_weekdays
[n
], &dayw
, &dayh
);
1005 dc
.DrawText(m_weekdays
[n
], x0
+ (wd
*m_widthCol
) + ((m_widthCol
- dayw
) / 2), y
); // center the day-name
1009 // then the calendar itself
1010 dc
.SetTextForeground(*wxBLACK
);
1011 //dc.SetFont(*wxNORMAL_FONT);
1014 wxDateTime date
= GetStartDate();
1017 wxLogDebug("starting calendar from %s\n",
1018 date
.Format("%a %d-%m-%Y %H:%M:%S").c_str());
1021 dc
.SetBackgroundMode(wxBRUSHSTYLE_SOLID
);
1022 for ( size_t nWeek
= 1; nWeek
<= 6; nWeek
++, y
+= m_heightRow
)
1024 // if the update region doesn't intersect this row, don't paint it
1025 if ( !IsExposed(x0
, y
, x0
+ 7*m_widthCol
, m_heightRow
- 1) )
1027 date
+= wxDateSpan
::Week();
1033 wxLogDebug("painting week %d at y = %d\n", nWeek
, y
);
1036 for ( int wd
= 0; wd
< 7; wd
++ )
1038 dc
.SetTextBackground(m_colBackground
);
1039 if ( IsDateShown(date
) )
1041 // don't use wxDate::Format() which prepends 0s
1042 unsigned int day
= date
.GetDay();
1043 wxString dayStr
= wxString
::Format(_T("%u"), day
);
1045 dc
.GetTextExtent(dayStr
, &width
, (wxCoord
*)NULL
);
1047 bool changedColours
= false,
1048 changedFont
= false;
1051 wxCalendarDateAttr
*attr
= NULL
;
1053 if ( date
.GetMonth() != m_date
.GetMonth() || !IsDateInRange(date
) )
1055 // draw the days of adjacent months in different colour
1056 dc
.SetTextForeground(m_colSurrounding
);
1057 changedColours
= true;
1061 isSel
= date
.IsSameDate(m_date
);
1062 attr
= m_attrs
[day
- 1];
1066 dc
.SetTextForeground(m_colHighlightFg
);
1067 dc
.SetTextBackground(m_colHighlightBg
);
1069 changedColours
= true;
1073 wxColour colFg
, colBg
;
1075 if ( attr
->IsHoliday() )
1077 colFg
= m_colHolidayFg
;
1078 colBg
= m_colHolidayBg
;
1082 colFg
= attr
->GetTextColour();
1083 colBg
= attr
->GetBackgroundColour();
1088 dc
.SetTextForeground(colFg
);
1089 changedColours
= true;
1094 dc
.SetTextBackground(colBg
);
1095 changedColours
= true;
1098 if ( attr
->HasFont() )
1100 dc
.SetFont(attr
->GetFont());
1106 wxCoord x
= wd
*m_widthCol
+ (m_widthCol
- width
) / 2 + x0
;
1107 dc
.DrawText(dayStr
, x
, y
+ 1);
1109 if ( !isSel
&& attr
&& attr
->HasBorder() )
1112 if ( attr
->HasBorderColour() )
1114 colBorder
= attr
->GetBorderColour();
1118 colBorder
= GetForegroundColour();
1121 wxPen
pen(colBorder
, 1, wxPENSTYLE_SOLID
);
1123 dc
.SetBrush(*wxTRANSPARENT_BRUSH
);
1125 switch ( attr
->GetBorder() )
1127 case wxCAL_BORDER_SQUARE
:
1128 dc
.DrawRectangle(x
- 2, y
,
1129 width
+ 4, m_heightRow
);
1132 case wxCAL_BORDER_ROUND
:
1133 dc
.DrawEllipse(x
- 2, y
,
1134 width
+ 4, m_heightRow
);
1138 wxFAIL_MSG(_T("unknown border type"));
1142 if ( changedColours
)
1144 dc
.SetTextForeground(GetForegroundColour());
1145 dc
.SetTextBackground(GetBackgroundColour());
1150 dc
.SetFont(GetFont());
1153 //else: just don't draw it
1155 date
+= wxDateSpan
::Day();
1159 // Greying out out-of-range background
1160 bool showSurrounding
= (GetWindowStyle() & wxCAL_SHOW_SURROUNDING_WEEKS
) != 0;
1162 date
= ( showSurrounding
) ?
GetStartDate() : wxDateTime(1, m_date
.GetMonth(), m_date
.GetYear());
1163 if ( !IsDateInRange(date
) )
1165 wxDateTime firstOOR
= GetLowerDateLimit() - wxDateSpan
::Day(); // first out-of-range
1167 wxBrush oorbrush
= *wxLIGHT_GREY_BRUSH
;
1168 oorbrush
.SetStyle(wxBRUSHSTYLE_FDIAGONAL_HATCH
);
1170 HighlightRange(&dc
, date
, firstOOR
, wxTRANSPARENT_PEN
, &oorbrush
);
1173 date
= ( showSurrounding
) ?
GetStartDate() + wxDateSpan
::Weeks(6) - wxDateSpan
::Day() : wxDateTime().SetToLastMonthDay(m_date
.GetMonth(), m_date
.GetYear());
1174 if ( !IsDateInRange(date
) )
1176 wxDateTime firstOOR
= GetUpperDateLimit() + wxDateSpan
::Day(); // first out-of-range
1178 wxBrush oorbrush
= *wxLIGHT_GREY_BRUSH
;
1179 oorbrush
.SetStyle(wxBRUSHSTYLE_FDIAGONAL_HATCH
);
1181 HighlightRange(&dc
, firstOOR
, date
, wxTRANSPARENT_PEN
, &oorbrush
);
1185 wxLogDebug("+++ finished painting");
1189 void wxGenericCalendarCtrl
::RefreshDate(const wxDateTime
& date
)
1195 // always refresh the whole row at once because our OnPaint() will draw
1196 // the whole row anyhow - and this allows the small optimisation in
1197 // OnClick() below to work
1198 rect
.x
= wxMax( (GetSize().x
- m_widthCol
*7) /2 , 0 );
1200 rect
.y
= (m_heightRow
* GetWeek(date
)) + m_rowOffset
;
1202 rect
.width
= 7*m_widthCol
;
1203 rect
.height
= m_heightRow
;
1206 // VZ: for some reason, the selected date seems to occupy more space under
1207 // MSW - this is probably some bug in the font size calculations, but I
1208 // don't know where exactly. This fix is ugly and leads to more
1209 // refreshes than really needed, but without it the selected days
1210 // leaves even more ugly underscores on screen.
1215 wxLogDebug("*** refreshing week %d at (%d, %d)-(%d, %d)\n",
1218 rect
.x
+ rect
.width
, rect
.y
+ rect
.height
);
1221 Refresh(true, &rect
);
1224 void wxGenericCalendarCtrl
::HighlightRange(wxPaintDC
* pDC
, const wxDateTime
& fromdate
, const wxDateTime
& todate
, const wxPen
* pPen
, const wxBrush
* pBrush
)
1226 // Highlights the given range using pen and brush
1227 // Does nothing if todate < fromdate
1231 wxLogDebug("+++ HighlightRange: (%s) - (%s) +++", fromdate
.Format("%d %m %Y"), todate
.Format("%d %m %Y"));
1234 if ( todate
>= fromdate
)
1241 // implicit: both dates must be currently shown - checked by GetDateCoord
1242 if ( GetDateCoord(fromdate
, &fd
, &fw
) && GetDateCoord(todate
, &td
, &tw
) )
1245 wxLogDebug("Highlight range: (%i, %i) - (%i, %i)", fd
, fw
, td
, tw
);
1247 if ( ( (tw
- fw
) == 1 ) && ( td
< fd
) )
1249 // special case: interval 7 days or less not in same week
1250 // split in two separate intervals
1251 wxDateTime tfd
= fromdate
+ wxDateSpan
::Days(7-fd
);
1252 wxDateTime ftd
= tfd
+ wxDateSpan
::Day();
1254 wxLogDebug("Highlight: Separate segments");
1257 HighlightRange(pDC
, fromdate
, tfd
, pPen
, pBrush
);
1258 HighlightRange(pDC
, ftd
, todate
, pPen
, pBrush
);
1263 wxPoint corners
[8]; // potentially 8 corners in polygon
1264 wxCoord x0
= wxMax( (GetSize().x
- m_widthCol
*7) /2 , 0 );
1268 // simple case: same week
1270 corners
[0] = wxPoint(x0
+ (fd
- 1) * m_widthCol
, (fw
* m_heightRow
) + m_rowOffset
);
1271 corners
[1] = wxPoint(x0
+ (fd
- 1) * m_widthCol
, ((fw
+ 1 ) * m_heightRow
) + m_rowOffset
);
1272 corners
[2] = wxPoint(x0
+ td
* m_widthCol
, ((tw
+ 1) * m_heightRow
) + m_rowOffset
);
1273 corners
[3] = wxPoint(x0
+ td
* m_widthCol
, (tw
* m_heightRow
) + m_rowOffset
);
1278 // "complex" polygon
1279 corners
[cidx
] = wxPoint(x0
+ (fd
- 1) * m_widthCol
, (fw
* m_heightRow
) + m_rowOffset
); cidx
++;
1283 corners
[cidx
] = wxPoint(x0
+ (fd
- 1) * m_widthCol
, ((fw
+ 1) * m_heightRow
) + m_rowOffset
); cidx
++;
1284 corners
[cidx
] = wxPoint(x0
, ((fw
+ 1) * m_heightRow
) + m_rowOffset
); cidx
++;
1287 corners
[cidx
] = wxPoint(x0
, ((tw
+ 1) * m_heightRow
) + m_rowOffset
); cidx
++;
1288 corners
[cidx
] = wxPoint(x0
+ td
* m_widthCol
, ((tw
+ 1) * m_heightRow
) + m_rowOffset
); cidx
++;
1292 corners
[cidx
] = wxPoint(x0
+ td
* m_widthCol
, (tw
* m_heightRow
) + m_rowOffset
); cidx
++;
1293 corners
[cidx
] = wxPoint(x0
+ 7 * m_widthCol
, (tw
* m_heightRow
) + m_rowOffset
); cidx
++;
1296 corners
[cidx
] = wxPoint(x0
+ 7 * m_widthCol
, (fw
* m_heightRow
) + m_rowOffset
); cidx
++;
1302 pDC
->SetBrush(*pBrush
);
1304 pDC
->DrawPolygon(numpoints
, corners
);
1310 wxLogDebug("--- HighlightRange ---");
1314 bool wxGenericCalendarCtrl
::GetDateCoord(const wxDateTime
& date
, int *day
, int *week
) const
1319 wxLogDebug("+++ GetDateCoord: (%s) +++", date
.Format("%d %m %Y"));
1322 if ( IsDateShown(date
) )
1324 bool startOnMonday
= ( GetWindowStyle() & wxCAL_MONDAY_FIRST
) != 0;
1327 *day
= date
.GetWeekDay();
1329 if ( *day
== 0 ) // sunday
1331 *day
= ( startOnMonday
) ?
7 : 1;
1335 *day
+= ( startOnMonday
) ?
0 : 1;
1338 int targetmonth
= date
.GetMonth() + (12 * date
.GetYear());
1339 int thismonth
= m_date
.GetMonth() + (12 * m_date
.GetYear());
1342 if ( targetmonth
== thismonth
)
1344 *week
= GetWeek(date
);
1348 if ( targetmonth
< thismonth
)
1350 *week
= 1; // trivial
1352 else // targetmonth > thismonth
1358 // get the datecoord of the last day in the month currently shown
1360 wxLogDebug(" +++ LDOM +++");
1362 GetDateCoord(ldcm
.SetToLastMonthDay(m_date
.GetMonth(), m_date
.GetYear()), &lastday
, &lastweek
);
1364 wxLogDebug(" --- LDOM ---");
1367 wxTimeSpan span
= date
- ldcm
;
1369 int daysfromlast
= span
.GetDays();
1371 wxLogDebug("daysfromlast: %i", daysfromlast
);
1373 if ( daysfromlast
+ lastday
> 7 ) // past week boundary
1375 int wholeweeks
= (daysfromlast
/ 7);
1376 *week
= wholeweeks
+ lastweek
;
1377 if ( (daysfromlast
- (7 * wholeweeks
) + lastday
) > 7 )
1397 wxLogDebug("--- GetDateCoord: (%s) = (%i, %i) ---", date
.Format("%d %m %Y"), *day
, *week
);
1403 // ----------------------------------------------------------------------------
1405 // ----------------------------------------------------------------------------
1407 void wxGenericCalendarCtrl
::OnDClick(wxMouseEvent
& event
)
1409 if ( HitTest(event
.GetPosition()) != wxCAL_HITTEST_DAY
)
1415 GenerateEvent(wxEVT_CALENDAR_DOUBLECLICKED
);
1419 void wxGenericCalendarCtrl
::OnClick(wxMouseEvent
& event
)
1422 wxDateTime
::WeekDay wday
;
1423 switch ( HitTest(event
.GetPosition(), &date
, &wday
) )
1425 case wxCAL_HITTEST_DAY
:
1426 if ( IsDateInRange(date
) )
1430 GenerateEvent(wxEVT_CALENDAR_SEL_CHANGED
);
1432 // we know that the month/year never change when the user
1433 // clicks on the control so there is no need to call
1434 // GenerateAllChangeEvents() here, we know which event to send
1435 GenerateEvent(wxEVT_CALENDAR_DAY_CHANGED
);
1439 case wxCAL_HITTEST_HEADER
:
1441 wxCalendarEvent
eventWd(this, GetDate(),
1442 wxEVT_CALENDAR_WEEKDAY_CLICKED
);
1443 eventWd
.SetWeekDay(wday
);
1444 (void)GetEventHandler()->ProcessEvent(eventWd
);
1448 case wxCAL_HITTEST_DECMONTH
:
1449 case wxCAL_HITTEST_INCMONTH
:
1450 case wxCAL_HITTEST_SURROUNDING_WEEK
:
1451 SetDateAndNotify(date
); // we probably only want to refresh the control. No notification.. (maybe as an option?)
1455 wxFAIL_MSG(_T("unknown hittest code"));
1458 case wxCAL_HITTEST_NOWHERE
:
1463 // as we don't (always) skip the message, we're not going to receive the
1464 // focus on click by default if we don't do it ourselves
1468 wxCalendarHitTestResult wxGenericCalendarCtrl
::HitTest(const wxPoint
& pos
,
1470 wxDateTime
::WeekDay
*wd
)
1474 // the position where the calendar really begins
1475 wxCoord x0
= wxMax((GetSize().x
- m_widthCol
*7)/2, 0);
1477 if ( HasFlag(wxCAL_SEQUENTIAL_MONTH_SELECTION
) )
1481 // we need to find out if the hit is on left arrow, on month or on right arrow
1483 if ( m_leftArrowRect
.Contains(pos
) )
1487 if ( IsDateInRange(m_date
- wxDateSpan
::Month()) )
1489 *date
= m_date
- wxDateSpan
::Month();
1493 *date
= GetLowerDateLimit();
1497 return wxCAL_HITTEST_DECMONTH
;
1500 if ( m_rightArrowRect
.Contains(pos
) )
1504 if ( IsDateInRange(m_date
+ wxDateSpan
::Month()) )
1506 *date
= m_date
+ wxDateSpan
::Month();
1510 *date
= GetUpperDateLimit();
1514 return wxCAL_HITTEST_INCMONTH
;
1519 // header: week days
1520 int wday
= (pos
.x
- x0
) / m_widthCol
;
1521 if ( pos
.y
< (m_heightRow
+ m_rowOffset
) )
1523 if ( pos
.y
> m_rowOffset
)
1527 if ( GetWindowStyle() & wxCAL_MONDAY_FIRST
)
1529 wday
= wday
== 6 ?
0 : wday
+ 1;
1532 *wd
= (wxDateTime
::WeekDay
)wday
;
1535 return wxCAL_HITTEST_HEADER
;
1539 return wxCAL_HITTEST_NOWHERE
;
1543 int week
= (pos
.y
- (m_heightRow
+ m_rowOffset
)) / m_heightRow
;
1544 if ( week
>= 6 || wday
>= 7 )
1546 return wxCAL_HITTEST_NOWHERE
;
1549 wxDateTime dt
= GetStartDate() + wxDateSpan
::Days(7*week
+ wday
);
1551 if ( IsDateShown(dt
) )
1556 if ( dt
.GetMonth() == m_date
.GetMonth() )
1559 return wxCAL_HITTEST_DAY
;
1563 return wxCAL_HITTEST_SURROUNDING_WEEK
;
1568 return wxCAL_HITTEST_NOWHERE
;
1572 // ----------------------------------------------------------------------------
1573 // subcontrols events handling
1574 // ----------------------------------------------------------------------------
1576 void wxGenericCalendarCtrl
::OnMonthChange(wxCommandEvent
& event
)
1578 wxDateTime
::Tm tm
= m_date
.GetTm();
1580 wxDateTime
::Month mon
= (wxDateTime
::Month
)event
.GetInt();
1581 if ( tm
.mday
> wxDateTime
::GetNumberOfDays(mon
, tm
.year
) )
1583 tm
.mday
= wxDateTime
::GetNumberOfDays(mon
, tm
.year
);
1586 wxDateTime target
= wxDateTime(tm
.mday
, mon
, tm
.year
);
1588 ChangeMonth(&target
);
1589 SetDateAndNotify(target
);
1592 void wxGenericCalendarCtrl
::OnYearChange(wxCommandEvent
& event
)
1594 int year
= (int)event
.GetInt();
1595 if ( year
== INT_MIN
)
1597 // invalid year in the spin control, ignore it
1601 wxDateTime
::Tm tm
= m_date
.GetTm();
1603 if ( tm
.mday
> wxDateTime
::GetNumberOfDays(tm
.mon
, year
) )
1605 tm
.mday
= wxDateTime
::GetNumberOfDays(tm
.mon
, year
);
1608 wxDateTime target
= wxDateTime(tm
.mday
, tm
.mon
, year
);
1610 if ( ChangeYear(&target
) )
1612 SetDateAndNotify(target
);
1616 // In this case we don't want to change the date. That would put us
1617 // inside the same year but a strange number of months forward/back..
1618 m_spinYear
->SetValue(target
.GetYear());
1622 void wxGenericCalendarCtrl
::OnYearTextChange(wxCommandEvent
& event
)
1624 SetUserChangedYear();
1625 OnYearChange(event
);
1628 // Responds to colour changes, and passes event on to children.
1629 void wxGenericCalendarCtrl
::OnSysColourChanged(wxSysColourChangedEvent
& event
)
1634 // Propagate the event to the children
1635 wxControl
::OnSysColourChanged(event
);
1637 // Redraw control area
1638 SetBackgroundColour(m_colBackground
);
1642 // ----------------------------------------------------------------------------
1643 // keyboard interface
1644 // ----------------------------------------------------------------------------
1646 void wxGenericCalendarCtrl
::OnChar(wxKeyEvent
& event
)
1649 switch ( event
.GetKeyCode() )
1653 target
= m_date
+ wxDateSpan
::Year();
1654 if ( ChangeYear(&target
) )
1656 SetDateAndNotify(target
);
1662 target
= m_date
- wxDateSpan
::Year();
1663 if ( ChangeYear(&target
) )
1665 SetDateAndNotify(target
);
1670 target
= m_date
- wxDateSpan
::Month();
1671 ChangeMonth(&target
);
1672 SetDateAndNotify(target
); // always
1676 target
= m_date
+ wxDateSpan
::Month();
1677 ChangeMonth(&target
);
1678 SetDateAndNotify(target
); // always
1682 if ( event
.ControlDown() )
1684 target
= wxDateTime(m_date
).SetToNextWeekDay(
1685 GetWindowStyle() & wxCAL_MONDAY_FIRST
1686 ? wxDateTime
::Sun
: wxDateTime
::Sat
);
1687 if ( !IsDateInRange(target
) )
1689 target
= GetUpperDateLimit();
1691 SetDateAndNotify(target
);
1694 SetDateAndNotify(m_date
+ wxDateSpan
::Day());
1698 if ( event
.ControlDown() )
1700 target
= wxDateTime(m_date
).SetToPrevWeekDay(
1701 GetWindowStyle() & wxCAL_MONDAY_FIRST
1702 ? wxDateTime
::Mon
: wxDateTime
::Sun
);
1703 if ( !IsDateInRange(target
) )
1705 target
= GetLowerDateLimit();
1707 SetDateAndNotify(target
);
1710 SetDateAndNotify(m_date
- wxDateSpan
::Day());
1714 SetDateAndNotify(m_date
- wxDateSpan
::Week());
1718 SetDateAndNotify(m_date
+ wxDateSpan
::Week());
1722 if ( event
.ControlDown() )
1723 SetDateAndNotify(wxDateTime
::Today());
1725 SetDateAndNotify(wxDateTime(1, m_date
.GetMonth(), m_date
.GetYear()));
1729 SetDateAndNotify(wxDateTime(m_date
).SetToLastMonthDay());
1733 GenerateEvent(wxEVT_CALENDAR_DOUBLECLICKED
);
1741 // ----------------------------------------------------------------------------
1742 // holidays handling
1743 // ----------------------------------------------------------------------------
1745 void wxGenericCalendarCtrl
::EnableHolidayDisplay(bool display
)
1747 long style
= GetWindowStyle();
1749 style
|= wxCAL_SHOW_HOLIDAYS
;
1751 style
&= ~wxCAL_SHOW_HOLIDAYS
;
1753 SetWindowStyle(style
);
1758 ResetHolidayAttrs();
1763 void wxGenericCalendarCtrl
::SetHolidayAttrs()
1765 if ( GetWindowStyle() & wxCAL_SHOW_HOLIDAYS
)
1767 ResetHolidayAttrs();
1769 wxDateTime
::Tm tm
= m_date
.GetTm();
1770 wxDateTime
dtStart(1, tm
.mon
, tm
.year
),
1771 dtEnd
= dtStart
.GetLastMonthDay();
1773 wxDateTimeArray hol
;
1774 wxDateTimeHolidayAuthority
::GetHolidaysInRange(dtStart
, dtEnd
, hol
);
1776 size_t count
= hol
.GetCount();
1777 for ( size_t n
= 0; n
< count
; n
++ )
1779 SetHoliday(hol
[n
].GetDay());
1784 void wxGenericCalendarCtrl
::SetHoliday(size_t day
)
1786 wxCHECK_RET( day
> 0 && day
< 32, _T("invalid day in SetHoliday") );
1788 wxCalendarDateAttr
*attr
= GetAttr(day
);
1791 attr
= new wxCalendarDateAttr
;
1794 attr
->SetHoliday(true);
1796 // can't use SetAttr() because it would delete this pointer
1797 m_attrs
[day
- 1] = attr
;
1800 void wxGenericCalendarCtrl
::ResetHolidayAttrs()
1802 for ( size_t day
= 0; day
< 31; day
++ )
1806 m_attrs
[day
]->SetHoliday(false);
1811 void wxGenericCalendarCtrl
::Mark(size_t day
, bool mark
)
1813 wxCHECK_RET( day
> 0 && day
< 32, _T("invalid day in Mark") );
1815 const wxCalendarDateAttr
& m
= wxCalendarDateAttr
::GetMark();
1817 if ( m_attrs
[day
- 1] )
1818 AddAttr(m_attrs
[day
- 1], m
);
1820 SetAttr(day
, new wxCalendarDateAttr(m
));
1823 if ( m_attrs
[day
- 1] )
1824 DelAttr(m_attrs
[day
- 1], m
);
1830 wxGenericCalendarCtrl
::GetClassDefaultAttributes(wxWindowVariant variant
)
1832 // Use the same color scheme as wxListBox
1833 return wxListBox
::GetClassDefaultAttributes(variant
);
1836 #endif // wxUSE_CALENDARCTRL