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