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


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