/[pcsx2_0.9.7]/trunk/3rdparty/wxWidgets/src/generic/calctrl.cpp
ViewVC logotype

Contents of /trunk/3rdparty/wxWidgets/src/generic/calctrl.cpp

Parent Directory Parent Directory | Revision Log Revision Log


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

  ViewVC Help
Powered by ViewVC 1.1.22