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