]> git.saurik.com Git - wxWidgets.git/blobdiff - src/generic/spinctlg.cpp
projects / wxWidgets.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Fix broken and missing DataView interface items for Phoenix
[wxWidgets.git] / src / generic / spinctlg.cpp
diff --git a/src/generic/spinctlg.cpp b/src/generic/spinctlg.cpp
index 066e66f381b6a39c790df4d92dabe4cd1ff970c1..64d00b43ffa7e05542077dae0d069d2998d18ef5 100644 (file)
--- a/src/generic/spinctlg.cpp
+++ b/src/generic/spinctlg.cpp
@@ -6,7 +6,7 @@
 // Created:     29.01.01
 // RCS-ID:      $Id$
 // Copyright:   (c) 2001 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
 // Created:     29.01.01
 // RCS-ID:      $Id$
 // Copyright:   (c) 2001 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
-// License:     wxWindows licence
+// Licence:     wxWindows licence
 ///////////////////////////////////////////////////////////////////////////////
 
 // ============================================================================
 ///////////////////////////////////////////////////////////////////////////////
 
 // ============================================================================
@@ -17,10 +17,6 @@
 // headers
 // ----------------------------------------------------------------------------
 
 // headers
 // ----------------------------------------------------------------------------
 
-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
-    #pragma implementation "spinctlg.h"
-#endif
-
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
@@ -28,166 +24,218 @@
     #pragma hdrstop
 #endif
 
     #pragma hdrstop
 #endif
 
-// There are port-specific versions for MSW, GTK, OS/2 and Mac, so exclude the
-// contents of this file in those cases
-#if !(defined(__WXMSW__) || defined(__WXGTK__) || defined(__WXPM__) || \
-    defined(__WXMAC__)) || defined(__WXUNIVERSAL__)
-
 #ifndef WX_PRECOMP
     #include "wx/textctrl.h"
 #endif //WX_PRECOMP
 
 #ifndef WX_PRECOMP
     #include "wx/textctrl.h"
 #endif //WX_PRECOMP
 
+#include "wx/spinctrl.h"
+#include "wx/tooltip.h"
+
 #if wxUSE_SPINCTRL
 
 #if wxUSE_SPINCTRL
 
+IMPLEMENT_DYNAMIC_CLASS(wxSpinDoubleEvent, wxNotifyEvent)
+
+// There are port-specific versions for the wxSpinCtrl, so exclude the
+// contents of this file in those cases
+#if !defined(wxHAS_NATIVE_SPINCTRL) || !defined(wxHAS_NATIVE_SPINCTRLDOUBLE)
+
 #include "wx/spinbutt.h"
 #include "wx/spinbutt.h"
-#include "wx/spinctrl.h"
+
+#if wxUSE_SPINBTN
 
 // ----------------------------------------------------------------------------
 // constants
 // ----------------------------------------------------------------------------
 
 
 // ----------------------------------------------------------------------------
 // constants
 // ----------------------------------------------------------------------------
 
-// the margin between the text control and the spin
-static const wxCoord MARGIN = 2;
+// The margin between the text control and the spin: the value here is the same
+// as the margin between the spin button and its "buddy" text control in wxMSW
+// so the generic control looks similarly to the native one there, we might
+// need to use different value for the other platforms (and maybe even
+// determine it dynamically?).
+static const wxCoord MARGIN = 1;
+
+#define SPINCTRLBUT_MAX 32000 // large to avoid wrap around trouble
 
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
-// wxSpinCtrlText: text control used by spin control
+// wxSpinCtrlTextGeneric: text control used by spin control
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 
-class wxSpinCtrlText : public wxTextCtrl
+class wxSpinCtrlTextGeneric : public wxTextCtrl
 {
 public:
 {
 public:
-    wxSpinCtrlText(wxSpinCtrl *spin, const wxString& value)
-        : wxTextCtrl(spin->GetParent(), wxID_ANY, value)
+    wxSpinCtrlTextGeneric(wxSpinCtrlGenericBase *spin, const wxString& value, long style=0)
+        : wxTextCtrl(spin->GetParent(), wxID_ANY, value, wxDefaultPosition, wxDefaultSize,
+                     // This is tricky: we want to honour any alignment flags
+                     // but not wxALIGN_CENTER_VERTICAL because it's the same
+                     // as wxTE_PASSWORD and we definitely don't want to show
+                     // asterisks in spin control.
+                     style & (wxALIGN_MASK | wxTE_PROCESS_ENTER) & ~wxTE_PASSWORD)
     {
         m_spin = spin;
 
         // remove the default minsize, the spinctrl will have one instead
     {
         m_spin = spin;
 
         // remove the default minsize, the spinctrl will have one instead
-        SetSizeHints(wxDefaultCoord,wxDefaultCoord);
+        SetSizeHints(wxDefaultCoord, wxDefaultCoord);
     }
 
     }
 
-protected:
-    void OnTextChange(wxCommandEvent& event)
+    virtual ~wxSpinCtrlTextGeneric()
     {
     {
-        int val;
-        if ( m_spin->GetTextValue(&val) )
-        {
-            m_spin->GetSpinButton()->SetValue(val);
-        }
+        // MSW sends extra kill focus event on destroy
+        if (m_spin)
+            m_spin->m_textCtrl = NULL;
 
 
-        event.Skip();
+        m_spin = NULL;
     }
 
     }
 
-    bool ProcessEvent(wxEvent &event)
+    void OnChar( wxKeyEvent &event )
     {
     {
-        // Hand button down events to wxSpinCtrl. Doesn't work.
-        if (event.GetEventType() == wxEVT_LEFT_DOWN && m_spin->ProcessEvent( event ))
-            return true;
+        if ( !m_spin->ProcessWindowEvent(event) )
+            event.Skip();
+    }
 
 
-        return wxTextCtrl::ProcessEvent( event );
+    void OnTextEvent(wxCommandEvent& event)
+    {
+        wxCommandEvent eventCopy(event);
+        eventCopy.SetEventObject(m_spin);
+        eventCopy.SetId(m_spin->GetId());
+        m_spin->ProcessWindowEvent(eventCopy);
     }
 
     }
 
-private:
-    wxSpinCtrl *m_spin;
+    void OnKillFocus(wxFocusEvent& event)
+    {
+        if (m_spin)
+            m_spin->ProcessWindowEvent(event);
+
+        event.Skip();
+    }
 
 
+    wxSpinCtrlGenericBase *m_spin;
+
+private:
     DECLARE_EVENT_TABLE()
 };
 
     DECLARE_EVENT_TABLE()
 };
 
-BEGIN_EVENT_TABLE(wxSpinCtrlText, wxTextCtrl)
-    EVT_TEXT(wxID_ANY, wxSpinCtrlText::OnTextChange)
+BEGIN_EVENT_TABLE(wxSpinCtrlTextGeneric, wxTextCtrl)
+    EVT_CHAR(wxSpinCtrlTextGeneric::OnChar)
+
+    // Forward the text events to wxSpinCtrl itself adjusting them slightly in
+    // the process.
+    EVT_TEXT(wxID_ANY, wxSpinCtrlTextGeneric::OnTextEvent)
+
+    // And we need to forward this one too as wxSpinCtrl is supposed to
+    // generate it if wxTE_PROCESS_ENTER is used with it (and if it isn't,
+    // we're never going to get EVT_TEXT_ENTER in the first place).
+    EVT_TEXT_ENTER(wxID_ANY, wxSpinCtrlTextGeneric::OnTextEvent)
+
+    EVT_KILL_FOCUS(wxSpinCtrlTextGeneric::OnKillFocus)
 END_EVENT_TABLE()
 
 // ----------------------------------------------------------------------------
 END_EVENT_TABLE()
 
 // ----------------------------------------------------------------------------
-// wxSpinCtrlButton: spin button used by spin control
+// wxSpinCtrlButtonGeneric: spin button used by spin control
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 
-class wxSpinCtrlButton : public wxSpinButton
+class wxSpinCtrlButtonGeneric : public wxSpinButton
 {
 public:
 {
 public:
-    wxSpinCtrlButton(wxSpinCtrl *spin, int style)
-        : wxSpinButton(spin->GetParent())
+    wxSpinCtrlButtonGeneric(wxSpinCtrlGenericBase *spin, int style)
+        : wxSpinButton(spin->GetParent(), wxID_ANY, wxDefaultPosition,
+                       wxDefaultSize, style | wxSP_VERTICAL)
     {
         m_spin = spin;
 
     {
         m_spin = spin;
 
-        SetWindowStyle(style | wxSP_VERTICAL);
+        SetRange(-SPINCTRLBUT_MAX, SPINCTRLBUT_MAX);
 
         // remove the default minsize, the spinctrl will have one instead
 
         // remove the default minsize, the spinctrl will have one instead
-        SetSizeHints(wxDefaultCoord,wxDefaultCoord);
+        SetSizeHints(wxDefaultCoord, wxDefaultCoord);
     }
 
     }
 
-protected:
-    void OnSpinButton(wxSpinEvent& eventSpin)
+    void OnSpinButton(wxSpinEvent& event)
     {
     {
-        m_spin->SetTextValue(eventSpin.GetPosition());
-
-        wxCommandEvent event(wxEVT_COMMAND_SPINCTRL_UPDATED, m_spin->GetId());
-        event.SetEventObject(m_spin);
-        event.SetInt(eventSpin.GetPosition());
-
-        m_spin->GetEventHandler()->ProcessEvent(event);
-
-        eventSpin.Skip();
+        if (m_spin)
+            m_spin->OnSpinButton(event);
     }
 
     }
 
-private:
-    wxSpinCtrl *m_spin;
+    wxSpinCtrlGenericBase *m_spin;
 
 
+private:
     DECLARE_EVENT_TABLE()
 };
 
     DECLARE_EVENT_TABLE()
 };
 
-BEGIN_EVENT_TABLE(wxSpinCtrlButton, wxSpinButton)
-    EVT_SPIN(wxID_ANY, wxSpinCtrlButton::OnSpinButton)
+BEGIN_EVENT_TABLE(wxSpinCtrlButtonGeneric, wxSpinButton)
+    EVT_SPIN_UP(  wxID_ANY, wxSpinCtrlButtonGeneric::OnSpinButton)
+    EVT_SPIN_DOWN(wxID_ANY, wxSpinCtrlButtonGeneric::OnSpinButton)
 END_EVENT_TABLE()
 
 END_EVENT_TABLE()
 
-IMPLEMENT_DYNAMIC_CLASS(wxSpinCtrl, wxControl)
-
 // ============================================================================
 // ============================================================================
-// implementation
+// wxSpinCtrlGenericBase
 // ============================================================================
 
 // ----------------------------------------------------------------------------
 // ============================================================================
 
 // ----------------------------------------------------------------------------
-// wxSpinCtrl creation
+// wxSpinCtrlGenericBase creation
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 
-void wxSpinCtrl::Init()
+void wxSpinCtrlGenericBase::Init()
 {
 {
-    m_text = NULL;
-    m_btn = NULL;
+    m_value         = 0;
+    m_min           = 0;
+    m_max           = 100;
+    m_increment     = 1;
+    m_snap_to_ticks = false;
+
+    m_spin_value    = 0;
+
+    m_textCtrl = NULL;
+    m_spinButton  = NULL;
 }
 
 }
 
-bool wxSpinCtrl::Create(wxWindow *parent,
-                        wxWindowID id,
-                        const wxString& value,
-                        const wxPoint& WXUNUSED(pos),
-                        const wxSize& size,
-                        long style,
-                        int min,
-                        int max,
-                        int initial,
-                        const wxString& name)
+bool wxSpinCtrlGenericBase::Create(wxWindow *parent,
+                                   wxWindowID id,
+                                   const wxString& value,
+                                   const wxPoint& pos, const wxSize& size,
+                                   long style,
+                                   double min, double max, double initial,
+                                   double increment,
+                                   const wxString& name)
 {
 {
-    if ( !wxControl::Create(parent, id, wxDefaultPosition, wxDefaultSize, style,
+    // don't use borders for this control itself, it wouldn't look good with
+    // the text control borders (but we might want to use style border bits to
+    // select the text control style)
+    if ( !wxControl::Create(parent, id, wxDefaultPosition, wxDefaultSize,
+                            (style & ~wxBORDER_MASK) | wxBORDER_NONE,
                             wxDefaultValidator, name) )
     {
         return false;
     }
 
                             wxDefaultValidator, name) )
     {
         return false;
     }
 
+    m_value = initial;
+    m_min   = min;
+    m_max   = max;
+    m_increment = increment;
+
+    m_textCtrl   = new wxSpinCtrlTextGeneric(this, value, style);
+    m_spinButton = new wxSpinCtrlButtonGeneric(this, style);
+#if wxUSE_TOOLTIPS
+    m_textCtrl->SetToolTip(GetToolTipText());
+    m_spinButton->SetToolTip(GetToolTipText());
+#endif // wxUSE_TOOLTIPS
+
+    m_spin_value = m_spinButton->GetValue();
+
     // the string value overrides the numeric one (for backwards compatibility
     // reasons and also because it is simpler to satisfy the string value which
     // comes much sooner in the list of arguments and leave the initial
     // parameter unspecified)
     if ( !value.empty() )
     {
     // the string value overrides the numeric one (for backwards compatibility
     // reasons and also because it is simpler to satisfy the string value which
     // comes much sooner in the list of arguments and leave the initial
     // parameter unspecified)
     if ( !value.empty() )
     {
-        long l;
-        if ( value.ToLong(&l) )
-            initial = l;
+        double d;
+        if ( DoTextToValue(value, &d) )
+        {
+            m_value = d;
+            m_textCtrl->SetValue(DoValueToText(m_value));
+        }
     }
 
     }
 
-    m_text = new wxSpinCtrlText(this, value);
-    m_btn = new wxSpinCtrlButton(this, style);
-
-    m_btn->SetRange(min, max);
-    m_btn->SetValue(initial);
-    SetBestSize(size);
+    SetInitialSize(size);
+    Move(pos);
 
     // have to disable this window to avoid interfering it with message
     // processing to the text and the button... but pretend it is enabled to
 
     // have to disable this window to avoid interfering it with message
     // processing to the text and the button... but pretend it is enabled to
@@ -202,166 +250,443 @@ bool wxSpinCtrl::Create(wxWindow *parent,
     return true;
 }
 
     return true;
 }
 
-wxSpinCtrl::~wxSpinCtrl()
+wxSpinCtrlGenericBase::~wxSpinCtrlGenericBase()
 {
     // delete the controls now, don't leave them alive even though they would
     // still be eventually deleted by our parent - but it will be too late, the
     // user code expects them to be gone now
 {
     // delete the controls now, don't leave them alive even though they would
     // still be eventually deleted by our parent - but it will be too late, the
     // user code expects them to be gone now
-    delete m_text;
-    m_text = NULL ;
-    delete m_btn;
-    m_btn = NULL ;
+
+    if (m_textCtrl)
+    {
+        // null this since MSW sends KILL_FOCUS on deletion, see ~wxSpinCtrlTextGeneric
+        wxDynamicCast(m_textCtrl, wxSpinCtrlTextGeneric)->m_spin = NULL;
+
+        wxSpinCtrlTextGeneric *text = (wxSpinCtrlTextGeneric*)m_textCtrl;
+        m_textCtrl = NULL;
+        delete text;
+    }
+
+    wxDELETE(m_spinButton);
 }
 
 // ----------------------------------------------------------------------------
 // geometry
 // ----------------------------------------------------------------------------
 
 }
 
 // ----------------------------------------------------------------------------
 // geometry
 // ----------------------------------------------------------------------------
 
-wxSize wxSpinCtrl::DoGetBestSize() const
+wxSize wxSpinCtrlGenericBase::DoGetBestSize() const
 {
 {
-    wxSize sizeBtn = m_btn->GetBestSize(),
-           sizeText = m_text->GetBestSize();
+    wxSize sizeBtn  = m_spinButton->GetBestSize(),
+           sizeText = m_textCtrl->GetBestSize();
 
     return wxSize(sizeBtn.x + sizeText.x + MARGIN, sizeText.y);
 }
 
 
     return wxSize(sizeBtn.x + sizeText.x + MARGIN, sizeText.y);
 }
 
-void wxSpinCtrl::DoMoveWindow(int x, int y, int width, int height)
+void wxSpinCtrlGenericBase::DoMoveWindow(int x, int y, int width, int height)
 {
     wxControl::DoMoveWindow(x, y, width, height);
 
     // position the subcontrols inside the client area
 {
     wxControl::DoMoveWindow(x, y, width, height);
 
     // position the subcontrols inside the client area
-    wxSize sizeBtn = m_btn->GetSize();
+    wxSize sizeBtn = m_spinButton->GetSize();
 
 
-    wxCoord wText = width - sizeBtn.x;
-    m_text->SetSize(x, y, wText, height);
-    m_btn->SetSize(x + wText + MARGIN, y, wxDefaultCoord, height);
+    wxCoord wText = width - sizeBtn.x - MARGIN;
+    m_textCtrl->SetSize(x, y, wText, height);
+    m_spinButton->SetSize(x + wText + MARGIN, y, wxDefaultCoord, height);
 }
 
 // ----------------------------------------------------------------------------
 // operations forwarded to the subcontrols
 // ----------------------------------------------------------------------------
 
 }
 
 // ----------------------------------------------------------------------------
 // operations forwarded to the subcontrols
 // ----------------------------------------------------------------------------
 
-bool wxSpinCtrl::Enable(bool enable)
+void wxSpinCtrlGenericBase::SetFocus()
+{
+    if ( m_textCtrl )
+        m_textCtrl->SetFocus();
+}
+
+#ifdef __WXMSW__
+
+void wxSpinCtrlGenericBase::DoEnable(bool enable)
+{
+    // We never enable this control itself, it must stay disabled to avoid
+    // interfering with the siblings event handling (see e.g. #12045 for the
+    // kind of problems which arise otherwise).
+    if ( !enable )
+        wxSpinCtrlBase::DoEnable(enable);
+}
+
+#endif // __WXMSW__
+
+bool wxSpinCtrlGenericBase::Enable(bool enable)
 {
 {
-    if ( !wxControl::Enable(enable) )
+    if ( !wxSpinCtrlBase::Enable(enable) )
         return false;
 
         return false;
 
-    m_btn->Enable(enable);
-    m_text->Enable(enable);
+    m_spinButton->Enable(enable);
+    m_textCtrl->Enable(enable);
 
     return true;
 }
 
 
     return true;
 }
 
-bool wxSpinCtrl::Show(bool show)
+bool wxSpinCtrlGenericBase::Show(bool show)
 {
     if ( !wxControl::Show(show) )
         return false;
 
     // under GTK Show() is called the first time before we are fully
     // constructed
 {
     if ( !wxControl::Show(show) )
         return false;
 
     // under GTK Show() is called the first time before we are fully
     // constructed
-    if ( m_btn )
+    if ( m_spinButton )
     {
     {
-        m_btn->Show(show);
-        m_text->Show(show);
+        m_spinButton->Show(show);
+        m_textCtrl->Show(show);
     }
 
     return true;
 }
 
     }
 
     return true;
 }
 
+#if wxUSE_TOOLTIPS
+void wxSpinCtrlGenericBase::DoSetToolTip(wxToolTip *tip)
+{
+    // Notice that we must check for the subcontrols not being NULL (as they
+    // could be if we were created with the default ctor and this is called
+    // before Create() for some reason) and that we can't call SetToolTip(tip)
+    // because this would take ownership of the wxToolTip object (twice).
+    if ( m_textCtrl )
+    {
+        if ( tip )
+            m_textCtrl->SetToolTip(tip->GetTip());
+        else
+            m_textCtrl->SetToolTip(NULL);
+    }
+
+    if ( m_spinButton )
+    {
+        if( tip )
+            m_spinButton->SetToolTip(tip->GetTip());
+        else
+            m_spinButton->SetToolTip(NULL);
+    }
+
+    wxWindowBase::DoSetToolTip(tip);
+}
+#endif // wxUSE_TOOLTIPS
+
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
-// value and range access
+// Handle sub controls events
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 
-bool wxSpinCtrl::GetTextValue(int *val) const
+BEGIN_EVENT_TABLE(wxSpinCtrlGenericBase, wxSpinCtrlBase)
+    EVT_CHAR(wxSpinCtrlGenericBase::OnTextChar)
+    EVT_KILL_FOCUS(wxSpinCtrlGenericBase::OnTextLostFocus)
+END_EVENT_TABLE()
+
+void wxSpinCtrlGenericBase::OnSpinButton(wxSpinEvent& event)
 {
 {
-    long l;
-    if ( !m_text->GetValue().ToLong(&l) )
-    {
-        // not a number at all
-        return false;
-    }
+    event.Skip();
+
+    // Sync the textctrl since the user expects that the button will modify
+    // what they see in the textctrl.
+    SyncSpinToText();
+
+    int spin_value = event.GetPosition();
+    double step = (event.GetEventType() == wxEVT_SCROLL_LINEUP) ? 1 : -1;
 
 
-    if ( l < GetMin() || l > GetMax() )
+    // Use the spinbutton's acceleration, if any, but not if wrapping around
+    if (((spin_value >= 0) && (m_spin_value >= 0)) || ((spin_value <= 0) && (m_spin_value <= 0)))
+        step *= abs(spin_value - m_spin_value);
+
+    double value = AdjustToFitInRange(m_value + step*m_increment);
+
+    // Ignore the edges when it wraps since the up/down event may be opposite
+    // They are in GTK and Mac
+    if (abs(spin_value - m_spin_value) > SPINCTRLBUT_MAX)
     {
     {
-        // out of range
-        return false;
+        m_spin_value = spin_value;
+        return;
     }
 
     }
 
-    *val = l;
+    m_spin_value = spin_value;
 
 
-    return true;
+    if ( DoSetValue(value) )
+        DoSendEvent();
 }
 
 }
 
-int wxSpinCtrl::GetValue() const
+void wxSpinCtrlGenericBase::OnTextLostFocus(wxFocusEvent& event)
 {
 {
-    return m_btn ? m_btn->GetValue() : 0;
+    SyncSpinToText();
+    DoSendEvent();
+
+    event.Skip();
 }
 
 }
 
-int wxSpinCtrl::GetMin() const
+void wxSpinCtrlGenericBase::OnTextChar(wxKeyEvent& event)
 {
 {
-    return m_btn ? m_btn->GetMin() : 0;
+    if ( !HasFlag(wxSP_ARROW_KEYS) )
+    {
+        event.Skip();
+        return;
+    }
+
+    double value = m_value;
+    switch ( event.GetKeyCode() )
+    {
+        case WXK_UP :
+            value += m_increment;
+            break;
+
+        case WXK_DOWN :
+            value -= m_increment;
+            break;
+
+        case WXK_PAGEUP :
+            value += m_increment * 10.0;
+            break;
+
+        case WXK_PAGEDOWN :
+            value -= m_increment * 10.0;
+            break;
+
+        default:
+            event.Skip();
+            return;
+    }
+
+    value = AdjustToFitInRange(value);
+
+    SyncSpinToText();
+
+    if ( DoSetValue(value) )
+        DoSendEvent();
 }
 
 }
 
-int wxSpinCtrl::GetMax() const
+// ----------------------------------------------------------------------------
+// Textctrl functions
+// ----------------------------------------------------------------------------
+
+bool wxSpinCtrlGenericBase::SyncSpinToText()
 {
 {
-    return m_btn ? m_btn->GetMax() : 0;
+    if ( !m_textCtrl || !m_textCtrl->IsModified() )
+        return false;
+
+    double textValue;
+    if ( DoTextToValue(m_textCtrl->GetValue(), &textValue) )
+    {
+        if (textValue > m_max)
+            textValue = m_max;
+        else if (textValue < m_min)
+            textValue = m_min;
+    }
+    else // text contents is not a valid number at all
+    {
+        // replace its contents with the last valid value
+        textValue = m_value;
+    }
+
+    // we must always set the value here, even if it's equal to m_value, as
+    // otherwise we could be left with an out of range value when leaving the
+    // text control and the current value is already m_max for example
+    return DoSetValue(textValue);
 }
 
 // ----------------------------------------------------------------------------
 // changing value and range
 // ----------------------------------------------------------------------------
 
 }
 
 // ----------------------------------------------------------------------------
 // changing value and range
 // ----------------------------------------------------------------------------
 
-void wxSpinCtrl::SetTextValue(int val)
+void wxSpinCtrlGenericBase::SetValue(const wxString& text)
 {
 {
-    wxCHECK_RET( m_text, _T("invalid call to wxSpinCtrl::SetTextValue") );
+    wxCHECK_RET( m_textCtrl, wxT("invalid call to wxSpinCtrl::SetValue") );
 
 
-    m_text->SetValue(wxString::Format(_T("%d"), val));
+    double val;
+    if ( DoTextToValue(text, &val) && InRange(val) )
+    {
+        DoSetValue(val);
+    }
+    else // not a number at all or out of range
+    {
+        m_textCtrl->SetValue(text);
+        m_textCtrl->SetSelection(0, -1);
+        m_textCtrl->SetInsertionPointEnd();
+    }
+}
 
 
-    // select all text
-    m_text->SetSelection(0, -1);
+bool wxSpinCtrlGenericBase::DoSetValue(double val)
+{
+    wxCHECK_MSG( m_textCtrl, false, wxT("invalid call to wxSpinCtrl::SetValue") );
+
+    if (!InRange(val))
+        return false;
 
 
-    // and give focus to the control!
-    // m_text->SetFocus();    Why???? TODO.
+    if ( m_snap_to_ticks && (m_increment != 0) )
+    {
+        double snap_value = val / m_increment;
+
+        if (wxFinite(snap_value)) // FIXME what to do about a failure?
+        {
+            if ((snap_value - floor(snap_value)) < (ceil(snap_value) - snap_value))
+                val = floor(snap_value) * m_increment;
+            else
+                val = ceil(snap_value) * m_increment;
+        }
+    }
+
+    wxString str(DoValueToText(val));
+
+    if ((val != m_value) || (str != m_textCtrl->GetValue()))
+    {
+        if ( !DoTextToValue(str, &m_value ) )    // wysiwyg for textctrl
+            m_value = val;
+        m_textCtrl->SetValue( str );
+        m_textCtrl->SetInsertionPointEnd();
+        m_textCtrl->DiscardEdits();
+        return true;
+    }
+
+    return false;
 }
 
 }
 
-void wxSpinCtrl::SetValue(int val)
+double wxSpinCtrlGenericBase::AdjustToFitInRange(double value) const
 {
 {
-    wxCHECK_RET( m_btn, _T("invalid call to wxSpinCtrl::SetValue") );
+    if (value < m_min)
+        value = HasFlag(wxSP_WRAP) ? m_max : m_min;
+    if (value > m_max)
+        value = HasFlag(wxSP_WRAP) ? m_min : m_max;
 
 
-    SetTextValue(val);
+    return value;
+}
 
 
-    m_btn->SetValue(val);
+void wxSpinCtrlGenericBase::DoSetRange(double min, double max)
+{
+    m_min = min;
+    m_max = max;
 }
 
 }
 
-void wxSpinCtrl::SetValue(const wxString& text)
+void wxSpinCtrlGenericBase::DoSetIncrement(double inc)
 {
 {
-    wxCHECK_RET( m_text, _T("invalid call to wxSpinCtrl::SetValue") );
+    m_increment = inc;
+}
 
 
-    long val;
-    if ( text.ToLong(&val) && ((val > INT_MIN) && (val < INT_MAX)) )
-    {
-        SetValue((int)val);
-    }
-    else // not a number at all or out of range
+void wxSpinCtrlGenericBase::SetSnapToTicks(bool snap_to_ticks)
+{
+    m_snap_to_ticks = snap_to_ticks;
+    DoSetValue(m_value);
+}
+
+void wxSpinCtrlGenericBase::SetSelection(long from, long to)
+{
+    wxCHECK_RET( m_textCtrl, wxT("invalid call to wxSpinCtrl::SetSelection") );
+
+    m_textCtrl->SetSelection(from, to);
+}
+
+#ifndef wxHAS_NATIVE_SPINCTRL
+
+//-----------------------------------------------------------------------------
+// wxSpinCtrl
+//-----------------------------------------------------------------------------
+
+bool wxSpinCtrl::SetBase(int base)
+{
+    // Currently we only support base 10 and 16. We could add support for base
+    // 8 quite easily but wxMSW doesn't support it natively so don't bother.
+    if ( base != 10 && base != 16 )
+        return false;
+
+    if ( base == m_base )
+        return true;
+
+    // Update the current control contents to show in the new base: be careful
+    // to call DoTextToValue() before changing the base...
+    double val;
+    const bool hasValidVal = DoTextToValue(m_textCtrl->GetValue(), &val);
+
+    m_base = base;
+
+    // ... but DoValueToText() after doing it.
+    if ( hasValidVal )
+        m_textCtrl->SetValue(DoValueToText(val));
+
+    return true;
+}
+
+void wxSpinCtrl::DoSendEvent()
+{
+    wxSpinEvent event( wxEVT_COMMAND_SPINCTRL_UPDATED, GetId());
+    event.SetEventObject( this );
+    event.SetPosition((int)(m_value + 0.5)); // FIXME should be SetValue
+    event.SetString(m_textCtrl->GetValue());
+    GetEventHandler()->ProcessEvent( event );
+}
+
+bool wxSpinCtrl::DoTextToValue(const wxString& text, double *val)
+{
+    long lval;
+    if ( !text.ToLong(&lval, GetBase()) )
+        return false;
+
+    *val = static_cast<double>(lval);
+
+    return true;
+}
+
+wxString wxSpinCtrl::DoValueToText(double val)
+{
+    switch ( GetBase() )
     {
     {
-        m_text->SetValue(text);
-        m_text->SetSelection(0, -1);
+        case 16:
+            return wxPrivate::wxSpinCtrlFormatAsHex(static_cast<long>(val),
+                                                    GetMax());
+
+        default:
+            wxFAIL_MSG( wxS("Unsupported spin control base") );
+            // Fall through
+
+        case 10:
+            return wxString::Format("%ld", static_cast<long>(val));
     }
 }
 
     }
 }
 
-void wxSpinCtrl::SetRange(int min, int max)
+#endif // !wxHAS_NATIVE_SPINCTRL
+
+//-----------------------------------------------------------------------------
+// wxSpinCtrlDouble
+//-----------------------------------------------------------------------------
+
+IMPLEMENT_DYNAMIC_CLASS(wxSpinCtrlDouble, wxSpinCtrlGenericBase)
+
+void wxSpinCtrlDouble::DoSendEvent()
 {
 {
-    wxCHECK_RET( m_btn, _T("invalid call to wxSpinCtrl::SetRange") );
+    wxSpinDoubleEvent event( wxEVT_COMMAND_SPINCTRLDOUBLE_UPDATED, GetId());
+    event.SetEventObject( this );
+    event.SetValue(m_value);
+    event.SetString(m_textCtrl->GetValue());
+    GetEventHandler()->ProcessEvent( event );
+}
 
 
-    m_btn->SetRange(min, max);
+bool wxSpinCtrlDouble::DoTextToValue(const wxString& text, double *val)
+{
+    return text.ToDouble(val);
 }
 
 }
 
-void wxSpinCtrl::SetSelection(long from, long to)
+wxString wxSpinCtrlDouble::DoValueToText(double val)
 {
 {
-    wxCHECK_RET( m_text, _T("invalid call to wxSpinCtrl::SetSelection") );
+    return wxString::Format(m_format, val);
+}
+
+void wxSpinCtrlDouble::SetDigits(unsigned digits)
+{
+    wxCHECK_RET( digits <= 20, "too many digits for wxSpinCtrlDouble" );
+
+    if ( digits == m_digits )
+        return;
+
+    m_digits = digits;
 
 
-    m_text->SetSelection(from, to);
+    m_format.Printf(wxT("%%0.%ulf"), digits);
+
+    DoSetValue(m_value);
 }
 
 }
 
-#endif // wxUSE_SPINCTRL
+#endif // wxUSE_SPINBTN
+
 #endif // !wxPort-with-native-spinctrl
 #endif // !wxPort-with-native-spinctrl
+
+#endif // wxUSE_SPINCTRL
wxWidgets (Impactor)