src/generic/calctrlg.cpp

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