X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/29c8694822a192934278ba0f98eaf437024c0278..3e1924dd5f5744c3e2a8973de9b3e4f372b7fd85:/src/generic/datectlg.cpp

diff --git a/src/generic/datectlg.cpp b/src/generic/datectlg.cpp
index b265e27738..5028bb79b0 100644
--- a/src/generic/datectlg.cpp
+++ b/src/generic/datectlg.cpp
@@ -1,6 +1,6 @@
 /////////////////////////////////////////////////////////////////////////////
-// Name:        generic/datectrl.cpp
-// Purpose:     generic wxDatePickerCtrl implementation
+// Name:        src/generic/datectlg.cpp
+// Purpose:     generic wxDatePickerCtrlGeneric implementation
 // Author:      Andreas Pflug
 // Modified by:
 // Created:     2005-01-19
@@ -23,532 +23,518 @@
     #pragma hdrstop
 #endif
 
+#if wxUSE_DATEPICKCTRL
+
 #include "wx/datectrl.h"
+
+// use this version if we're explicitly requested to do it or if it's the only
+// one we have
+#if !defined(wxHAS_NATIVE_DATEPICKCTRL) || \
+        (defined(wxUSE_DATEPICKCTRL_GENERIC) && wxUSE_DATEPICKCTRL_GENERIC)
+
+#ifndef WX_PRECOMP
+    #include "wx/dialog.h"
+    #include "wx/dcmemory.h"
+    #include "wx/panel.h"
+    #include "wx/textctrl.h"
+    #include "wx/valtext.h"
+#endif
+
+#ifdef wxHAS_NATIVE_DATEPICKCTRL
+    // this header is not included from wx/datectrl.h if we have a native
+    // version, but we do need it here
+    #include "wx/generic/datectrl.h"
+#else
+    // we need to define _WX_DEFINE_DATE_EVENTS_ before including wx/dateevt.h to
+    // define the event types we use if we're the only date picker control version
+    // being compiled -- otherwise it's defined in the native version implementation
+    #define _WX_DEFINE_DATE_EVENTS_
+#endif
+
+#include "wx/dateevt.h"
+
 #include "wx/calctrl.h"
+#include "wx/combo.h"
 
 // ----------------------------------------------------------------------------
 // constants
 // ----------------------------------------------------------------------------
 
-enum
-{
-    CTRLID_TXT = 101,
-    CTRLID_CAL,
-    CTRLID_BTN,
-    CTRLID_PAN
-};
-
-#ifndef DEFAULT_ITEM_WIDTH
-    #define DEFAULT_ITEM_WIDTH 100
+#if defined(__WXMSW__)
+    #define CALBORDER         0
+#else
+    #define CALBORDER         4
 #endif
 
-// ============================================================================
-// wxDatePickerCtrl implementation
-// ============================================================================
-
-BEGIN_EVENT_TABLE(wxDatePickerCtrl, wxDatePickerCtrlBase)
-    EVT_BUTTON(CTRLID_BTN, wxDatePickerCtrl::OnClick)
-    EVT_TEXT(CTRLID_TXT, wxDatePickerCtrl::OnText)
-    EVT_CHILD_FOCUS(wxDatePickerCtrl::OnChildSetFocus)
-END_EVENT_TABLE()
-
-IMPLEMENT_DYNAMIC_CLASS(wxDatePickerCtrl, wxDatePickerCtrlBase)
-
 // ----------------------------------------------------------------------------
-// creation
+// global variables
 // ----------------------------------------------------------------------------
 
-wxDatePickerCtrl::wxDatePickerCtrl(wxWindow *parent,
-                            wxWindowID id,
-                            const wxDateTime& date,
-                            const wxPoint& pos,
-                            const wxSize& size,
-                            long style,
-                            const wxString& name)
-{
-    Init();
-    Create(parent, id, date, pos, size, style, name);
-}
 
+// ----------------------------------------------------------------------------
+// local classes
+// ----------------------------------------------------------------------------
 
-bool wxDatePickerCtrl::Create(wxWindow *parent,
-                            wxWindowID id,
-                            const wxDateTime& date,
-                            const wxPoint& pos,
-                            const wxSize& size,
-                            long style,
-                            const wxString& name)
+class wxCalendarComboPopup : public wxCalendarCtrl,
+                             public wxComboPopup
 {
-    wxASSERT_MSG( !(style & wxDP_SPIN),
-                  _T("wxDP_SPIN style not supported, use wxDP_DEFAULT") );
-
-    wxString txt;
-    if (date.IsValid())
-        txt = date.FormatDate();
-
-    if ( !wxControl::Create(parent, id, pos, size,
-                            style | wxCLIP_CHILDREN | wxWANTS_CHARS,
-                            wxDefaultValidator, name) )
+public:
 
+    wxCalendarComboPopup() : wxCalendarCtrl(),
+                             wxComboPopup()
     {
-        return false;
     }
 
-    SetWindowStyle(style | wxWANTS_CHARS);
-    InheritAttributes();
-
-    wxBitmap bmp(8, 4);
+    virtual void Init()
     {
-        wxMemoryDC dc;
-
-        dc.SelectObject(bmp);
-        dc.SetBrush(wxBrush(GetBackgroundColour()));
-        dc.SetPen(wxPen(GetBackgroundColour()));
-        dc.DrawRectangle(0,0, 8,4);
-
-        dc.SetBrush(wxBrush(GetForegroundColour()));
-        dc.SetPen(wxPen(GetForegroundColour()));
-        wxPoint pt[3] = { wxPoint(0,0), wxPoint(6,0), wxPoint(3,3) };
-        dc.DrawPolygon(3, pt);
-        dc.SelectObject(wxNullBitmap);
     }
 
-    m_txt=new wxTextCtrl(this, CTRLID_TXT, txt);
-    m_txt->Connect(wxID_ANY, wxID_ANY, wxEVT_KEY_DOWN,
-                   (wxObjectEventFunction)&wxDatePickerCtrl::OnEditKey,
-                   0, this);
-    m_txt->Connect(wxID_ANY, wxID_ANY, wxEVT_KILL_FOCUS,
-                   (wxObjectEventFunction)&wxDatePickerCtrl::OnKillFocus,
-                   0, this);
-    SetFormat(wxT("%x"));
-
-    m_btn = new wxBitmapButton(this, CTRLID_BTN, bmp);
-
-    m_dlg = new wxDialog(this, CTRLID_CAL, wxEmptyString,
-                         wxDefaultPosition, wxDefaultSize,
-                         wxSIMPLE_BORDER);
-    m_dlg->SetFont(GetFont());
-
-    wxPanel *panel=new wxPanel(m_dlg, CTRLID_PAN,
-                               wxPoint(0, 0), wxDefaultSize,
-                               wxSUNKEN_BORDER);
-    m_cal = new wxCalendarCtrl(panel, CTRLID_CAL, wxDefaultDateTime,
-                               wxPoint(0,0), wxDefaultSize,
-                               wxCAL_SHOW_HOLIDAYS | wxSUNKEN_BORDER);
-    m_cal->Connect(CTRLID_CAL, CTRLID_CAL, wxEVT_CALENDAR_SEL_CHANGED,
-                   (wxObjectEventFunction)&wxDatePickerCtrl::OnSelChange,
-                   0, this);
-    m_cal->Connect(wxID_ANY, wxID_ANY, wxEVT_KEY_DOWN,
-                   (wxObjectEventFunction)&wxDatePickerCtrl::OnCalKey,
-                   0, this);
-    m_cal->Connect(CTRLID_CAL, CTRLID_CAL, wxEVT_CALENDAR_DOUBLECLICKED,
-                   (wxObjectEventFunction)&wxDatePickerCtrl::OnSelChange,
-                   0, this);
-    m_cal->Connect(CTRLID_CAL, CTRLID_CAL, wxEVT_CALENDAR_DAY_CHANGED,
-                   (wxObjectEventFunction)&wxDatePickerCtrl::OnSelChange,
-                   0, this);
-    m_cal->Connect(CTRLID_CAL, CTRLID_CAL, wxEVT_CALENDAR_MONTH_CHANGED,
-                   (wxObjectEventFunction)&wxDatePickerCtrl::OnSelChange,
-                   0, this);
-    m_cal->Connect(CTRLID_CAL, CTRLID_CAL, wxEVT_CALENDAR_YEAR_CHANGED,
-                   (wxObjectEventFunction)&wxDatePickerCtrl::OnSelChange,
-                   0, this);
-
-    wxWindow *yearControl = m_cal->GetYearControl();
-
-    Connect(wxID_ANY, wxID_ANY, wxEVT_SET_FOCUS,
-            (wxObjectEventFunction)&wxDatePickerCtrl::OnSetFocus);
-
-    wxClientDC dc(yearControl);
-    dc.SetFont(m_font);
-    wxCoord width, dummy;
-    dc.GetTextExtent(wxT("2000"), &width, &dummy);
-    width += ConvertDialogToPixels(wxSize(20,0)).x;
-
-    wxSize calSize = m_cal->GetBestSize();
-    wxSize yearSize = yearControl->GetSize();
-    yearSize.x = width;
-
-    wxPoint yearPosition = yearControl->GetPosition();
-
-#ifdef __WXMSW__
-#define CALBORDER   0
-#else
-#define CALBORDER   4
-#endif
-
-    width = yearPosition.x + yearSize.x+2+CALBORDER/2;
-    if (width < calSize.x-4)
-        width = calSize.x-4;
-
-    int calPos = (width-calSize.x)/2;
-    if (calPos == -1)
+    // NB: Don't create lazily since it didn't work that way before
+    //     wxComboCtrl was used, and changing behaviour would almost
+    //     certainly introduce new bugs.
+    virtual bool Create(wxWindow* parent)
     {
-        calPos = 0;
-        width += 2;
-    }
-    m_cal->SetSize(calPos, 0, calSize.x, calSize.y);
-    yearControl->SetSize(width-yearSize.x-CALBORDER/2, yearPosition.y,
-                         yearSize.x, yearSize.y);
-    m_cal->GetMonthControl()->Move(0, 0);
+        if ( !wxCalendarCtrl::Create(parent, wxID_ANY, wxDefaultDateTime,
+                              wxPoint(0, 0), wxDefaultSize,
+                              wxCAL_SHOW_HOLIDAYS | wxBORDER_SUNKEN) )
+            return false;
 
+        wxWindow *yearControl = wxCalendarCtrl::GetYearControl();
 
+        wxClientDC dc(yearControl);
+        dc.SetFont(yearControl->GetFont());
+        wxCoord width, dummy;
+        dc.GetTextExtent(wxT("2000"), &width, &dummy);
+        width += ConvertDialogToPixels(wxSize(20, 0)).x;
 
-    panel->SetClientSize(width+CALBORDER/2, calSize.y-2+CALBORDER);
-    m_dlg->SetClientSize(panel->GetSize());
+        wxSize calSize = wxCalendarCtrl::GetBestSize();
+        wxSize yearSize = yearControl->GetSize();
+        yearSize.x = width;
 
-    return TRUE;
-}
+        wxPoint yearPosition = yearControl->GetPosition();
 
+        SetFormat("%x");
 
-void wxDatePickerCtrl::Init()
-{
-    m_dlg = NULL;
-    m_txt = NULL;
-    m_cal = NULL;
-    m_btn = NULL;
+        width = yearPosition.x + yearSize.x+2+CALBORDER/2;
+        if (width < calSize.x-4)
+            width = calSize.x-4;
 
-    m_dropped = false;
-    m_ignoreDrop = false;
-}
+        int calPos = (width-calSize.x)/2;
+        if (calPos == -1)
+        {
+            calPos = 0;
+            width += 2;
+        }
+        wxCalendarCtrl::SetSize(calPos, 0, calSize.x, calSize.y);
+        yearControl->SetSize(width-yearSize.x-CALBORDER/2, yearPosition.y,
+                             yearSize.x, yearSize.y);
+        wxCalendarCtrl::GetMonthControl()->Move(0, 0);
 
+        m_useSize.x = width+CALBORDER/2;
+        m_useSize.y = calSize.y-2+CALBORDER;
 
-bool wxDatePickerCtrl::Destroy()
-{
-    if (m_cal)
-        m_cal->Destroy();
-    if (m_dlg)
-        m_dlg->Destroy();
-    if (m_txt)
-        m_txt->Destroy();
-    if (m_btn)
-        m_btn->Destroy();
-
-    m_dlg = NULL;
-    m_txt = NULL;
-    m_cal = NULL;
-    m_btn = NULL;
+        wxWindow* tx = m_combo->GetTextCtrl();
+        if ( !tx )
+            tx = m_combo;
 
-    return wxControl::Destroy();
-}
+        tx->Connect(wxEVT_KILL_FOCUS,
+                    wxFocusEventHandler(wxCalendarComboPopup::OnKillTextFocus),
+                    NULL, this);
 
-// ----------------------------------------------------------------------------
-// overridden base class methods
-// ----------------------------------------------------------------------------
-
-void wxDatePickerCtrl::DoMoveWindow(int x, int y, int w, int h)
-{
-    wxControl::DoMoveWindow(x, y, w, h);
-    wxSize bs=m_btn->GetBestSize();
-    int eh=m_txt->GetBestSize().y;
+        return true;
+    }
 
-    m_txt->SetSize(0, 0, w-bs.x-1, h > eh ? eh : h);
-    m_btn->SetSize(w - bs.x, 0, bs.x, h > bs.y ? bs.y : h);
+    virtual wxSize GetAdjustedSize(int WXUNUSED(minWidth),
+                                   int WXUNUSED(prefHeight),
+                                   int WXUNUSED(maxHeight))
+    {
+        return m_useSize;
+    }
 
-    if (m_dropped)
-        DropDown();
-}
+    virtual wxWindow *GetControl() { return this; }
 
-wxSize wxDatePickerCtrl::DoGetBestSize() const
-{
-    int bh=m_btn->GetBestSize().y;
-    int eh=m_txt->GetBestSize().y;
-    return wxSize(DEFAULT_ITEM_WIDTH, bh > eh ? bh : eh);
-}
+    void SetDateValue(const wxDateTime& date)
+    {
+        if ( date.IsValid() )
+        {
+            m_combo->SetText(date.Format(m_format));
+        }
+        else // invalid date
+        {
+            wxASSERT_MSG( HasDPFlag(wxDP_ALLOWNONE),
+                            _T("this control must have a valid date") );
 
+            m_combo->SetText(wxEmptyString);
+        }
 
-bool wxDatePickerCtrl::Show(bool show)
-{
-    if ( !wxControl::Show(show) )
-    {
-        return FALSE;
+        SetDate(date);
     }
 
-    if (!show)
+    bool ParseDateTime(const wxString& s, wxDateTime* pDt)
     {
-        if (m_dlg)
+        wxASSERT(pDt);
+
+        if ( !s.empty() )
         {
-            m_dlg->Hide();
-            m_dropped = false;
+            pDt->ParseFormat(s.c_str(), m_format);
+            if ( !pDt->IsValid() )
+                return false;
         }
+
+        return true;
     }
 
-    return TRUE;
-}
+    void SendDateEvent(const wxDateTime& dt)
+    {
+        //
+        // Sends both wxCalendarEvent and wxDateEvent
+        wxWindow* datePicker = m_combo->GetParent();
+
+        wxCalendarEvent cev((wxCalendarCtrl*) this, wxEVT_CALENDAR_SEL_CHANGED);
+        cev.SetEventObject(datePicker);
+        cev.SetId(datePicker->GetId());
+        cev.SetDate(dt);
+        datePicker->GetEventHandler()->ProcessEvent(cev);
+
+        wxDateEvent event(datePicker, dt, wxEVT_DATE_CHANGED);
+        datePicker->GetEventHandler()->ProcessEvent(event);
+    }
 
+private:
 
-bool wxDatePickerCtrl::Enable(bool enable)
-{
-    if ( !wxControl::Enable(enable) )
+    void OnCalKey(wxKeyEvent & ev)
     {
-        return FALSE;
+        if (ev.GetKeyCode() == WXK_ESCAPE && !ev.HasModifiers())
+            Dismiss();
+        else
+            ev.Skip();
     }
 
-    if (!enable)
+    void OnSelChange(wxCalendarEvent &ev)
     {
-        if (m_cal)
-            m_cal->Hide();
-    }
-    if (m_btn)
-        m_btn->Enable(enable);
-    return TRUE;
-}
+        m_combo->SetText(GetDate().Format(m_format));
 
-// ----------------------------------------------------------------------------
-// wxDatePickerCtrl API
-// ----------------------------------------------------------------------------
+        if ( ev.GetEventType() == wxEVT_CALENDAR_DOUBLECLICKED )
+        {
+            Dismiss();
+        }
 
-bool
-wxDatePickerCtrl::SetDateRange(const wxDateTime& lowerdate,
-                               const wxDateTime& upperdate)
-{
-    return m_cal->SetDateRange(lowerdate, upperdate);
-}
+        SendDateEvent(GetDate());
+    }
 
-bool wxDatePickerCtrl::SetFormat(const wxChar *fmt)
-{
-    wxDateTime dt;
-    dt.ParseFormat(wxT("2003-10-13"), wxT("%Y-%m-%d"));
-    wxString str=dt.Format(fmt);
-    wxChar *p=(wxChar*)str.c_str();
+    void OnKillTextFocus(wxFocusEvent &ev)
+    {
+        ev.Skip();
 
-    m_format=wxEmptyString;
+        const wxDateTime& dtOld = GetDate();
 
-    while (*p)
-    {
-        int n=wxAtoi(p);
-        if (n == dt.GetDay())
-        {
-            m_format.Append(wxT("%d"));
-            p += 2;
-        }
-        else if (n == (int)dt.GetMonth()+1)
+        wxDateTime dt;
+        wxString value = m_combo->GetValue();
+        if ( !ParseDateTime(value, &dt) )
         {
-            m_format.Append(wxT("%m"));
-            p += 2;
+            if ( !HasDPFlag(wxDP_ALLOWNONE) )
+                dt = dtOld;
         }
-        else if (n == dt.GetYear())
+
+        m_combo->SetText(GetStringValueFor(dt));
+
+        // notify that we had to change the date after validation
+        if ( (dt.IsValid() && (!dtOld.IsValid() || dt != dtOld)) ||
+                (!dt.IsValid() && dtOld.IsValid()) )
         {
-            m_format.Append(wxT("%Y"));
-            p += 4;
+            SetDate(dt);
+            SendDateEvent(dt);
         }
-        else
-            m_format.Append(*p++);
     }
 
-    if (m_txt)
+    bool HasDPFlag(int flag)
     {
-        wxStringList valList;
-        wxChar c;
-        for (c='0'; c <= '9'; c++)
-            valList.Add(wxString(c, 1));
-        wxChar *p=(wxChar*)m_format.c_str();
-        while (*p)
+        return m_combo->GetParent()->HasFlag(flag);
+    }
+
+    bool SetFormat(const wxString& fmt)
+    {
+        m_format.clear();
+
+        wxDateTime dt;
+        dt.ParseFormat(wxT("2003-10-13"), wxT("%Y-%m-%d"));
+        wxString str(dt.Format(fmt));
+
+        const wxChar *p = str.c_str();
+        while ( *p )
         {
-            if (*p == '%')
+            int n=wxAtoi(p);
+            if (n == dt.GetDay())
+            {
+                m_format.Append(wxT("%d"));
                 p += 2;
+            }
+            else if (n == (int)dt.GetMonth()+1)
+            {
+                m_format.Append(wxT("%m"));
+                p += 2;
+            }
+            else if (n == dt.GetYear())
+            {
+                m_format.Append(wxT("%Y"));
+                p += 4;
+            }
+            else if (n == (dt.GetYear() % 100))
+            {
+                if ( HasDPFlag(wxDP_SHOWCENTURY) )
+                    m_format.Append(wxT("%Y"));
+                else
+                    m_format.Append(wxT("%y"));
+                p += 2;
+            }
             else
-                valList.Add(wxString(*p++, 1));
+                m_format.Append(*p++);
         }
-        wxTextValidator tv(wxFILTER_INCLUDE_CHAR_LIST);
-        tv.SetIncludeList(valList);
 
-        m_txt->SetValidator(tv);
+        if ( m_combo )
+        {
+            wxArrayString allowedChars;
+            for ( wxChar c = _T('0'); c <= _T('9'); c++ )
+                allowedChars.Add(wxString(c, 1));
+
+            const wxChar *p2 = m_format.c_str();
+            while ( *p2 )
+            {
+                if ( *p2 == '%')
+                    p2 += 2;
+                else
+                    allowedChars.Add(wxString(*p2++, 1));
+            }
+
+    #if wxUSE_VALIDATORS
+            wxTextValidator tv(wxFILTER_INCLUDE_CHAR_LIST);
+            tv.SetIncludes(allowedChars);
+            m_combo->SetValidator(tv);
+    #endif
+
+            if ( GetDate().IsValid() )
+                m_combo->SetText(GetDate().Format(m_format));
+        }
+
+        return true;
     }
-    return true;
-}
 
+    virtual void SetStringValue(const wxString& s)
+    {
+        wxDateTime dt;
+        if ( ParseDateTime(s, &dt) )
+            SetDate(dt);
+        else if ( HasDPFlag(wxDP_ALLOWNONE) )
+            SetDate(wxInvalidDateTime);
+        //else: !wxDP_ALLOWNONE, keep the old value
+    }
 
-wxDateTime wxDatePickerCtrl::GetValue() const
-{
-    wxDateTime dt;
-    wxString txt=m_txt->GetValue();
+    virtual wxString GetStringValue() const
+    {
+        return GetStringValueFor(GetDate());
+    }
 
-    if (!txt.IsEmpty())
-        dt.ParseFormat(txt, m_format);
+private:
+    // returns either the given date representation using the current format or
+    // an empty string if it's invalid
+    wxString GetStringValueFor(const wxDateTime& dt) const
+    {
+        wxString val;
+        if ( dt.IsValid() )
+            val = dt.Format(m_format);
 
-    return dt;
-}
+        return val;
+    }
+
+    wxSize          m_useSize;
+    wxString        m_format;
+
+    DECLARE_EVENT_TABLE()
+};
+
+
+BEGIN_EVENT_TABLE(wxCalendarComboPopup, wxCalendarCtrl)
+    EVT_KEY_DOWN(wxCalendarComboPopup::OnCalKey)
+    EVT_CALENDAR_SEL_CHANGED(wxID_ANY, wxCalendarComboPopup::OnSelChange)
+    EVT_CALENDAR_DAY(wxID_ANY, wxCalendarComboPopup::OnSelChange)
+    EVT_CALENDAR_MONTH(wxID_ANY, wxCalendarComboPopup::OnSelChange)
+    EVT_CALENDAR_YEAR(wxID_ANY, wxCalendarComboPopup::OnSelChange)
+    EVT_CALENDAR(wxID_ANY, wxCalendarComboPopup::OnSelChange)
+END_EVENT_TABLE()
+
+
+// ============================================================================
+// wxDatePickerCtrlGeneric implementation
+// ============================================================================
+
+BEGIN_EVENT_TABLE(wxDatePickerCtrlGeneric, wxDatePickerCtrlBase)
+    EVT_TEXT(wxID_ANY, wxDatePickerCtrlGeneric::OnText)
+    EVT_SIZE(wxDatePickerCtrlGeneric::OnSize)
+    EVT_SET_FOCUS(wxDatePickerCtrlGeneric::OnFocus)
+END_EVENT_TABLE()
+
+#ifndef wxHAS_NATIVE_DATEPICKCTRL
+    IMPLEMENT_DYNAMIC_CLASS(wxDatePickerCtrl, wxControl)
+#endif
 
+// ----------------------------------------------------------------------------
+// creation
+// ----------------------------------------------------------------------------
 
-void wxDatePickerCtrl::SetValue(const wxDateTime& date)
+bool wxDatePickerCtrlGeneric::Create(wxWindow *parent,
+                                     wxWindowID id,
+                                     const wxDateTime& date,
+                                     const wxPoint& pos,
+                                     const wxSize& size,
+                                     long style,
+                                     const wxValidator& validator,
+                                     const wxString& name)
 {
-    if (m_cal)
+    wxASSERT_MSG( !(style & wxDP_SPIN),
+                  _T("wxDP_SPIN style not supported, use wxDP_DEFAULT") );
+
+    if ( !wxControl::Create(parent, id, pos, size,
+                            style | wxCLIP_CHILDREN | wxWANTS_CHARS | wxBORDER_NONE,
+                            validator, name) )
     {
-        if (date.IsValid())
-            m_txt->SetValue(date.FormatDate());
-        else
-            m_txt->SetValue(wxEmptyString);
+        return false;
     }
+
+    InheritAttributes();
+
+    m_combo = new wxComboCtrl(this, -1, wxEmptyString,
+                              wxDefaultPosition, wxDefaultSize);
+
+    m_combo->SetCtrlMainWnd(this);
+
+    m_popup = new wxCalendarComboPopup();
+
+#if defined(__WXMSW__)
+    // without this keyboard navigation in month control doesn't work
+    m_combo->UseAltPopupWindow();
+#endif
+    m_combo->SetPopupControl(m_popup);
+
+    m_popup->SetDateValue(date.IsValid() ? date : wxDateTime::Today());
+
+    SetInitialSize(size);
+
+    return true;
 }
 
 
-bool wxDatePickerCtrl::GetRange(wxDateTime *dt1, wxDateTime *dt2) const
+void wxDatePickerCtrlGeneric::Init()
 {
-    if (dt1)
-        *dt1 = m_cal->GetLowerDateLimit();
-    if (dt1)
-        *dt2 = m_cal->GetUpperDateLimit();
-    return true;
+    m_combo = NULL;
+    m_popup = NULL;
 }
 
+wxDatePickerCtrlGeneric::~wxDatePickerCtrlGeneric()
+{
+}
 
-void wxDatePickerCtrl::SetRange(const wxDateTime &dt1, const wxDateTime &dt2)
+bool wxDatePickerCtrlGeneric::Destroy()
 {
-    m_cal->SetDateRange(dt1, dt2);
+    if ( m_combo )
+        m_combo->Destroy();
+
+    m_combo = NULL;
+    m_popup = NULL;
+
+    return wxControl::Destroy();
 }
 
 // ----------------------------------------------------------------------------
-// event handlers
+// overridden base class methods
 // ----------------------------------------------------------------------------
 
-void wxDatePickerCtrl::DropDown(bool down)
+wxSize wxDatePickerCtrlGeneric::DoGetBestSize() const
 {
-    if (m_dlg)
-    {
-        if (down)
-        {
-            if (m_txt->GetValue().IsEmpty())
-                m_cal->SetDate(wxDateTime::Today());
-            else
-            {
-                wxDateTime dt;
-                dt.ParseFormat(m_txt->GetValue(), m_format);
-                m_cal->SetDate(dt);
-            }
-            wxPoint pos=GetParent()->ClientToScreen(GetPosition());
-
-            m_dlg->Move(pos.x, pos.y + GetSize().y);
-            m_dlg->Show();
-            m_dropped = true;
-        }
-        else
-        {
-            if (m_dropped)
-                m_dlg->Hide();
-            m_dropped = false;
-        }
-    }
+    return m_combo->GetBestSize();
 }
 
+// ----------------------------------------------------------------------------
+// wxDatePickerCtrlGeneric API
+// ----------------------------------------------------------------------------
 
-void wxDatePickerCtrl::OnChildSetFocus(wxChildFocusEvent &ev)
+bool
+wxDatePickerCtrlGeneric::SetDateRange(const wxDateTime& lowerdate,
+                                      const wxDateTime& upperdate)
 {
-    ev.Skip();
-    m_ignoreDrop = false;
+    return m_popup->SetDateRange(lowerdate, upperdate);
+}
 
-    wxWindow  *w=(wxWindow*)ev.GetEventObject();
-    while (w)
-    {
-        if (w == m_dlg)
-            return;
-        w = w->GetParent();
-    }
 
-    if (m_dropped)
-    {
-        DropDown(false);
-        if (ev.GetEventObject() == m_btn)
-            m_ignoreDrop = true;
-    }
+wxDateTime wxDatePickerCtrlGeneric::GetValue() const
+{
+    return m_popup->GetDate();
 }
 
 
-void wxDatePickerCtrl::OnClick(wxCommandEvent& event)
+void wxDatePickerCtrlGeneric::SetValue(const wxDateTime& date)
 {
-    if (m_ignoreDrop)
-    {
-        m_ignoreDrop = false;
-        m_txt->SetFocus();
-    }
-    else
-    {
-        DropDown();
-        m_cal->SetFocus();
-    }
+    m_popup->SetDateValue(date);
 }
 
 
-void wxDatePickerCtrl::OnSetFocus(wxFocusEvent &ev)
+bool wxDatePickerCtrlGeneric::GetRange(wxDateTime *dt1, wxDateTime *dt2) const
 {
-    if (m_txt)
-    {
-        m_txt->SetFocus();
-        m_txt->SetSelection(0, 100);
-    }
+    if (dt1)
+        *dt1 = m_popup->GetLowerDateLimit();
+    if (dt2)
+        *dt2 = m_popup->GetUpperDateLimit();
+    return true;
 }
 
 
-void wxDatePickerCtrl::OnKillFocus(wxFocusEvent &ev)
+void
+wxDatePickerCtrlGeneric::SetRange(const wxDateTime &dt1, const wxDateTime &dt2)
 {
-    ev.Skip();
+    m_popup->SetDateRange(dt1, dt2);
+}
 
-    wxDateTime dt;
-    dt.ParseFormat(m_txt->GetValue(), m_format);
-    if (!dt.IsValid())
-        m_txt->SetValue(wxEmptyString);
-    else
-        m_txt->SetValue(dt.Format(m_format));
+wxCalendarCtrl *wxDatePickerCtrlGeneric::GetCalendar() const
+{
+    return m_popup;
 }
 
+// ----------------------------------------------------------------------------
+// event handlers
+// ----------------------------------------------------------------------------
 
-void wxDatePickerCtrl::OnSelChange(wxCalendarEvent &ev)
+
+void wxDatePickerCtrlGeneric::OnSize(wxSizeEvent& event)
 {
-    if (m_cal)
-    {
-        m_txt->SetValue(m_cal->GetDate().FormatDate());
-        if (ev.GetEventType() == wxEVT_CALENDAR_DOUBLECLICKED)
-        {
-            DropDown(false);
-            m_txt->SetFocus();
-        }
-    }
-    ev.SetEventObject(this);
-    ev.SetId(GetId());
-    GetParent()->ProcessEvent(ev);
+    if ( m_combo )
+        m_combo->SetSize(GetClientSize());
+
+    event.Skip();
 }
 
 
-void wxDatePickerCtrl::OnText(wxCommandEvent &ev)
+void wxDatePickerCtrlGeneric::OnText(wxCommandEvent &ev)
 {
     ev.SetEventObject(this);
     ev.SetId(GetId());
-    GetParent()->ProcessEvent(ev);
+    GetParent()->GetEventHandler()->ProcessEvent(ev);
 
     // We'll create an additional event if the date is valid.
-    // If the date isn't valid, the user's probable in the middle of typing
-    wxString txt=m_txt->GetValue();
+    // If the date isn't valid, the user's probably in the middle of typing
     wxDateTime dt;
-    if (!txt.IsEmpty())
-    {
-        dt.ParseFormat(txt, m_format);
-        if (!dt.IsValid())
-            return;
-    }
+    if ( !m_popup->ParseDateTime(m_combo->GetValue(), &dt) )
+        return;
 
-    wxCalendarEvent cev(m_cal, wxEVT_CALENDAR_SEL_CHANGED);
-    cev.SetEventObject(this);
-    cev.SetId(GetId());
-    cev.SetDate(dt);
-
-    GetParent()->ProcessEvent(cev);
+    m_popup->SendDateEvent(dt);
 }
 
 
-void wxDatePickerCtrl::OnEditKey(wxKeyEvent & ev)
+void wxDatePickerCtrlGeneric::OnFocus(wxFocusEvent& WXUNUSED(event))
 {
-    if (ev.GetKeyCode() == WXK_DOWN && !ev.HasModifiers())
-        DropDown();
-    else
-        ev.Skip();
+    m_combo->SetFocus();
 }
 
 
-void wxDatePickerCtrl::OnCalKey(wxKeyEvent & ev)
-{
-    if (ev.GetKeyCode() == WXK_ESCAPE && !ev.HasModifiers())
-        DropDown(false);
-    else
-        ev.Skip();
-}
+#endif // wxUSE_DATEPICKCTRL_GENERIC
+
+#endif // wxUSE_DATEPICKCTRL