src/generic/calctrl.cpp

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