← Back to branch summary

~registry/dolphin-emu/triforce

« back to all changes in this revision

Viewing changes to Externals/wxWidgets3/src/generic/calctrlg.cpp

  • Committer: Sérgio Benjamim
  • Date: 2015-02-13 05:54:40 UTC
  • Revision ID: sergio_br2@yahoo.com.br-20150213055440-ey2rt3sjpy27km78
Dolphin Triforce branch from code.google, commit b957980 (4.0-315).

Show diffs side-by-side

added added

removed removed

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