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