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