src/generic/calctrl.cpp

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