]> git.saurik.com Git - wxWidgets.git/blob - src/generic/calctrlg.cpp
projects / wxWidgets.git / blob
? search:


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