Added wxDataViewBitmapCell

[wxWidgets.git] / src / generic / datectlg.cpp

diff --git a/src/generic/datectlg.cpp b/src/generic/datectlg.cpp
index 847109b2b89e82f009277af5f00690e3dcfa8bb3..ab5d7448d7331e3d894eaf1dc6dfe9074460f01a 100644 (file)
--- 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
 // Author:      Andreas Pflug
 // Modified by:
 // Created:     2005-01-19


@@ -23,8 +23,40 @@
     #pragma hdrstop
 #endif
 
     #pragma hdrstop
 #endif
 

+#if wxUSE_DATEPICKCTRL
+

 #include "wx/datectrl.h"
 
 #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/bmpbuttn.h"
+    #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/renderer.h"
+

 // ----------------------------------------------------------------------------
 // constants
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // constants
 // ----------------------------------------------------------------------------


@@ -32,8 +64,8 @@
 enum
 {
     CTRLID_TXT = 101,
 enum
 {
     CTRLID_TXT = 101,

-    CTRLID_CAL
-    CTRLID_BTN
+    CTRLID_CAL,
+    CTRLID_BTN,

     CTRLID_PAN
 };
 
     CTRLID_PAN
 };
 


@@ -41,102 +73,415 @@ enum
     #define DEFAULT_ITEM_WIDTH 100
 #endif
 
     #define DEFAULT_ITEM_WIDTH 100
 #endif
 

-// ============================================================================
-// wxDatePickerCtrl implementation
-// ============================================================================
+#if defined(__WXMSW__)
+    #undef wxUSE_POPUPWIN
+    #define wxUSE_POPUPWIN    0  // Popup not working
+    #define TXTCTRL_FLAGS     wxNO_BORDER
+    #define CALBORDER         0
+    #define TXTPOSY           1
+#elif defined(__WXGTK__)
+    #define TXTCTRL_FLAGS     0
+    #define CALBORDER         4
+    #define TXTPOSY           0
+#else
+    #define TXTCTRL_FLAGS     0
+    #define CALBORDER         4
+    #define TXTPOSY           0
+#endif

 
 

-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()
+// ----------------------------------------------------------------------------
+// global variables
+// ----------------------------------------------------------------------------

 
 

-IMPLEMENT_DYNAMIC_CLASS(wxDatePickerCtrl, wxDatePickerCtrlBase)
+// this should have been a flag in wxDatePickerCtrlGeneric itself but adding it
+// there now would break backwards compatibility, so put it here as a global:
+// this shouldn't be a big problem as only one (GUI) thread normally can call
+// wxDatePickerCtrlGeneric::SetValue() and so it can be only ever used for one
+// control at a time
+//
+// if the value is not NULL, it points to the control which is inside SetValue()
+static wxDatePickerCtrlGeneric *gs_inSetValue = NULL;

 
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------

-// creation
+// local classes

 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 

-wxDatePickerCtrl::wxDatePickerCtrl(wxWindow *parent,
-                            wxWindowID id,
-                            const wxDateTime& date,
-                            const wxPoint& pos,
-                            const wxSize& size,
-                            long style,
-                            const wxString& name)
+// This flag indicates that combo box style drop button is to be created
+#define wxBU_COMBO          0x0400
+
+
+class wxDropdownButton : public wxBitmapButton
+{
+public:
+    wxDropdownButton() { Init(); }
+    wxDropdownButton(wxWindow *parent,
+                     wxWindowID id,
+                     const wxPoint& pos = wxDefaultPosition,
+                     const wxSize& size = wxDefaultSize,
+                     long style=0,
+                     const wxValidator& validator = wxDefaultValidator);
+
+    bool Create(wxWindow *parent,
+                wxWindowID id,
+                const wxPoint& pos = wxDefaultPosition,
+                const wxSize& size = wxDefaultSize,
+                long style = 0,
+                const wxValidator& validator = wxDefaultValidator);
+
+protected:
+    virtual void DoMoveWindow(int x, int y, int w, int h);
+
+    void OnSize(wxSizeEvent& event);
+    void OnMouseEnter(wxMouseEvent& event);
+    void OnMouseLeave(wxMouseEvent& event);
+
+    void RecreateBitmaps(int w, int h);
+
+    wxBitmap    m_bmpNormal;
+    wxBitmap    m_bmpHot;
+
+    int         m_borderX, m_borderY;
+
+    // True if DrawDropArrow should be used instead of DrawComboBoxDropButton
+    bool        m_useDropArrow;
+
+private:
+
+    void Init()
+    {
+        m_borderX = -1;
+        m_borderY = -1;
+    }
+
+    DECLARE_EVENT_TABLE()
+    DECLARE_DYNAMIC_CLASS_NO_COPY(wxDropdownButton)
+};
+
+
+// Below, macro DROPBUT_USEDROPARROW should return false when
+// DrawComboBoxDropButton is to be used to render the entire button.
+// COMBOST is non-zero if wxBU_COMBO was set.
+
+#if defined(__WXMSW__)
+
+    #define DROPBUT_USEDROPARROW(COMBOST)   (COMBOST?false:true)
+    #define DROPBUT_DEFAULT_WIDTH           17
+
+#elif defined(__WXGTK__)
+
+    #define DROPBUT_USEDROPARROW(COMBOST)   true
+    #define DROPBUT_DEFAULT_WIDTH           19
+
+#else
+
+    #define DROPBUT_USEDROPARROW(COMBOST)   true
+    #define DROPBUT_DEFAULT_WIDTH           17
+
+#endif
+
+
+IMPLEMENT_DYNAMIC_CLASS(wxDropdownButton, wxBitmapButton)
+
+
+BEGIN_EVENT_TABLE(wxDropdownButton,wxBitmapButton)
+    EVT_ENTER_WINDOW(wxDropdownButton::OnMouseEnter)
+    EVT_LEAVE_WINDOW(wxDropdownButton::OnMouseLeave)
+    EVT_SIZE(wxDropdownButton::OnSize)
+END_EVENT_TABLE()
+
+
+wxDropdownButton::wxDropdownButton(wxWindow *parent,
+                                   wxWindowID id,
+                                   const wxPoint& pos,
+                                   const wxSize& size,
+                                   long style,
+                                   const wxValidator& validator)

 {
     Init();
 {
     Init();

-    Create(parent, id, date, pos, size, style, name);
+    Create(parent, id, pos, size, style, validator);

 }
 
 
 }
 
 

-bool wxDatePickerCtrl::Create(wxWindow *parent,
-                            wxWindowID id,
-                            const wxDateTime& date,
-                            const wxPoint& pos,
-                            const wxSize& size,
-                            long style,
-                            const wxString& name)
+bool wxDropdownButton::Create(wxWindow *parent,
+                              wxWindowID id,
+                              const wxPoint& pos,
+                              const wxSize& size,
+                              long style,
+                              const wxValidator& validator)

 {
 {

-    wxString txt;
-    if (date.IsValid())
-        txt = date.FormatDate();
+    m_marginX = 0;
+    m_marginY = 0;

 
 

-    if ( !wxControl::Create(parent, id, pos, size,
-                            style | wxCLIP_CHILDREN | wxWANTS_CHARS,
-                            wxDefaultValidator, name) )
+    m_useDropArrow = DROPBUT_USEDROPARROW(style & wxBU_COMBO);

 
 

-    {
+    wxBitmap chkBmp(15,15);  // arbitrary
+    if ( !wxBitmapButton::Create(parent, id, chkBmp,
+                                 pos, wxDefaultSize,
+                                 style | (m_useDropArrow ? wxBU_AUTODRAW : wxNO_BORDER),
+                                 validator) )

         return false;
         return false;

+
+    const wxSize sz = GetSize();
+    int w = chkBmp.GetWidth(),
+        h = chkBmp.GetHeight();
+    m_borderX = sz.x - m_marginX - w;
+    m_borderY = sz.y - m_marginY - h;
+
+    DoMoveWindow(pos.x, pos.y, size.x, size.y);
+
+    return true;
+}
+
+
+void wxDropdownButton::RecreateBitmaps(int w, int h)
+{
+    wxMemoryDC dc;
+
+    int borderX = m_marginX + m_borderX;
+    int borderY = m_marginY + m_borderY;
+    int bw = w - borderX;
+    int bh = h - borderY;
+
+    wxBitmap bmp(bw, bh);
+    wxBitmap bmpSel(bw, bh);
+    wxRect r(0,0,w,h);
+
+    wxRendererNative& renderer = wxRendererNative::Get();
+
+    dc.SelectObject(bmp);
+
+    if ( m_useDropArrow )
+    {
+        // Use DrawDropArrow on transparent background.
+
+        wxColour magic(255,0,255);
+        wxBrush magicBrush(magic);
+        r.x = -(borderX/2);
+        r.y = -(borderY/2);
+
+        dc.SetBrush( magicBrush );
+        dc.SetPen( *wxTRANSPARENT_PEN );
+        dc.DrawRectangle(0,0,bw,bh);
+        renderer.DrawDropArrow(this, dc, r);
+        dc.SelectObject( wxNullBitmap );
+        wxMask *mask = new wxMask( bmp, magic );
+        bmp.SetMask( mask );
+
+        dc.SelectObject(bmpSel);
+
+        dc.SetBrush( magicBrush );
+        dc.SetPen( *wxTRANSPARENT_PEN );
+        dc.DrawRectangle(0,0,bw,bh);
+        renderer.DrawDropArrow(this, dc, r, wxCONTROL_PRESSED);
+        dc.SelectObject( wxNullBitmap );
+        mask = new wxMask( bmpSel, magic );
+        bmpSel.SetMask( mask );

     }
     }

+    else
+    {
+        // Use DrawComboBoxDropButton for the entire button
+        // (also render extra "hot" button state).

 
 

-    SetWindowStyle(style | wxWANTS_CHARS);
-    InheritAttributes();
+        renderer.DrawComboBoxDropButton(this, dc, r);
+
+        dc.SelectObject(bmpSel);
+
+        renderer.DrawComboBoxDropButton(this, dc, r, wxCONTROL_PRESSED);

 
 

-    wxBitmap bmp(8, 4);
+        wxBitmap bmpHot(bw,bh);
+        dc.SelectObject(bmpHot);
+        renderer.DrawComboBoxDropButton(this, dc, r, wxCONTROL_CURRENT);
+
+        m_bmpNormal = bmp;
+        m_bmpHot = bmpHot;
+    }
+
+    SetBitmapLabel(bmp);
+    SetBitmapSelected(bmpSel);
+}
+
+
+void wxDropdownButton::DoMoveWindow(int x, int y, int w, int h)
+{
+    if (w < 0)
+        w = DROPBUT_DEFAULT_WIDTH;
+
+    wxBitmapButton::DoMoveWindow(x, y, w, h);
+}
+
+
+void wxDropdownButton::OnSize(wxSizeEvent& event)
+{
+    if ( m_borderX >= 0 && m_borderY >= 0 )

     {
     {

-        wxMemoryDC dc;
+        int w, h;
+        GetClientSize(&w,&h);

 
 

-        dc.SelectObject(bmp);
-        dc.SetBrush(wxBrush(GetBackgroundColour()));
-        dc.SetPen(wxPen(GetBackgroundColour()));
-        dc.DrawRectangle(0,0, 8,4);
+        if ( w > 1 && h > 1 )
+            RecreateBitmaps(w,h);
+    }
+    event.Skip();
+}

 
 

-        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);
+
+void wxDropdownButton::OnMouseEnter(wxMouseEvent& event)
+{
+    if ( !m_useDropArrow )
+        SetBitmapLabel(m_bmpHot);
+
+    event.Skip();
+}
+
+
+void wxDropdownButton::OnMouseLeave(wxMouseEvent& event)
+{
+    if ( !m_useDropArrow )
+        SetBitmapLabel(m_bmpNormal);
+
+    event.Skip();
+}
+
+
+#if wxUSE_POPUPWIN
+
+#include "wx/popupwin.h"
+
+class wxDatePopupInternal : public wxPopupTransientWindow
+{
+public:
+    wxDatePopupInternal(wxWindow *parent) : wxPopupTransientWindow(parent) { }
+
+    void ShowAt(int x, int y)
+    {
+        Position(wxPoint(x, y), wxSize(0, 0));
+        Popup();

     }
 
     }
 

-    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"));
+    void Hide()
+    {
+        Dismiss();
+    }
+};

 
 

-    m_btn = new wxBitmapButton(this, CTRLID_BTN, bmp);
+#else // !wxUSE_POPUPWIN

 
 

-    m_dlg = new wxDialog(this, CTRLID_CAL, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxSIMPLE_BORDER);
-    m_dlg->SetFont(GetFont());
+class wxDatePopupInternal : public wxDialog
+{
+public:
+    wxDatePopupInternal(wxWindow *parent)
+        : wxDialog(parent,
+                   wxID_ANY,
+                   wxEmptyString,
+                   wxDefaultPosition,
+                   wxDefaultSize,
+                   wxSIMPLE_BORDER)
+    {
+    }

 
 

-    wxPanel *panel=new wxPanel(m_dlg, CTRLID_PAN, wxPoint(0, 0), wxDefaultSize, wxSUNKEN_BORDER|wxCLIP_CHILDREN);
-    m_cal = new wxCalendarCtrl(panel, CTRLID_CAL, wxDefaultDateTime, wxPoint(0,0), wxDefaultSize, 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);
+    void ShowAt(int x, int y)
+    {
+        Show();
+        Move(x, y);
+    }
+
+    void Hide()
+    {
+        wxDialog::Hide();
+    }
+};
+
+#endif // wxUSE_POPUPWIN/!wxUSE_POPUPWIN
+
+// ============================================================================
+// wxDatePickerCtrlGeneric implementation
+// ============================================================================
+
+BEGIN_EVENT_TABLE(wxDatePickerCtrlGeneric, wxDatePickerCtrlBase)
+    EVT_BUTTON(CTRLID_BTN, wxDatePickerCtrlGeneric::OnClick)
+    EVT_TEXT(CTRLID_TXT, wxDatePickerCtrlGeneric::OnText)
+    EVT_CHILD_FOCUS(wxDatePickerCtrlGeneric::OnChildSetFocus)
+    EVT_SIZE(wxDatePickerCtrlGeneric::OnSize)
+END_EVENT_TABLE()
+
+#ifndef wxHAS_NATIVE_DATEPICKCTRL
+    IMPLEMENT_DYNAMIC_CLASS(wxDatePickerCtrl, wxControl)
+#endif
+
+// ----------------------------------------------------------------------------
+// creation
+// ----------------------------------------------------------------------------
+
+bool wxDatePickerCtrlGeneric::Create(wxWindow *parent,
+                                     wxWindowID id,
+                                     const wxDateTime& date,
+                                     const wxPoint& pos,
+                                     const wxSize& size,
+                                     long style,
+                                     const wxValidator& validator,
+                                     const wxString& name)
+{
+    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,
+                            validator, name) )
+
+    {
+        return false;
+    }
+
+    InheritAttributes();
+
+    m_txt = new wxTextCtrl(this, CTRLID_TXT, wxEmptyString, wxDefaultPosition, wxDefaultSize, TXTCTRL_FLAGS);
+
+    m_txt->Connect(wxEVT_KEY_DOWN,
+                   wxKeyEventHandler(wxDatePickerCtrlGeneric::OnEditKey),
+                   NULL, this);
+    m_txt->Connect(wxEVT_KILL_FOCUS,
+                   wxFocusEventHandler(wxDatePickerCtrlGeneric::OnKillFocus),
+                   NULL, this);
+
+    m_btn = new wxDropdownButton(this, CTRLID_BTN, wxDefaultPosition, wxDefaultSize, wxBU_COMBO);
+
+    m_popup = new wxDatePopupInternal(this);
+    m_popup->SetFont(GetFont());
+
+    wxPanel *panel=new wxPanel(m_popup, 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(wxEVT_CALENDAR_SEL_CHANGED,
+                   wxCalendarEventHandler(wxDatePickerCtrlGeneric::OnSelChange),
+                   NULL, this);
+    m_cal->Connect(wxEVT_KEY_DOWN,
+                   wxKeyEventHandler(wxDatePickerCtrlGeneric::OnCalKey),
+                   NULL, this);
+    m_cal->Connect(wxEVT_CALENDAR_DOUBLECLICKED,
+                   wxCalendarEventHandler(wxDatePickerCtrlGeneric::OnSelChange),
+                   NULL, this);
+    m_cal->Connect(wxEVT_CALENDAR_DAY_CHANGED,
+                   wxCalendarEventHandler(wxDatePickerCtrlGeneric::OnSelChange),
+                   NULL, this);
+    m_cal->Connect(wxEVT_CALENDAR_MONTH_CHANGED,
+                   wxCalendarEventHandler(wxDatePickerCtrlGeneric::OnSelChange),
+                   NULL, this);
+    m_cal->Connect(wxEVT_CALENDAR_YEAR_CHANGED,
+                   wxCalendarEventHandler(wxDatePickerCtrlGeneric::OnSelChange),
+                   NULL, this);

 
     wxWindow *yearControl = m_cal->GetYearControl();
 
 
     wxWindow *yearControl = m_cal->GetYearControl();
 

-    Connect(wxID_ANY, wxID_ANY, wxEVT_SET_FOCUS, (wxObjectEventFunction)&wxDatePickerCtrl::OnSetFocus);
+    Connect(wxEVT_SET_FOCUS,
+            wxFocusEventHandler(wxDatePickerCtrlGeneric::OnSetFocus));

 
     wxClientDC dc(yearControl);
 
     wxClientDC dc(yearControl);

-    dc.SetFont(m_font);
+    dc.SetFont(yearControl->GetFont());

     wxCoord width, dummy;
     dc.GetTextExtent(wxT("2000"), &width, &dummy);
     wxCoord width, dummy;
     dc.GetTextExtent(wxT("2000"), &width, &dummy);

-    width += ConvertDialogToPixels(wxSize(20,0)).x;
+    width += ConvertDialogToPixels(wxSize(20, 0)).x;

 
     wxSize calSize = m_cal->GetBestSize();
     wxSize yearSize = yearControl->GetSize();
 
     wxSize calSize = m_cal->GetBestSize();
     wxSize yearSize = yearControl->GetSize();


@@ -144,11 +489,7 @@ bool wxDatePickerCtrl::Create(wxWindow *parent,
 
     wxPoint yearPosition = yearControl->GetPosition();
 
 
     wxPoint yearPosition = yearControl->GetPosition();
 

-#ifdef __WXMSW__
-#define CALBORDER   0
-#else
-#define CALBORDER   4
-#endif
+    SetFormat(wxT("%x"));

 
     width = yearPosition.x + yearSize.x+2+CALBORDER/2;
     if (width < calSize.x-4)
 
     width = yearPosition.x + yearSize.x+2+CALBORDER/2;
     if (width < calSize.x-4)


@@ -161,21 +502,29 @@ bool wxDatePickerCtrl::Create(wxWindow *parent,
         width += 2;
     }
     m_cal->SetSize(calPos, 0, calSize.x, calSize.y);
         width += 2;
     }
     m_cal->SetSize(calPos, 0, calSize.x, calSize.y);

-    yearControl->SetSize(width-yearSize.x-CALBORDER/2, yearPosition.y, yearSize.x, yearSize.y);
+    yearControl->SetSize(width-yearSize.x-CALBORDER/2, yearPosition.y,
+                         yearSize.x, yearSize.y);

     m_cal->GetMonthControl()->Move(0, 0);
 
 
 
     panel->SetClientSize(width+CALBORDER/2, calSize.y-2+CALBORDER);
     m_cal->GetMonthControl()->Move(0, 0);
 
 
 
     panel->SetClientSize(width+CALBORDER/2, calSize.y-2+CALBORDER);

-    m_dlg->SetClientSize(panel->GetSize());
+    m_popup->SetClientSize(panel->GetSize());
+    m_popup->Hide();
+
+    SetValue(date.IsValid() ? date : wxDateTime::Today());

 
 

-    return TRUE;
+    SetBestFittingSize(size);
+
+    SetBackgroundColour(m_txt->GetBackgroundColour());
+
+    return true;

 }
 
 
 }
 
 

-void wxDatePickerCtrl::Init()
+void wxDatePickerCtrlGeneric::Init()

 {
 {

-    m_dlg = NULL;
+    m_popup = NULL;

     m_txt = NULL;
     m_cal = NULL;
     m_btn = NULL;
     m_txt = NULL;
     m_cal = NULL;
     m_btn = NULL;


@@ -184,19 +533,26 @@ void wxDatePickerCtrl::Init()
     m_ignoreDrop = false;
 }
 
     m_ignoreDrop = false;
 }
 

+wxDatePickerCtrlGeneric::~wxDatePickerCtrlGeneric()
+{
+    m_popup = NULL;
+    m_txt = NULL;
+    m_cal = NULL;
+    m_btn = NULL;
+}

 
 

-bool wxDatePickerCtrl::Destroy()
+bool wxDatePickerCtrlGeneric::Destroy()

 {
     if (m_cal)
         m_cal->Destroy();
 {
     if (m_cal)
         m_cal->Destroy();

-    if (m_dlg)
-        m_dlg->Destroy();
+    if (m_popup)
+        m_popup->Destroy();

     if (m_txt)
         m_txt->Destroy();
     if (m_btn)
         m_btn->Destroy();
 
     if (m_txt)
         m_txt->Destroy();
     if (m_btn)
         m_btn->Destroy();
 

-    m_dlg = NULL;
+    m_popup = NULL;

     m_txt = NULL;
     m_cal = NULL;
     m_btn = NULL;
     m_txt = NULL;
     m_cal = NULL;
     m_btn = NULL;


@@ -208,78 +564,86 @@ bool wxDatePickerCtrl::Destroy()
 // overridden base class methods
 // ----------------------------------------------------------------------------
 
 // overridden base class methods
 // ----------------------------------------------------------------------------
 

-void wxDatePickerCtrl::DoMoveWindow(int x, int y, int w, int h)
+void wxDatePickerCtrlGeneric::DoMoveWindow(int x, int y, int w, int h)

 {
     wxControl::DoMoveWindow(x, y, w, h);
 {
     wxControl::DoMoveWindow(x, y, w, h);

-    wxSize bs=m_btn->GetBestSize();
-    int eh=m_txt->GetBestSize().y;
-
-    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);

 
     if (m_dropped)
 
     if (m_dropped)

-        DropDown();
+        DropDown(false);

 }
 
 }
 

-wxSize wxDatePickerCtrl::DoGetBestSize() const
+wxSize wxDatePickerCtrlGeneric::DoGetBestSize() const

 {
 {

-    int bh=m_btn->GetBestSize().y;
-    int eh=m_txt->GetBestSize().y;
-    return wxSize(DEFAULT_ITEM_WIDTH, bh > eh ? bh : eh);
+    if (m_btn && m_txt)
+    {
+        int bh=m_btn->GetBestSize().y;
+        int eh=m_txt->GetBestSize().y;
+        return wxSize(DEFAULT_ITEM_WIDTH, bh > eh ? bh : eh);
+    }
+    return wxControl::DoGetBestSize();

 }
 
 
 }
 
 

-bool wxDatePickerCtrl::Show(bool show)
+bool wxDatePickerCtrlGeneric::Show(bool show)

 {
     if ( !wxControl::Show(show) )
     {
 {
     if ( !wxControl::Show(show) )
     {

-        return FALSE;
+        return false;

     }
 
     }
 

-    if (!show)
+    if ( !show )

     {
     {

-        if (m_dlg)
+        if ( m_popup )

         {
         {

-            m_dlg->Hide();
+            m_popup->Hide();

             m_dropped = false;
         }
     }
 
             m_dropped = false;
         }
     }
 

-    return TRUE;
+    return true;

 }
 
 
 }
 
 

-bool wxDatePickerCtrl::Enable(bool enable)
+bool wxDatePickerCtrlGeneric::Enable(bool enable)

 {
     if ( !wxControl::Enable(enable) )
     {
 {
     if ( !wxControl::Enable(enable) )
     {

-        return FALSE;
+        return false;

     }
 
     }
 

-    if (!enable)
+    if ( !enable )

     {
     {

-        if (m_cal)
-            m_cal->Hide();
+        if ( m_popup )
+            m_popup->Hide();

     }
     }

-    if (m_btn)
+
+    if ( m_btn )

         m_btn->Enable(enable);
         m_btn->Enable(enable);

-    return TRUE;
+
+    return true;

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------

-// wxDatePickerCtrl API
+// wxDatePickerCtrlGeneric API

 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 

-bool wxDatePickerCtrl::SetFormat(const wxChar *fmt)
+bool
+wxDatePickerCtrlGeneric::SetDateRange(const wxDateTime& lowerdate,
+                                      const wxDateTime& upperdate)
+{
+    return m_cal->SetDateRange(lowerdate, upperdate);
+}
+
+bool wxDatePickerCtrlGeneric::SetFormat(const wxChar *fmt)

 {
 {

+    m_format.clear();
+

     wxDateTime dt;
     dt.ParseFormat(wxT("2003-10-13"), wxT("%Y-%m-%d"));
     wxDateTime dt;
     dt.ParseFormat(wxT("2003-10-13"), wxT("%Y-%m-%d"));

-    wxString str=dt.Format(fmt);
-    wxChar *p=(wxChar*)str.c_str();
-
-    m_format=wxEmptyString;
+    wxString str(dt.Format(fmt));

 
 

-    while (*p)
+    const wxChar *p = str.c_str();
+    while ( *p )

     {
         int n=wxAtoi(p);
         if (n == dt.GetDay())
     {
         int n=wxAtoi(p);
         if (n == dt.GetDay())


@@ -297,108 +661,149 @@ bool wxDatePickerCtrl::SetFormat(const wxChar *fmt)
             m_format.Append(wxT("%Y"));
             p += 4;
         }
             m_format.Append(wxT("%Y"));
             p += 4;
         }

+        else if (n == (dt.GetYear() % 100))
+        {
+            if (GetWindowStyle() & wxDP_SHOWCENTURY)
+                m_format.Append(wxT("%Y"));
+            else
+                m_format.Append(wxT("%y"));
+            p += 2;
+        }

         else
             m_format.Append(*p++);
     }
 
         else
             m_format.Append(*p++);
     }
 

-    if (m_txt)
+    if ( m_txt )

     {
     {

-        wxStringList valList;
-        wxChar c;
-        for (c='0'; c <= '9'; c++)
-            valList.Add(wxString(c, 1));
-        wxChar *p=(wxChar*)m_format.c_str();
-        while (*p)
+        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 (*p == '%')
-                p += 2;
+            if ( *p2 == '%')
+                p2 += 2;

             else
             else

-                valList.Add(wxString(*p++, 1));
+                allowedChars.Add(wxString(*p2++, 1));

         }
         }

-        wxTextValidator tv(wxFILTER_INCLUDE_CHAR_LIST);
-        tv.SetIncludeList(valList);

 
 

+#if wxUSE_VALIDATORS
+        wxTextValidator tv(wxFILTER_INCLUDE_CHAR_LIST);
+        tv.SetIncludes(allowedChars);

         m_txt->SetValidator(tv);
         m_txt->SetValidator(tv);

+#endif
+
+        if (m_currentDate.IsValid())
+            m_txt->SetValue(m_currentDate.Format(m_format));

     }
     }

+

     return true;
 }
 
 
     return true;
 }
 
 

-wxDateTime wxDatePickerCtrl::GetValue() const
+wxDateTime wxDatePickerCtrlGeneric::GetValue() const

 {
 {

-    wxDateTime dt;
-    wxString txt=m_txt->GetValue();
-
-    if (!txt.IsEmpty())
-        dt.ParseFormat(txt, m_format);
-
-    return dt;
+    return m_currentDate;

 }
 
 
 }
 
 

-void wxDatePickerCtrl::SetValue(const wxDateTime& date)
+void wxDatePickerCtrlGeneric::SetValue(const wxDateTime& date)

 {
 {

-    if (m_cal)
+    if ( !m_cal ) 
+        return;
+
+    // we need to suppress the event sent from wxTextCtrl as calling our
+    // SetValue() should not result in an event being sent (wxTextCtrl is
+    // an exception to this rule)
+    gs_inSetValue = this;
+
+    if ( date.IsValid() )

     {
     {

-        if (date.IsValid())
-            m_txt->SetValue(date.FormatDate());
-        else
-            m_txt->SetValue(wxEmptyString);
+        m_txt->SetValue(date.Format(m_format));

     }
     }

+    else // invalid date
+    {
+        wxASSERT_MSG( HasFlag(wxDP_ALLOWNONE),
+                        _T("this control must have a valid date") );
+
+        m_txt->SetValue(wxEmptyString);
+    }
+
+    gs_inSetValue = NULL;
+
+    m_currentDate = date;

 }
 
 
 }
 
 

-bool wxDatePickerCtrl::GetRange(wxDateTime *dt1, wxDateTime *dt2) const
+bool wxDatePickerCtrlGeneric::GetRange(wxDateTime *dt1, wxDateTime *dt2) const

 {
     if (dt1)
 {
     if (dt1)

-        *dt1 = GetLowerDateLimit();
-    if (dt1)
-        *dt2 = GetUpperDateLimit();
+        *dt1 = m_cal->GetLowerDateLimit();
+    if (dt2)
+        *dt2 = m_cal->GetUpperDateLimit();

     return true;
 }
 
 
     return true;
 }
 
 

-void wxDatePickerCtrl::SetRange(const wxDateTime &dt1, const wxDateTime &dt2)
+void
+wxDatePickerCtrlGeneric::SetRange(const wxDateTime &dt1, const wxDateTime &dt2)

 {
 {

-    SetLowerDateLimit(dt1);
-    SetUpperDateLimit(dt2);
+    m_cal->SetDateRange(dt1, dt2);

 }
 
 // ----------------------------------------------------------------------------
 // event handlers
 // ----------------------------------------------------------------------------
 
 }
 
 // ----------------------------------------------------------------------------
 // event handlers
 // ----------------------------------------------------------------------------
 

-void wxDatePickerCtrl::DropDown(bool down)
+void wxDatePickerCtrlGeneric::DropDown(bool down)

 {
 {

-    if (m_dlg)
+    if (m_popup)

     {
         if (down)
         {
     {
         if (down)
         {

-            if (m_txt->GetValue().IsEmpty())
-                m_cal->SetDate(wxDateTime::Today());
-            else
-            {
-                wxDateTime dt;
+            wxDateTime dt;
+            if (!m_txt->GetValue().empty())

                 dt.ParseFormat(m_txt->GetValue(), m_format);
                 dt.ParseFormat(m_txt->GetValue(), m_format);

+
+            if (dt.IsValid())

                 m_cal->SetDate(dt);
                 m_cal->SetDate(dt);

-            }
-            wxPoint pos=GetParent()->ClientToScreen(GetPosition());
+            else
+                m_cal->SetDate(wxDateTime::Today());

 
 

-            m_dlg->Move(pos.x, pos.y + GetSize().y);
-            m_dlg->Show();
+            wxPoint pos=GetParent()->ClientToScreen(GetPosition());
+            m_popup->ShowAt(pos.x, pos.y + GetSize().y);

             m_dropped = true;
             m_dropped = true;

+            m_cal->SetFocus();

         }
         else
         {
             if (m_dropped)
         }
         else
         {
             if (m_dropped)

-                m_dlg->Hide();
+                m_popup->Hide();

             m_dropped = false;
         }
     }
 }
 
 
             m_dropped = false;
         }
     }
 }
 
 

-void wxDatePickerCtrl::OnChildSetFocus(wxChildFocusEvent &ev)
+void wxDatePickerCtrlGeneric::OnSize(wxSizeEvent& event)
+{
+    if ( m_btn )
+    {
+        wxSize sz = GetClientSize();
+
+        wxSize bs=m_btn->GetSize();
+        int eh=m_txt->GetBestSize().y;
+
+        m_txt->SetSize(0, TXTPOSY, sz.x-bs.x, sz.y > eh ? eh-TXTPOSY : sz.y-TXTPOSY);
+        m_btn->SetSize(sz.x - bs.x, 0, bs.x, sz.y);
+    }
+
+    event.Skip();
+}
+
+
+void wxDatePickerCtrlGeneric::OnChildSetFocus(wxChildFocusEvent &ev)

 {
     ev.Skip();
     m_ignoreDrop = false;
 {
     ev.Skip();
     m_ignoreDrop = false;


@@ -406,7 +811,7 @@ void wxDatePickerCtrl::OnChildSetFocus(wxChildFocusEvent &ev)
     wxWindow  *w=(wxWindow*)ev.GetEventObject();
     while (w)
     {
     wxWindow  *w=(wxWindow*)ev.GetEventObject();
     while (w)
     {

-        if (w == m_dlg)
+        if (w == m_popup)

             return;
         w = w->GetParent();
     }
             return;
         w = w->GetParent();
     }


@@ -414,13 +819,13 @@ void wxDatePickerCtrl::OnChildSetFocus(wxChildFocusEvent &ev)
     if (m_dropped)
     {
         DropDown(false);
     if (m_dropped)
     {
         DropDown(false);

-        if (ev.GetEventObject() == m_btn)
+        if (::wxFindWindowAtPoint(::wxGetMousePosition()) == m_btn)

             m_ignoreDrop = true;
     }
 }
 
 
             m_ignoreDrop = true;
     }
 }
 
 

-void wxDatePickerCtrl::OnClick(wxCommandEvent& event)
+void wxDatePickerCtrlGeneric::OnClick(wxCommandEvent& WXUNUSED(event))

 {
     if (m_ignoreDrop)
     {
 {
     if (m_ignoreDrop)
     {


@@ -435,34 +840,53 @@ void wxDatePickerCtrl::OnClick(wxCommandEvent& event)
 }
 
 
 }
 
 

-void wxDatePickerCtrl::OnSetFocus(wxFocusEvent &ev)
+void wxDatePickerCtrlGeneric::OnSetFocus(wxFocusEvent& WXUNUSED(ev))

 {
     if (m_txt)
     {
         m_txt->SetFocus();
 {
     if (m_txt)
     {
         m_txt->SetFocus();

-        m_txt->SetSelection(0, 100);
+        m_txt->SetSelection(-1, -1); // select everything

     }
 }
 
 
     }
 }
 
 

-void wxDatePickerCtrl::OnKillFocus(wxFocusEvent &ev)
+void wxDatePickerCtrlGeneric::OnKillFocus(wxFocusEvent &ev)

 {
 {

+    if (!m_txt)
+        return;
+    

     ev.Skip();
 
     wxDateTime dt;
     dt.ParseFormat(m_txt->GetValue(), m_format);
     ev.Skip();
 
     wxDateTime dt;
     dt.ParseFormat(m_txt->GetValue(), m_format);

-    if (!dt.IsValid())
-        m_txt->SetValue(wxEmptyString);
-    else
+    if ( !dt.IsValid() )
+    {
+        if ( !HasFlag(wxDP_ALLOWNONE) )
+            dt = m_currentDate;
+    }
+
+    if(dt.IsValid())

         m_txt->SetValue(dt.Format(m_format));
         m_txt->SetValue(dt.Format(m_format));

+    else
+        m_txt->SetValue(wxEmptyString);
+
+    // notify that we had to change the date after validation
+    if ( (dt.IsValid() && (!m_currentDate.IsValid() || m_currentDate != dt)) ||
+            (!dt.IsValid() && m_currentDate.IsValid()) )
+    {
+        m_currentDate = dt;
+        wxDateEvent event(this, dt, wxEVT_DATE_CHANGED);
+        GetEventHandler()->ProcessEvent(event);
+    }

 }
 
 
 }
 
 

-void wxDatePickerCtrl::OnSelChange(wxCalendarEvent &ev)
+void wxDatePickerCtrlGeneric::OnSelChange(wxCalendarEvent &ev)

 {
     if (m_cal)
     {
 {
     if (m_cal)
     {

-        m_txt->SetValue(m_cal->GetDate().FormatDate());
+        m_currentDate = m_cal->GetDate();
+        m_txt->SetValue(m_currentDate.Format(m_format));

         if (ev.GetEventType() == wxEVT_CALENDAR_DOUBLECLICKED)
         {
             DropDown(false);
         if (ev.GetEventType() == wxEVT_CALENDAR_DOUBLECLICKED)
         {
             DropDown(false);


@@ -472,20 +896,29 @@ void wxDatePickerCtrl::OnSelChange(wxCalendarEvent &ev)
     ev.SetEventObject(this);
     ev.SetId(GetId());
     GetParent()->ProcessEvent(ev);
     ev.SetEventObject(this);
     ev.SetId(GetId());
     GetParent()->ProcessEvent(ev);

+
+    wxDateEvent dev(this, ev.GetDate(), wxEVT_DATE_CHANGED);
+    GetParent()->ProcessEvent(dev);

 }
 
 
 }
 
 

-void wxDatePickerCtrl::OnText(wxCommandEvent &ev)
+void wxDatePickerCtrlGeneric::OnText(wxCommandEvent &ev)

 {
 {

+    if ( gs_inSetValue )
+    {
+        // artificial event resulting from our own SetValue() call, ignore it
+        return;
+    }
+

     ev.SetEventObject(this);
     ev.SetId(GetId());
     GetParent()->ProcessEvent(ev);
 
     // We'll create an additional event if the date is valid.
     ev.SetEventObject(this);
     ev.SetId(GetId());
     GetParent()->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
+    wxString txt = m_txt->GetValue();

     wxDateTime dt;
     wxDateTime dt;

-    if (!txt.IsEmpty())
+    if (!txt.empty())

     {
         dt.ParseFormat(txt, m_format);
         if (!dt.IsValid())
     {
         dt.ParseFormat(txt, m_format);
         if (!dt.IsValid())


@@ -498,19 +931,22 @@ void wxDatePickerCtrl::OnText(wxCommandEvent &ev)
     cev.SetDate(dt);
 
     GetParent()->ProcessEvent(cev);
     cev.SetDate(dt);
 
     GetParent()->ProcessEvent(cev);

+
+    wxDateEvent dev(this, dt, wxEVT_DATE_CHANGED);
+    GetParent()->ProcessEvent(dev);

 }
 
 
 }
 
 

-void wxDatePickerCtrl::OnEditKey(wxKeyEvent & ev)
+void wxDatePickerCtrlGeneric::OnEditKey(wxKeyEvent & ev)

 {
     if (ev.GetKeyCode() == WXK_DOWN && !ev.HasModifiers())
 {
     if (ev.GetKeyCode() == WXK_DOWN && !ev.HasModifiers())

-        DropDown();
+        DropDown(true);

     else
         ev.Skip();
 }
 
 
     else
         ev.Skip();
 }
 
 

-void wxDatePickerCtrl::OnCalKey(wxKeyEvent & ev)
+void wxDatePickerCtrlGeneric::OnCalKey(wxKeyEvent & ev)

 {
     if (ev.GetKeyCode() == WXK_ESCAPE && !ev.HasModifiers())
         DropDown(false);
 {
     if (ev.GetKeyCode() == WXK_ESCAPE && !ev.HasModifiers())
         DropDown(false);


@@ -518,3 +954,6 @@ void wxDatePickerCtrl::OnCalKey(wxKeyEvent & ev)
         ev.Skip();
 }
 
         ev.Skip();
 }
 

+#endif // wxUSE_DATEPICKCTRL_GENERIC
+
+#endif // wxUSE_DATEPICKCTRL