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