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     wxFLAGS_MEMBER(wxCAL_SHOW_WEEK_NUMBERS)
 100
 101 wxEND_FLAGS( wxCalendarCtrlStyle )
 102
 103 IMPLEMENT_DYNAMIC_CLASS_XTI(wxGenericCalendarCtrl, wxControl,"wx/calctrl.h")
 104
 105 wxBEGIN_PROPERTIES_TABLE(wxGenericCalendarCtrl)
 106     wxEVENT_RANGE_PROPERTY( Updated , wxEVT_CALENDAR_SEL_CHANGED , wxEVT_CALENDAR_WEEK_CLICKED , wxCalendarEvent )
 107     wxHIDE_PROPERTY( Children )
 108     wxPROPERTY( Date,wxDateTime, SetDate , GetDate, , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
 109     wxPROPERTY_FLAGS( WindowStyle , wxCalendarCtrlStyle , long , SetWindowStyleFlag , GetWindowStyleFlag , , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
 110 wxEND_PROPERTIES_TABLE()
 111
 112 wxBEGIN_HANDLERS_TABLE(wxGenericCalendarCtrl)
 113 wxEND_HANDLERS_TABLE()
 114
 115 wxCONSTRUCTOR_6( wxGenericCalendarCtrl , wxWindow* , Parent , wxWindowID , Id , wxDateTime , Date , wxPoint , Position , wxSize , Size , long , WindowStyle )
 116 #else
 117 IMPLEMENT_DYNAMIC_CLASS(wxGenericCalendarCtrl, wxControl)
 118 #endif
 119
 120 // ============================================================================
 121 // implementation
 122 // ============================================================================
 123
 124 // ----------------------------------------------------------------------------
 125 // helper functions
 126 // ----------------------------------------------------------------------------
 127
 128 namespace
 129 {
 130
 131 // add attributes that are set in attr
 132 void AddAttr(wxCalendarDateAttr *self, const wxCalendarDateAttr& attr)
 133 {
 134     if (attr.HasTextColour())
 135         self->SetTextColour(attr.GetTextColour());
 136     if (attr.HasBackgroundColour())
 137         self->SetBackgroundColour(attr.GetBackgroundColour());
 138     if (attr.HasBorderColour())
 139         self->SetBorderColour(attr.GetBorderColour());
 140     if (attr.HasFont())
 141         self->SetFont(attr.GetFont());
 142     if (attr.HasBorder())
 143         self->SetBorder(attr.GetBorder());
 144     if (attr.IsHoliday())
 145         self->SetHoliday(true);
 146 }
 147
 148 // remove attributes that are set in attr
 149 void DelAttr(wxCalendarDateAttr *self, const wxCalendarDateAttr &attr)
 150 {
 151     if (attr.HasTextColour())
 152         self->SetTextColour(wxNullColour);
 153     if (attr.HasBackgroundColour())
 154         self->SetBackgroundColour(wxNullColour);
 155     if (attr.HasBorderColour())
 156         self->SetBorderColour(wxNullColour);
 157     if (attr.HasFont())
 158         self->SetFont(wxNullFont);
 159     if (attr.HasBorder())
 160         self->SetBorder(wxCAL_BORDER_NONE);
 161     if (attr.IsHoliday())
 162         self->SetHoliday(false);
 163 }
 164
 165 } // anonymous namespace
 166
 167 // ----------------------------------------------------------------------------
 168 // wxGenericCalendarCtrl
 169 // ----------------------------------------------------------------------------
 170
 171 wxGenericCalendarCtrl::wxGenericCalendarCtrl(wxWindow *parent,
 172                                              wxWindowID id,
 173                                              const wxDateTime& date,
 174                                              const wxPoint& pos,
 175                                              const wxSize& size,
 176                                              long style,
 177                                              const wxString& name)
 178 {
 179     Init();
 180
 181     (void)Create(parent, id, date, pos, size, style, name);
 182 }
 183
 184 void wxGenericCalendarCtrl::Init()
 185 {
 186     m_comboMonth = NULL;
 187     m_spinYear = NULL;
 188     m_staticYear = NULL;
 189     m_staticMonth = NULL;
 190
 191     m_userChangedYear = false;
 192
 193     m_widthCol =
 194     m_heightRow =
 195     m_calendarWeekWidth = 0;
 196
 197     wxDateTime::WeekDay wd;
 198     for ( wd = wxDateTime::Sun; wd < wxDateTime::Inv_WeekDay; wxNextWDay(wd) )
 199     {
 200         m_weekdays[wd] = wxDateTime::GetWeekDayName(wd, wxDateTime::Name_Abbr);
 201     }
 202
 203     for ( size_t n = 0; n < WXSIZEOF(m_attrs); n++ )
 204     {
 205         m_attrs[n] = NULL;
 206     }
 207
 208     InitColours();
 209 }
 210
 211 void wxGenericCalendarCtrl::InitColours()
 212 {
 213     m_colHighlightFg = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
 214     m_colHighlightBg = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT);
 215     m_colBackground = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW);
 216     m_colSurrounding = wxSystemSettings::GetColour(wxSYS_COLOUR_GRAYTEXT);
 217
 218     m_colHolidayFg = *wxRED;
 219     // don't set m_colHolidayBg - by default, same as our bg colour
 220
 221     m_colHeaderFg = *wxBLUE;
 222     m_colHeaderBg = *wxLIGHT_GREY;
 223 }
 224
 225 bool wxGenericCalendarCtrl::Create(wxWindow *parent,
 226                                    wxWindowID id,
 227                                    const wxDateTime& date,
 228                                    const wxPoint& pos,
 229                                    const wxSize& size,
 230                                    long style,
 231                                    const wxString& name)
 232 {
 233     if ( !wxControl::Create(parent, id, pos, size,
 234                             style | wxCLIP_CHILDREN | wxWANTS_CHARS | wxFULL_REPAINT_ON_RESIZE,
 235                             wxDefaultValidator, name) )
 236     {
 237         return false;
 238     }
 239
 240     // needed to get the arrow keys normally used for the dialog navigation
 241     SetWindowStyle(style | wxWANTS_CHARS);
 242
 243     m_date = date.IsValid() ? date : wxDateTime::Today();
 244
 245     m_lowdate = wxDefaultDateTime;
 246     m_highdate = wxDefaultDateTime;
 247
 248     if ( !HasFlag(wxCAL_SEQUENTIAL_MONTH_SELECTION) )
 249     {
 250         CreateYearSpinCtrl();
 251         m_staticYear = new wxStaticText(GetParent(), wxID_ANY, m_date.Format(_T("%Y")),
 252                                         wxDefaultPosition, wxDefaultSize,
 253                                         wxALIGN_CENTRE);
 254         CreateMonthComboBox();
 255         m_staticMonth = new wxStaticText(GetParent(), wxID_ANY, m_date.Format(_T("%B")),
 256                                          wxDefaultPosition, wxDefaultSize,
 257                                          wxALIGN_CENTRE);
 258     }
 259
 260     ShowCurrentControls();
 261
 262     // we need to set the position as well because the main control position
 263     // is not the same as the one specified in pos if we have the controls
 264     // above it
 265     SetInitialSize(size);
 266     SetPosition(pos);
 267
 268     // Since we don't paint the whole background make sure that the platform
 269     // will use the right one.
 270     SetBackgroundColour(m_colBackground);
 271
 272     SetHolidayAttrs();
 273
 274     return true;
 275 }
 276
 277 wxGenericCalendarCtrl::~wxGenericCalendarCtrl()
 278 {
 279     for ( size_t n = 0; n < WXSIZEOF(m_attrs); n++ )
 280     {
 281         delete m_attrs[n];
 282     }
 283
 284     if ( !HasFlag(wxCAL_SEQUENTIAL_MONTH_SELECTION) )
 285     {
 286         delete m_comboMonth;
 287         delete m_staticMonth;
 288         delete m_spinYear;
 289         delete m_staticYear;
 290     }
 291 }
 292
 293 void wxGenericCalendarCtrl::SetWindowStyleFlag(long style)
 294 {
 295     // changing this style doesn't work because the controls are not
 296     // created/shown/hidden accordingly
 297     wxASSERT_MSG( (style & wxCAL_SEQUENTIAL_MONTH_SELECTION) ==
 298                     (m_windowStyle & wxCAL_SEQUENTIAL_MONTH_SELECTION),
 299                   _T("wxCAL_SEQUENTIAL_MONTH_SELECTION can't be changed after creation") );
 300
 301     wxControl::SetWindowStyleFlag(style);
 302 }
 303
 304 // ----------------------------------------------------------------------------
 305 // Create the wxComboBox and wxSpinCtrl
 306 // ----------------------------------------------------------------------------
 307
 308 void wxGenericCalendarCtrl::CreateMonthComboBox()
 309 {
 310     m_comboMonth = new wxComboBox(GetParent(), wxID_ANY,
 311                                   wxEmptyString,
 312                                   wxDefaultPosition,
 313                                   wxDefaultSize,
 314                                   0, NULL,
 315                                   wxCB_READONLY | wxCLIP_SIBLINGS);
 316
 317     wxDateTime::Month m;
 318     for ( m = wxDateTime::Jan; m < wxDateTime::Inv_Month; wxNextMonth(m) )
 319     {
 320         m_comboMonth->Append(wxDateTime::GetMonthName(m));
 321     }
 322
 323     m_comboMonth->SetSelection(GetDate().GetMonth());
 324     m_comboMonth->SetSize(wxDefaultCoord,
 325                           wxDefaultCoord,
 326                           wxDefaultCoord,
 327                           wxDefaultCoord,
 328                           wxSIZE_AUTO_WIDTH|wxSIZE_AUTO_HEIGHT);
 329
 330     m_comboMonth->Connect(m_comboMonth->GetId(), wxEVT_COMMAND_COMBOBOX_SELECTED,
 331                           wxCommandEventHandler(wxGenericCalendarCtrl::OnMonthChange),
 332                           NULL, this);
 333 }
 334
 335 void wxGenericCalendarCtrl::CreateYearSpinCtrl()
 336 {
 337     m_spinYear = new wxSpinCtrl(GetParent(), wxID_ANY,
 338                                 GetDate().Format(_T("%Y")),
 339                                 wxDefaultPosition,
 340                                 wxDefaultSize,
 341                                 wxSP_ARROW_KEYS | wxCLIP_SIBLINGS,
 342                                 -4300, 10000, GetDate().GetYear());
 343 #ifdef __WXMAC__
 344     m_spinYear->SetSize( 90, -1 );
 345 #endif
 346
 347     m_spinYear->Connect(m_spinYear->GetId(), wxEVT_COMMAND_TEXT_UPDATED,
 348                         wxCommandEventHandler(wxGenericCalendarCtrl::OnYearTextChange),
 349                         NULL, this);
 350
 351     m_spinYear->Connect(m_spinYear->GetId(), wxEVT_COMMAND_SPINCTRL_UPDATED,
 352                         wxSpinEventHandler(wxGenericCalendarCtrl::OnYearChange),
 353                         NULL, this);
 354 }
 355
 356 // ----------------------------------------------------------------------------
 357 // forward wxWin functions to subcontrols
 358 // ----------------------------------------------------------------------------
 359
 360 bool wxGenericCalendarCtrl::Destroy()
 361 {
 362     if ( m_staticYear )
 363         m_staticYear->Destroy();
 364     if ( m_spinYear )
 365         m_spinYear->Destroy();
 366     if ( m_comboMonth )
 367         m_comboMonth->Destroy();
 368     if ( m_staticMonth )
 369         m_staticMonth->Destroy();
 370
 371     m_staticYear = NULL;
 372     m_spinYear = NULL;
 373     m_comboMonth = NULL;
 374     m_staticMonth = NULL;
 375
 376     return wxControl::Destroy();
 377 }
 378
 379 bool wxGenericCalendarCtrl::Show(bool show)
 380 {
 381     if ( !wxControl::Show(show) )
 382     {
 383         return false;
 384     }
 385
 386     if ( !(GetWindowStyle() & wxCAL_SEQUENTIAL_MONTH_SELECTION) )
 387     {
 388         if ( GetMonthControl() )
 389         {
 390             GetMonthControl()->Show(show);
 391             GetYearControl()->Show(show);
 392         }
 393     }
 394
 395     return true;
 396 }
 397
 398 bool wxGenericCalendarCtrl::Enable(bool enable)
 399 {
 400     if ( !wxControl::Enable(enable) )
 401     {
 402         return false;
 403     }
 404
 405     if ( !(GetWindowStyle() & wxCAL_SEQUENTIAL_MONTH_SELECTION) )
 406     {
 407         GetMonthControl()->Enable(enable);
 408         GetYearControl()->Enable(enable);
 409     }
 410
 411     return true;
 412 }
 413
 414 // ----------------------------------------------------------------------------
 415 // enable/disable month/year controls
 416 // ----------------------------------------------------------------------------
 417
 418 void wxGenericCalendarCtrl::ShowCurrentControls()
 419 {
 420     if ( !HasFlag(wxCAL_SEQUENTIAL_MONTH_SELECTION) )
 421     {
 422         if ( AllowMonthChange() )
 423         {
 424             m_comboMonth->Show();
 425             m_staticMonth->Hide();
 426
 427             if ( AllowYearChange() )
 428             {
 429                 m_spinYear->Show();
 430                 m_staticYear->Hide();
 431
 432                 // skip the rest
 433                 return;
 434             }
 435         }
 436         else
 437         {
 438             m_comboMonth->Hide();
 439             m_staticMonth->Show();
 440         }
 441
 442         // year change not allowed here
 443         m_spinYear->Hide();
 444         m_staticYear->Show();
 445     }
 446     //else: these controls are not even created, don't show/hide them
 447 }
 448
 449 wxControl *wxGenericCalendarCtrl::GetMonthControl() const
 450 {
 451     return AllowMonthChange() ? (wxControl *)m_comboMonth : (wxControl *)m_staticMonth;
 452 }
 453
 454 wxControl *wxGenericCalendarCtrl::GetYearControl() const
 455 {
 456     return AllowYearChange() ? (wxControl *)m_spinYear : (wxControl *)m_staticYear;
 457 }
 458
 459 void wxGenericCalendarCtrl::EnableYearChange(bool enable)
 460 {
 461     if ( enable != AllowYearChange() )
 462     {
 463         long style = GetWindowStyle();
 464         if ( enable )
 465             style &= ~wxCAL_NO_YEAR_CHANGE;
 466         else
 467             style |= wxCAL_NO_YEAR_CHANGE;
 468         SetWindowStyle(style);
 469
 470         ShowCurrentControls();
 471         if ( GetWindowStyle() & wxCAL_SEQUENTIAL_MONTH_SELECTION )
 472         {
 473             Refresh();
 474         }
 475     }
 476 }
 477
 478 bool wxGenericCalendarCtrl::EnableMonthChange(bool enable)
 479 {
 480     if ( !wxCalendarCtrlBase::EnableMonthChange(enable) )
 481         return false;
 482
 483     ShowCurrentControls();
 484     if ( GetWindowStyle() & wxCAL_SEQUENTIAL_MONTH_SELECTION )
 485         Refresh();
 486
 487     return true;
 488 }
 489
 490 // ----------------------------------------------------------------------------
 491 // changing date
 492 // ----------------------------------------------------------------------------
 493
 494 bool wxGenericCalendarCtrl::SetDate(const wxDateTime& date)
 495 {
 496     bool retval = true;
 497
 498     bool sameMonth = m_date.GetMonth() == date.GetMonth(),
 499          sameYear = m_date.GetYear() == date.GetYear();
 500
 501     if ( IsDateInRange(date) )
 502     {
 503         if ( sameMonth && sameYear )
 504         {
 505             // just change the day
 506             ChangeDay(date);
 507         }
 508         else
 509         {
 510             if ( AllowMonthChange() && (AllowYearChange() || sameYear) )
 511             {
 512                 // change everything
 513                 m_date = date;
 514
 515                 if ( !(GetWindowStyle() & wxCAL_SEQUENTIAL_MONTH_SELECTION) )
 516                 {
 517                     // update the controls
 518                     m_comboMonth->SetSelection(m_date.GetMonth());
 519
 520                     if ( AllowYearChange() )
 521                     {
 522                         if ( !m_userChangedYear )
 523                             m_spinYear->SetValue(m_date.Format(_T("%Y")));
 524                     }
 525                 }
 526
 527                 // as the month changed, holidays did too
 528                 SetHolidayAttrs();
 529
 530                 // update the calendar
 531                 Refresh();
 532             }
 533             else
 534             {
 535                 // forbidden
 536                 retval = false;
 537             }
 538         }
 539     }
 540
 541     m_userChangedYear = false;
 542
 543     return retval;
 544 }
 545
 546 void wxGenericCalendarCtrl::ChangeDay(const wxDateTime& date)
 547 {
 548     if ( m_date != date )
 549     {
 550         // we need to refresh the row containing the old date and the one
 551         // containing the new one
 552         wxDateTime dateOld = m_date;
 553         m_date = date;
 554
 555         RefreshDate(dateOld);
 556
 557         // if the date is in the same row, it was already drawn correctly
 558         if ( GetWeek(m_date) != GetWeek(dateOld) )
 559         {
 560             RefreshDate(m_date);
 561         }
 562     }
 563 }
 564
 565 void wxGenericCalendarCtrl::SetDateAndNotify(const wxDateTime& date)
 566 {
 567     const wxDateTime dateOld = GetDate();
 568     if ( date != dateOld && SetDate(date) )
 569     {
 570         GenerateAllChangeEvents(dateOld);
 571     }
 572 }
 573
 574 // ----------------------------------------------------------------------------
 575 // date range
 576 // ----------------------------------------------------------------------------
 577
 578 bool wxGenericCalendarCtrl::SetLowerDateLimit(const wxDateTime& date /* = wxDefaultDateTime */)
 579 {
 580     bool retval = true;
 581
 582     if ( !(date.IsValid()) || ( ( m_highdate.IsValid() ) ? ( date <= m_highdate ) : true ) )
 583     {
 584         m_lowdate = date;
 585     }
 586     else
 587     {
 588         retval = false;
 589     }
 590
 591     return retval;
 592 }
 593
 594 bool wxGenericCalendarCtrl::SetUpperDateLimit(const wxDateTime& date /* = wxDefaultDateTime */)
 595 {
 596     bool retval = true;
 597
 598     if ( !(date.IsValid()) || ( ( m_lowdate.IsValid() ) ? ( date >= m_lowdate ) : true ) )
 599     {
 600         m_highdate = date;
 601     }
 602     else
 603     {
 604         retval = false;
 605     }
 606
 607     return retval;
 608 }
 609
 610 bool wxGenericCalendarCtrl::SetDateRange(const wxDateTime& lowerdate /* = wxDefaultDateTime */, const wxDateTime& upperdate /* = wxDefaultDateTime */)
 611 {
 612     bool retval = true;
 613
 614     if (
 615         ( !( lowerdate.IsValid() ) || ( ( upperdate.IsValid() ) ? ( lowerdate <= upperdate ) : true ) ) &&
 616         ( !( upperdate.IsValid() ) || ( ( lowerdate.IsValid() ) ? ( upperdate >= lowerdate ) : true ) ) )
 617     {
 618         m_lowdate = lowerdate;
 619         m_highdate = upperdate;
 620     }
 621     else
 622     {
 623         retval = false;
 624     }
 625
 626     return retval;
 627 }
 628
 629 bool wxGenericCalendarCtrl::GetDateRange(wxDateTime *lowerdate,
 630                                          wxDateTime *upperdate) const
 631 {
 632     if ( lowerdate )
 633         *lowerdate = m_lowdate;
 634     if ( upperdate )
 635         *upperdate = m_highdate;
 636
 637     return m_lowdate.IsValid() || m_highdate.IsValid();
 638 }
 639
 640 // ----------------------------------------------------------------------------
 641 // date helpers
 642 // ----------------------------------------------------------------------------
 643
 644 wxDateTime wxGenericCalendarCtrl::GetStartDate() const
 645 {
 646     wxDateTime::Tm tm = m_date.GetTm();
 647
 648     wxDateTime date = wxDateTime(1, tm.mon, tm.year);
 649
 650     // rewind back
 651     date.SetToPrevWeekDay(GetWindowStyle() & wxCAL_MONDAY_FIRST
 652                           ? wxDateTime::Mon : wxDateTime::Sun);
 653
 654     if ( GetWindowStyle() & wxCAL_SHOW_SURROUNDING_WEEKS )
 655     {
 656         // We want to offset the calendar if we start on the first..
 657         if ( date.GetDay() == 1 )
 658         {
 659             date -= wxDateSpan::Week();
 660         }
 661     }
 662
 663     return date;
 664 }
 665
 666 bool wxGenericCalendarCtrl::IsDateShown(const wxDateTime& date) const
 667 {
 668     if ( !(GetWindowStyle() & wxCAL_SHOW_SURROUNDING_WEEKS) )
 669     {
 670         return date.GetMonth() == m_date.GetMonth();
 671     }
 672     else
 673     {
 674         return true;
 675     }
 676 }
 677
 678 bool wxGenericCalendarCtrl::IsDateInRange(const wxDateTime& date) const
 679 {
 680     // Check if the given date is in the range specified
 681     return ( ( ( m_lowdate.IsValid() ) ? ( date >= m_lowdate ) : true )
 682         && ( ( m_highdate.IsValid() ) ? ( date <= m_highdate ) : true ) );
 683 }
 684
 685 bool wxGenericCalendarCtrl::ChangeYear(wxDateTime* target) const
 686 {
 687     bool retval = false;
 688
 689     if ( !(IsDateInRange(*target)) )
 690     {
 691         if ( target->GetYear() < m_date.GetYear() )
 692         {
 693             if ( target->GetYear() >= GetLowerDateLimit().GetYear() )
 694             {
 695                 *target = GetLowerDateLimit();
 696                 retval = true;
 697             }
 698             else
 699             {
 700                 *target = m_date;
 701             }
 702         }
 703         else
 704         {
 705             if ( target->GetYear() <= GetUpperDateLimit().GetYear() )
 706             {
 707                 *target = GetUpperDateLimit();
 708                 retval = true;
 709             }
 710             else
 711             {
 712                 *target = m_date;
 713             }
 714         }
 715     }
 716     else
 717     {
 718         retval = true;
 719     }
 720
 721     return retval;
 722 }
 723
 724 bool wxGenericCalendarCtrl::ChangeMonth(wxDateTime* target) const
 725 {
 726     bool retval = true;
 727
 728     if ( !(IsDateInRange(*target)) )
 729     {
 730         retval = false;
 731
 732         if ( target->GetMonth() < m_date.GetMonth() )
 733         {
 734             *target = GetLowerDateLimit();
 735         }
 736         else
 737         {
 738             *target = GetUpperDateLimit();
 739         }
 740     }
 741
 742     return retval;
 743 }
 744
 745 size_t wxGenericCalendarCtrl::GetWeek(const wxDateTime& date) const
 746 {
 747     size_t retval = date.GetWeekOfMonth(GetWindowStyle() & wxCAL_MONDAY_FIRST
 748                                    ? wxDateTime::Monday_First
 749                                    : wxDateTime::Sunday_First);
 750
 751     if ( (GetWindowStyle() & wxCAL_SHOW_SURROUNDING_WEEKS) )
 752     {
 753         // we need to offset an extra week if we "start" on the 1st of the month
 754         wxDateTime::Tm tm = date.GetTm();
 755
 756         wxDateTime datetest = wxDateTime(1, tm.mon, tm.year);
 757
 758         // rewind back
 759         datetest.SetToPrevWeekDay(GetWindowStyle() & wxCAL_MONDAY_FIRST
 760                               ? wxDateTime::Mon : wxDateTime::Sun);
 761
 762         if ( datetest.GetDay() == 1 )
 763         {
 764             retval += 1;
 765         }
 766     }
 767
 768     return retval;
 769 }
 770
 771 // ----------------------------------------------------------------------------
 772 // size management
 773 // ----------------------------------------------------------------------------
 774
 775 // this is a composite control and it must arrange its parts each time its
 776 // size or position changes: the combobox and spinctrl are along the top of
 777 // the available area and the calendar takes up the rest of the space
 778
 779 // the static controls are supposed to be always smaller than combo/spin so we
 780 // always use the latter for size calculations and position the static to take
 781 // the same space
 782
 783 // the constants used for the layout
 784 #define VERT_MARGIN    5           // distance between combo and calendar
 785 #define HORZ_MARGIN    5           //                            spin
 786
 787 wxSize wxGenericCalendarCtrl::DoGetBestSize() const
 788 {
 789     // calc the size of the calendar
 790     const_cast<wxGenericCalendarCtrl *>(this)->RecalcGeometry();
 791
 792     wxCoord width = 7*m_widthCol + m_calendarWeekWidth,
 793             height = 7*m_heightRow + m_rowOffset + VERT_MARGIN;
 794
 795     if ( !HasFlag(wxCAL_SEQUENTIAL_MONTH_SELECTION) )
 796     {
 797         const wxSize bestSizeCombo = m_comboMonth->GetBestSize();
 798
 799         height += wxMax(bestSizeCombo.y, m_spinYear->GetBestSize().y)
 800                     + VERT_MARGIN;
 801 #ifdef __WXMAC__
 802         // the spin control get clipped otherwise
 803         width += 10;
 804 #endif
 805
 806         wxCoord w2 = bestSizeCombo.x + HORZ_MARGIN + GetCharWidth()*6;
 807         if ( width < w2 )
 808             width = w2;
 809     }
 810
 811     wxSize best(width, height);
 812     if ( !HasFlag(wxBORDER_NONE) )
 813     {
 814         best += GetWindowBorderSize();
 815     }
 816
 817     CacheBestSize(best);
 818
 819     return best;
 820 }
 821
 822 void wxGenericCalendarCtrl::DoMoveWindow(int x, int y, int width, int height)
 823 {
 824     int yDiff;
 825
 826     if ( !HasFlag(wxCAL_SEQUENTIAL_MONTH_SELECTION) && m_staticMonth )
 827     {
 828         wxSize sizeCombo = m_comboMonth->GetEffectiveMinSize();
 829         wxSize sizeStatic = m_staticMonth->GetSize();
 830         wxSize sizeSpin = m_spinYear->GetSize();
 831
 832         int maxHeight = wxMax(sizeSpin.y, sizeCombo.y);
 833         int dy = (maxHeight - sizeStatic.y) / 2;
 834 #ifdef __WXMAC__
 835         m_comboMonth->Move(x, y + (maxHeight - sizeCombo.y)/2 + 2); // FIXME, something is reporting the wrong size..
 836 #else
 837         m_comboMonth->Move(x, y + (maxHeight - sizeCombo.y)/2);
 838 #endif
 839         m_staticMonth->SetSize(x, y + dy, sizeCombo.x, -1, sizeStatic.y);
 840
 841         int xDiff = sizeCombo.x + HORZ_MARGIN;
 842
 843         m_spinYear->SetSize(x + xDiff, y + (maxHeight - sizeSpin.y)/2, width - xDiff, maxHeight);
 844         m_staticYear->SetSize(x + xDiff, y + dy, width - xDiff, sizeStatic.y);
 845
 846         yDiff = maxHeight + VERT_MARGIN;
 847     }
 848     else // no controls on the top
 849     {
 850         yDiff = 0;
 851     }
 852
 853     wxControl::DoMoveWindow(x, y + yDiff, width, height - yDiff);
 854 }
 855
 856 void wxGenericCalendarCtrl::DoGetSize(int *width, int *height) const
 857 {
 858 #ifdef __WXMAC__
 859     wxControl::DoGetSize( width, height );
 860
 861     if ( !HasFlag(wxCAL_SEQUENTIAL_MONTH_SELECTION) && m_staticMonth && height )
 862     {
 863         wxSize sizeCombo = m_comboMonth->GetEffectiveMinSize();
 864         wxSize sizeSpin = m_spinYear->GetSize();
 865
 866         int maxHeight = wxMax(sizeSpin.y, sizeCombo.y);
 867         *height += maxHeight + VERT_MARGIN;
 868     }
 869 #else
 870     wxControl::DoGetSize( width, height );
 871 #endif
 872 }
 873
 874 void wxGenericCalendarCtrl::RecalcGeometry()
 875 {
 876     wxClientDC dc(this);
 877
 878     dc.SetFont(GetFont());
 879
 880     // determine the column width (weekday names are not necessarily wider
 881     // than the numbers (in some languages), so let's not assume that they are)
 882     m_widthCol = 0;
 883     for ( int day = 10; day <= 31; day++)
 884     {
 885         wxCoord width;
 886         dc.GetTextExtent(wxString::Format(wxT("%d"), day), &width, &m_heightRow);
 887         if ( width > m_widthCol )
 888         {
 889             // 1.5 times the width gives nice margins even if the weekday
 890             // names are short
 891             m_widthCol = width+width/2;
 892         }
 893     }
 894     wxDateTime::WeekDay wd;
 895     for ( wd = wxDateTime::Sun; wd < wxDateTime::Inv_WeekDay; wxNextWDay(wd) )
 896     {
 897         wxCoord width;
 898         dc.GetTextExtent(m_weekdays[wd], &width, &m_heightRow);
 899         if ( width > m_widthCol )
 900         {
 901             m_widthCol = width;
 902         }
 903     }
 904
 905     m_calendarWeekWidth = HasFlag( wxCAL_SHOW_WEEK_NUMBERS )
 906         ? dc.GetTextExtent( wxString::Format( wxT( "%d" ), 42 )).GetWidth() + 4 : 0;
 907
 908     // leave some margins
 909     m_widthCol += 2;
 910     m_heightRow += 2;
 911
 912     m_rowOffset = HasFlag(wxCAL_SEQUENTIAL_MONTH_SELECTION) ? m_heightRow : 0; // conditional in relation to style
 913 }
 914
 915 // ----------------------------------------------------------------------------
 916 // drawing
 917 // ----------------------------------------------------------------------------
 918
 919 void wxGenericCalendarCtrl::OnPaint(wxPaintEvent& WXUNUSED(event))
 920 {
 921     wxPaintDC dc(this);
 922
 923     dc.SetFont(GetFont());
 924
 925     RecalcGeometry();
 926
 927 #if DEBUG_PAINT
 928     wxLogDebug("--- starting to paint, selection: %s, week %u\n",
 929            m_date.Format("%a %d-%m-%Y %H:%M:%S").c_str(),
 930            GetWeek(m_date));
 931 #endif
 932
 933     wxCoord y = 0;
 934     wxCoord x0 = m_calendarWeekWidth;
 935
 936     if ( HasFlag(wxCAL_SEQUENTIAL_MONTH_SELECTION) )
 937     {
 938         // draw the sequential month-selector
 939
 940         dc.SetBackgroundMode(wxBRUSHSTYLE_TRANSPARENT);
 941         dc.SetTextForeground(*wxBLACK);
 942         dc.SetBrush(wxBrush(m_colHeaderBg, wxBRUSHSTYLE_SOLID));
 943         dc.SetPen(wxPen(m_colHeaderBg, 1, wxPENSTYLE_SOLID));
 944         dc.DrawRectangle(0, y, GetClientSize().x, m_heightRow);
 945
 946         // Get extent of month-name + year
 947         wxCoord monthw, monthh;
 948         wxString headertext = m_date.Format(wxT("%B %Y"));
 949         dc.GetTextExtent(headertext, &monthw, &monthh);
 950
 951         // draw month-name centered above weekdays
 952         wxCoord monthx = ((m_widthCol * 7) - monthw) / 2 + x0;
 953         wxCoord monthy = ((m_heightRow - monthh) / 2) + y;
 954         dc.DrawText(headertext, monthx,  monthy);
 955
 956         // calculate the "month-arrows"
 957         wxPoint leftarrow[3];
 958         wxPoint rightarrow[3];
 959
 960         int arrowheight = monthh / 2;
 961
 962         leftarrow[0] = wxPoint(0, arrowheight / 2);
 963         leftarrow[1] = wxPoint(arrowheight / 2, 0);
 964         leftarrow[2] = wxPoint(arrowheight / 2, arrowheight - 1);
 965
 966         rightarrow[0] = wxPoint(0,0);
 967         rightarrow[1] = wxPoint(arrowheight / 2, arrowheight / 2);
 968         rightarrow[2] = wxPoint(0, arrowheight - 1);
 969
 970         // draw the "month-arrows"
 971
 972         wxCoord arrowy = (m_heightRow - arrowheight) / 2;
 973         wxCoord larrowx = (m_widthCol - (arrowheight / 2)) / 2 + x0;
 974         wxCoord rarrowx = ((m_widthCol - (arrowheight / 2)) / 2) + m_widthCol*6 + x0;
 975         m_leftArrowRect = m_rightArrowRect = wxRect(0,0,0,0);
 976
 977         if ( AllowMonthChange() )
 978         {
 979             wxDateTime ldpm = wxDateTime(1,m_date.GetMonth(), m_date.GetYear()) - wxDateSpan::Day(); // last day prev month
 980             // Check if range permits change
 981             if ( IsDateInRange(ldpm) && ( ( ldpm.GetYear() == m_date.GetYear() ) ? true : AllowYearChange() ) )
 982             {
 983                 m_leftArrowRect = wxRect(larrowx - 3, arrowy - 3, (arrowheight / 2) + 8, (arrowheight + 6));
 984                 dc.SetBrush(*wxBLACK_BRUSH);
 985                 dc.SetPen(*wxBLACK_PEN);
 986                 dc.DrawPolygon(3, leftarrow, larrowx , arrowy, wxWINDING_RULE);
 987                 dc.SetBrush(*wxTRANSPARENT_BRUSH);
 988                 dc.DrawRectangle(m_leftArrowRect);
 989             }
 990             wxDateTime fdnm = wxDateTime(1,m_date.GetMonth(), m_date.GetYear()) + wxDateSpan::Month(); // first day next month
 991             if ( IsDateInRange(fdnm) && ( ( fdnm.GetYear() == m_date.GetYear() ) ? true : AllowYearChange() ) )
 992             {
 993                 m_rightArrowRect = wxRect(rarrowx - 4, arrowy - 3, (arrowheight / 2) + 8, (arrowheight + 6));
 994                 dc.SetBrush(*wxBLACK_BRUSH);
 995                 dc.SetPen(*wxBLACK_PEN);
 996                 dc.DrawPolygon(3, rightarrow, rarrowx , arrowy, wxWINDING_RULE);
 997                 dc.SetBrush(*wxTRANSPARENT_BRUSH);
 998                 dc.DrawRectangle(m_rightArrowRect);
 999             }
1000         }
1001
1002         y += m_heightRow;
1003     }
1004
1005     // first draw the week days
1006     if ( IsExposed(x0, y, x0 + 7*m_widthCol, m_heightRow) )
1007     {
1008 #if DEBUG_PAINT
1009         wxLogDebug("painting the header");
1010 #endif
1011
1012         dc.SetBackgroundMode(wxBRUSHSTYLE_TRANSPARENT);
1013         dc.SetTextForeground(m_colHeaderFg);
1014         dc.SetBrush(wxBrush(m_colHeaderBg, wxBRUSHSTYLE_SOLID));
1015         dc.SetPen(wxPen(m_colHeaderBg, 1, wxPENSTYLE_SOLID));
1016         dc.DrawRectangle(0, y, GetClientSize().x, m_heightRow);
1017
1018         bool startOnMonday = (GetWindowStyle() & wxCAL_MONDAY_FIRST) != 0;
1019         for ( int wd = 0; wd < 7; wd++ )
1020         {
1021             size_t n;
1022             if ( startOnMonday )
1023                 n = wd == 6 ? 0 : wd + 1;
1024             else
1025                 n = wd;
1026             wxCoord dayw, dayh;
1027             dc.GetTextExtent(m_weekdays[n], &dayw, &dayh);
1028             dc.DrawText(m_weekdays[n], x0 + (wd*m_widthCol) + ((m_widthCol- dayw) / 2), y); // center the day-name
1029         }
1030     }
1031
1032     // then the calendar itself
1033     dc.SetTextForeground(*wxBLACK);
1034     //dc.SetFont(*wxNORMAL_FONT);
1035
1036     y += m_heightRow;
1037
1038     // draw column with calendar week nr
1039     if ( HasFlag( wxCAL_SHOW_WEEK_NUMBERS ) && IsExposed( 0, y, m_calendarWeekWidth, m_heightRow * 6 ))
1040     {
1041         dc.SetBackgroundMode(wxTRANSPARENT);
1042         dc.SetBrush(wxBrush(m_colHeaderBg, wxSOLID));
1043         dc.SetPen(wxPen(m_colHeaderBg, 1, wxSOLID));
1044         dc.DrawRectangle( 0, y, m_calendarWeekWidth, m_heightRow * 6 );
1045         wxDateTime date = GetStartDate();
1046         for ( size_t i = 0; i < 6; ++i )
1047         {
1048             const int weekNr = date.GetWeekOfYear();
1049             wxString text = wxString::Format( wxT( "%d" ), weekNr );
1050             dc.DrawText( text, m_calendarWeekWidth - dc.GetTextExtent( text ).GetWidth() - 2, y + m_heightRow * i );
1051             date += wxDateSpan::Week();
1052         }
1053     }
1054
1055     wxDateTime date = GetStartDate();
1056
1057 #if DEBUG_PAINT
1058     wxLogDebug("starting calendar from %s\n",
1059             date.Format("%a %d-%m-%Y %H:%M:%S").c_str());
1060 #endif
1061
1062     dc.SetBackgroundMode(wxBRUSHSTYLE_SOLID);
1063     for ( size_t nWeek = 1; nWeek <= 6; nWeek++, y += m_heightRow )
1064     {
1065         // if the update region doesn't intersect this row, don't paint it
1066         if ( !IsExposed(x0, y, x0 + 7*m_widthCol, m_heightRow - 1) )
1067         {
1068             date += wxDateSpan::Week();
1069
1070             continue;
1071         }
1072
1073 #if DEBUG_PAINT
1074         wxLogDebug("painting week %d at y = %d\n", nWeek, y);
1075 #endif
1076
1077         for ( int wd = 0; wd < 7; wd++ )
1078         {
1079             dc.SetTextBackground(m_colBackground);
1080             if ( IsDateShown(date) )
1081             {
1082                 // don't use wxDate::Format() which prepends 0s
1083                 unsigned int day = date.GetDay();
1084                 wxString dayStr = wxString::Format(_T("%u"), day);
1085                 wxCoord width;
1086                 dc.GetTextExtent(dayStr, &width, NULL);
1087
1088                 bool changedColours = false,
1089                      changedFont = false;
1090
1091                 bool isSel = false;
1092                 wxCalendarDateAttr *attr = NULL;
1093
1094                 if ( date.GetMonth() != m_date.GetMonth() || !IsDateInRange(date) )
1095                 {
1096                     // draw the days of adjacent months in different colour
1097                     dc.SetTextForeground(m_colSurrounding);
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 optimization in
1238     // OnClick() below to work
1239     rect.x = m_calendarWeekWidth;
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 = m_calendarWeekWidth;
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_WEEK:
1481         {
1482             wxCalendarEvent send( this, date, wxEVT_CALENDAR_WEEK_CLICKED );
1483             HandleWindowEvent( send );
1484         }
1485         break;
1486
1487         case wxCAL_HITTEST_HEADER:
1488             {
1489                 wxCalendarEvent eventWd(this, GetDate(),
1490                                         wxEVT_CALENDAR_WEEKDAY_CLICKED);
1491                 eventWd.SetWeekDay(wday);
1492                 (void)GetEventHandler()->ProcessEvent(eventWd);
1493             }
1494             break;
1495
1496         case wxCAL_HITTEST_DECMONTH:
1497         case wxCAL_HITTEST_INCMONTH:
1498         case wxCAL_HITTEST_SURROUNDING_WEEK:
1499             SetDateAndNotify(date); // we probably only want to refresh the control. No notification.. (maybe as an option?)
1500             break;
1501
1502         default:
1503             wxFAIL_MSG(_T("unknown hittest code"));
1504             // fall through
1505
1506         case wxCAL_HITTEST_NOWHERE:
1507             event.Skip();
1508             break;
1509     }
1510
1511     // as we don't (always) skip the message, we're not going to receive the
1512     // focus on click by default if we don't do it ourselves
1513     SetFocus();
1514 }
1515
1516 wxCalendarHitTestResult wxGenericCalendarCtrl::HitTest(const wxPoint& pos,
1517                                                 wxDateTime *date,
1518                                                 wxDateTime::WeekDay *wd)
1519 {
1520     RecalcGeometry();
1521
1522     // the position where the calendar really begins
1523     wxCoord x0 = m_calendarWeekWidth;
1524
1525     if ( HasFlag(wxCAL_SEQUENTIAL_MONTH_SELECTION) )
1526     {
1527         // Header: month
1528
1529         // we need to find out if the hit is on left arrow, on month or on right arrow
1530         // left arrow?
1531         if ( m_leftArrowRect.Contains(pos) )
1532         {
1533             if ( date )
1534             {
1535                 if ( IsDateInRange(m_date - wxDateSpan::Month()) )
1536                 {
1537                     *date = m_date - wxDateSpan::Month();
1538                 }
1539                 else
1540                 {
1541                     *date = GetLowerDateLimit();
1542                 }
1543             }
1544
1545             return wxCAL_HITTEST_DECMONTH;
1546         }
1547
1548         if ( m_rightArrowRect.Contains(pos) )
1549         {
1550             if ( date )
1551             {
1552                 if ( IsDateInRange(m_date + wxDateSpan::Month()) )
1553                 {
1554                     *date = m_date + wxDateSpan::Month();
1555                 }
1556                 else
1557                 {
1558                     *date = GetUpperDateLimit();
1559                 }
1560             }
1561
1562             return wxCAL_HITTEST_INCMONTH;
1563         }
1564     }
1565
1566     if ( pos.x - x0 < 0 )
1567         if ( pos.x >= 0 && pos.y > m_rowOffset + m_heightRow && pos.y <= m_rowOffset + m_heightRow * 7 )
1568         {
1569             if ( date )
1570             {
1571                 *date = GetStartDate();
1572                 *date += wxDateSpan::Week() * (( pos.y - m_rowOffset ) / m_heightRow - 1 );
1573             }
1574             if ( wd )
1575                 *wd = ( GetWindowStyle() & wxCAL_MONDAY_FIRST ) ? wxDateTime::Mon : wxDateTime::Sun;
1576             return wxCAL_HITTEST_WEEK;
1577         }
1578         else    // early exit -> the rest of the function checks for clicks on days
1579             return wxCAL_HITTEST_NOWHERE;
1580
1581     // header: week days
1582     int wday = (pos.x - x0) / m_widthCol;
1583     if ( wday > 6 )
1584         return wxCAL_HITTEST_NOWHERE;
1585     if ( pos.y < (m_heightRow + m_rowOffset))
1586     {
1587         if ( pos.y > m_rowOffset )
1588         {
1589             if ( wd )
1590             {
1591                 if ( GetWindowStyle() & wxCAL_MONDAY_FIRST )
1592                 {
1593                     wday = wday == 6 ? 0 : wday + 1;
1594                 }
1595
1596                 *wd = (wxDateTime::WeekDay)wday;
1597             }
1598
1599             return wxCAL_HITTEST_HEADER;
1600         }
1601         else
1602         {
1603             return wxCAL_HITTEST_NOWHERE;
1604         }
1605     }
1606
1607     int week = (pos.y - (m_heightRow + m_rowOffset)) / m_heightRow;
1608     if ( week >= 6 || wday >= 7 )
1609     {
1610         return wxCAL_HITTEST_NOWHERE;
1611     }
1612
1613     wxDateTime dt = GetStartDate() + wxDateSpan::Days(7*week + wday);
1614
1615     if ( IsDateShown(dt) )
1616     {
1617         if ( date )
1618             *date = dt;
1619
1620         if ( dt.GetMonth() == m_date.GetMonth() )
1621         {
1622
1623             return wxCAL_HITTEST_DAY;
1624         }
1625         else
1626         {
1627             return wxCAL_HITTEST_SURROUNDING_WEEK;
1628         }
1629     }
1630     else
1631     {
1632         return wxCAL_HITTEST_NOWHERE;
1633     }
1634 }
1635
1636 // ----------------------------------------------------------------------------
1637 // subcontrols events handling
1638 // ----------------------------------------------------------------------------
1639
1640 void wxGenericCalendarCtrl::OnMonthChange(wxCommandEvent& event)
1641 {
1642     wxDateTime::Tm tm = m_date.GetTm();
1643
1644     wxDateTime::Month mon = (wxDateTime::Month)event.GetInt();
1645     if ( tm.mday > wxDateTime::GetNumberOfDays(mon, tm.year) )
1646     {
1647         tm.mday = wxDateTime::GetNumberOfDays(mon, tm.year);
1648     }
1649
1650     wxDateTime target = wxDateTime(tm.mday, mon, tm.year);
1651
1652     ChangeMonth(&target);
1653     SetDateAndNotify(target);
1654 }
1655
1656 void wxGenericCalendarCtrl::HandleYearChange(wxCommandEvent& event)
1657 {
1658     int year = (int)event.GetInt();
1659     if ( year == INT_MIN )
1660     {
1661         // invalid year in the spin control, ignore it
1662         return;
1663     }
1664
1665     wxDateTime::Tm tm = m_date.GetTm();
1666
1667     if ( tm.mday > wxDateTime::GetNumberOfDays(tm.mon, year) )
1668     {
1669         tm.mday = wxDateTime::GetNumberOfDays(tm.mon, year);
1670     }
1671
1672     wxDateTime target = wxDateTime(tm.mday, tm.mon, year);
1673
1674     if ( ChangeYear(&target) )
1675     {
1676         SetDateAndNotify(target);
1677     }
1678     else
1679     {
1680         // In this case we don't want to change the date. That would put us
1681         // inside the same year but a strange number of months forward/back..
1682         m_spinYear->SetValue(target.GetYear());
1683     }
1684 }
1685
1686 void wxGenericCalendarCtrl::OnYearChange(wxSpinEvent& event)
1687 {
1688     HandleYearChange( event );
1689 }
1690
1691 void wxGenericCalendarCtrl::OnYearTextChange(wxCommandEvent& event)
1692 {
1693     SetUserChangedYear();
1694     HandleYearChange(event);
1695 }
1696
1697 // Responds to colour changes, and passes event on to children.
1698 void wxGenericCalendarCtrl::OnSysColourChanged(wxSysColourChangedEvent& event)
1699 {
1700     // reinit colours
1701     InitColours();
1702
1703     // Propagate the event to the children
1704     wxControl::OnSysColourChanged(event);
1705
1706     // Redraw control area
1707     SetBackgroundColour(m_colBackground);
1708     Refresh();
1709 }
1710
1711 // ----------------------------------------------------------------------------
1712 // keyboard interface
1713 // ----------------------------------------------------------------------------
1714
1715 void wxGenericCalendarCtrl::OnChar(wxKeyEvent& event)
1716 {
1717     wxDateTime target;
1718     switch ( event.GetKeyCode() )
1719     {
1720         case _T('+'):
1721         case WXK_ADD:
1722             target = m_date + wxDateSpan::Year();
1723             if ( ChangeYear(&target) )
1724             {
1725                 SetDateAndNotify(target);
1726             }
1727             break;
1728
1729         case _T('-'):
1730         case WXK_SUBTRACT:
1731             target = m_date - wxDateSpan::Year();
1732             if ( ChangeYear(&target) )
1733             {
1734                 SetDateAndNotify(target);
1735             }
1736             break;
1737
1738         case WXK_PAGEUP:
1739             target = m_date - wxDateSpan::Month();
1740             ChangeMonth(&target);
1741             SetDateAndNotify(target); // always
1742             break;
1743
1744         case WXK_PAGEDOWN:
1745             target = m_date + wxDateSpan::Month();
1746             ChangeMonth(&target);
1747             SetDateAndNotify(target); // always
1748             break;
1749
1750         case WXK_RIGHT:
1751             if ( event.ControlDown() )
1752             {
1753                 target = wxDateTime(m_date).SetToNextWeekDay(
1754                                  GetWindowStyle() & wxCAL_MONDAY_FIRST
1755                                  ? wxDateTime::Sun : wxDateTime::Sat);
1756                 if ( !IsDateInRange(target) )
1757                 {
1758                     target = GetUpperDateLimit();
1759                 }
1760                 SetDateAndNotify(target);
1761             }
1762             else
1763                 SetDateAndNotify(m_date + wxDateSpan::Day());
1764             break;
1765
1766         case WXK_LEFT:
1767             if ( event.ControlDown() )
1768             {
1769                 target = wxDateTime(m_date).SetToPrevWeekDay(
1770                                  GetWindowStyle() & wxCAL_MONDAY_FIRST
1771                                  ? wxDateTime::Mon : wxDateTime::Sun);
1772                 if ( !IsDateInRange(target) )
1773                 {
1774                     target = GetLowerDateLimit();
1775                 }
1776                 SetDateAndNotify(target);
1777             }
1778             else
1779                 SetDateAndNotify(m_date - wxDateSpan::Day());
1780             break;
1781
1782         case WXK_UP:
1783             SetDateAndNotify(m_date - wxDateSpan::Week());
1784             break;
1785
1786         case WXK_DOWN:
1787             SetDateAndNotify(m_date + wxDateSpan::Week());
1788             break;
1789
1790         case WXK_HOME:
1791             if ( event.ControlDown() )
1792                 SetDateAndNotify(wxDateTime::Today());
1793             else
1794                 SetDateAndNotify(wxDateTime(1, m_date.GetMonth(), m_date.GetYear()));
1795             break;
1796
1797         case WXK_END:
1798             SetDateAndNotify(wxDateTime(m_date).SetToLastMonthDay());
1799             break;
1800
1801         case WXK_RETURN:
1802             GenerateEvent(wxEVT_CALENDAR_DOUBLECLICKED);
1803             break;
1804
1805         default:
1806             event.Skip();
1807     }
1808 }
1809
1810 // ----------------------------------------------------------------------------
1811 // holidays handling
1812 // ----------------------------------------------------------------------------
1813
1814 void wxGenericCalendarCtrl::SetHoliday(size_t day)
1815 {
1816     wxCHECK_RET( day > 0 && day < 32, _T("invalid day in SetHoliday") );
1817
1818     wxCalendarDateAttr *attr = GetAttr(day);
1819     if ( !attr )
1820     {
1821         attr = new wxCalendarDateAttr;
1822     }
1823
1824     attr->SetHoliday(true);
1825
1826     // can't use SetAttr() because it would delete this pointer
1827     m_attrs[day - 1] = attr;
1828 }
1829
1830 void wxGenericCalendarCtrl::ResetHolidayAttrs()
1831 {
1832     for ( size_t day = 0; day < 31; day++ )
1833     {
1834         if ( m_attrs[day] )
1835         {
1836             m_attrs[day]->SetHoliday(false);
1837         }
1838     }
1839 }
1840
1841 void wxGenericCalendarCtrl::Mark(size_t day, bool mark)
1842 {
1843     wxCHECK_RET( day > 0 && day < 32, _T("invalid day in Mark") );
1844
1845     const wxCalendarDateAttr& m = wxCalendarDateAttr::GetMark();
1846     if (mark) {
1847         if ( m_attrs[day - 1] )
1848             AddAttr(m_attrs[day - 1], m);
1849         else
1850             SetAttr(day, new wxCalendarDateAttr(m));
1851     }
1852     else {
1853         if ( m_attrs[day - 1] )
1854             DelAttr(m_attrs[day - 1], m);
1855     }
1856 }
1857
1858 //static
1859 wxVisualAttributes
1860 wxGenericCalendarCtrl::GetClassDefaultAttributes(wxWindowVariant variant)
1861 {
1862     // Use the same color scheme as wxListBox
1863     return wxListBox::GetClassDefaultAttributes(variant);
1864 }
1865
1866 #endif // wxUSE_CALENDARCTRL