X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/23d416bfc42eb1d30f6104b658fdd2dbccda8c52..0cae0a4e1830b34fcc69cc9fa1d04b528c2a1fb4:/src/generic/spinctlg.cpp diff --git a/src/generic/spinctlg.cpp b/src/generic/spinctlg.cpp index cea2e0b054..3da88c9404 100644 --- a/src/generic/spinctlg.cpp +++ b/src/generic/spinctlg.cpp @@ -4,9 +4,8 @@ // Author: Vadim Zeitlin // Modified by: // Created: 29.01.01 -// RCS-ID: $Id$ // Copyright: (c) 2001 Vadim Zeitlin -// License: wxWindows license +// Licence: wxWindows licence /////////////////////////////////////////////////////////////////////////////// // ============================================================================ @@ -17,10 +16,6 @@ // headers // ---------------------------------------------------------------------------- -#ifdef __GNUG__ - #pragma implementation "spinctlg.h" -#endif - // For compilers that support precompilation, includes "wx.h". #include "wx/wxprec.h" @@ -28,313 +23,709 @@ #pragma hdrstop #endif -#if !(defined(__WXMSW__) || defined(__WXGTK__) || defined(__WXPM__)) || defined(__WXMAC__) || \ - defined(__WXUNIVERSAL__) - #ifndef WX_PRECOMP #include "wx/textctrl.h" #endif //WX_PRECOMP -#include "wx/spinbutt.h" #include "wx/spinctrl.h" +#include "wx/tooltip.h" + +#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" + +#if wxUSE_SPINBTN // ---------------------------------------------------------------------------- // 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: - wxSpinCtrlText(wxSpinCtrl *spin, const wxString& value) - : wxTextCtrl(spin->GetParent(), -1, value) + wxSpinCtrlTextGeneric(wxSpinCtrlGenericBase *spin, const wxString& value, long style=0) + : wxTextCtrl(spin, 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 + 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; - - return wxTextCtrl::ProcessEvent( event ); + if ( !m_spin->ProcessWindowEvent(event) ) + event.Skip(); } -private: - wxSpinCtrl *m_spin; + void OnTextEvent(wxCommandEvent& event) + { + wxCommandEvent eventCopy(event); + eventCopy.SetEventObject(m_spin); + eventCopy.SetId(m_spin->GetId()); + m_spin->ProcessWindowEvent(eventCopy); + } + + void OnKillFocus(wxFocusEvent& event) + { + if (m_spin) + m_spin->ProcessWindowEvent(event); + event.Skip(); + } + + wxSpinCtrlGenericBase *m_spin; + +private: DECLARE_EVENT_TABLE() }; -BEGIN_EVENT_TABLE(wxSpinCtrlText, wxTextCtrl) - EVT_TEXT(-1, 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() // ---------------------------------------------------------------------------- -// wxSpinCtrlButton: spin button used by spin control +// wxSpinCtrlButtonGeneric: spin button used by spin control // ---------------------------------------------------------------------------- -class wxSpinCtrlButton : public wxSpinButton +class wxSpinCtrlButtonGeneric : public wxSpinButton { public: - wxSpinCtrlButton(wxSpinCtrl *spin, int style) - : wxSpinButton(spin->GetParent()) + wxSpinCtrlButtonGeneric(wxSpinCtrlGenericBase *spin, int style) + : wxSpinButton(spin, wxID_ANY, wxDefaultPosition, + wxDefaultSize, style | wxSP_VERTICAL) { m_spin = spin; - SetWindowStyle(style); + SetRange(-SPINCTRLBUT_MAX, SPINCTRLBUT_MAX); + + // remove the default minsize, the spinctrl will have one instead + SetSizeHints(wxDefaultCoord, wxDefaultCoord); } -protected: void OnSpinButton(wxSpinEvent& event) { - m_spin->SetTextValue(event.GetPosition()); - - event.Skip(); + if (m_spin) + m_spin->OnSpinButton(event); } -private: - wxSpinCtrl *m_spin; + wxSpinCtrlGenericBase *m_spin; +private: DECLARE_EVENT_TABLE() }; -BEGIN_EVENT_TABLE(wxSpinCtrlButton, wxSpinButton) - EVT_SPIN(-1, wxSpinCtrlButton::OnSpinButton) +BEGIN_EVENT_TABLE(wxSpinCtrlButtonGeneric, wxSpinButton) + EVT_SPIN_UP( wxID_ANY, wxSpinCtrlButtonGeneric::OnSpinButton) + EVT_SPIN_DOWN(wxID_ANY, wxSpinCtrlButtonGeneric::OnSpinButton) 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& 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, pos, size, 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; + return false; } - SetBackgroundColour(*wxRED); - m_text = new wxSpinCtrlText(this, value); - m_btn = new wxSpinCtrlButton(this, style); + 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); - m_btn->SetRange(min, max); - m_btn->SetValue(initial); -#ifdef __WXMAC__ - wxSize csize = size ; - if ( size.y == -1 ) { - csize.y = m_text->GetSize().y ; +#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() ) + { + double d; + if ( DoTextToValue(value, &d) ) + { + m_value = d; + m_textCtrl->ChangeValue(DoValueToText(m_value)); + } } - DoSetSize(pos.x, pos.y, csize.x, csize.y); -#else - DoSetSize(pos.x, pos.y, size.x, size.y); -#endif - // have to disable this window to avoid interfering it with message - // processing to the text and the button... but pretend it is enabled to - // make IsEnabled() return TRUE - wxControl::Enable(FALSE); // don't use non virtual Disable() here! - m_isEnabled = TRUE; - - // we don't even need to show this window itself - and not doing it avoids - // that it overwrites the text control - wxControl::Show(FALSE); -#ifndef __WXMAC__ - m_isShown = TRUE; -#endif - return TRUE; + + SetInitialSize(size); + Move(pos); + + return true; } -wxSpinCtrl::~wxSpinCtrl() +wxSpinCtrlGenericBase::~wxSpinCtrlGenericBase() { - // delete the controls now, don't leave them alive even though they woudl + // 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; - delete m_btn; + + 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); +} + +wxWindowList wxSpinCtrlGenericBase::GetCompositeWindowParts() const +{ + wxWindowList parts; + parts.push_back(m_textCtrl); + parts.push_back(m_spinButton); + return parts; } // ---------------------------------------------------------------------------- // geometry // ---------------------------------------------------------------------------- -wxSize wxSpinCtrl::DoGetBestClientSize() const +wxSize wxSpinCtrlGenericBase::DoGetBestSize() const +{ + return DoGetSizeFromTextSize(m_textCtrl->GetBestSize().x, -1); +} + +wxSize wxSpinCtrlGenericBase::DoGetSizeFromTextSize(int xlen, int ylen) const { - wxSize sizeBtn = m_btn->GetBestSize(), - sizeText = m_text->GetBestSize(); + wxSize sizeBtn = m_spinButton->GetBestSize(); + wxSize totalS( m_textCtrl->GetBestSize() ); - return wxSize(sizeBtn.x + sizeText.x + MARGIN, sizeText.y); + wxSize tsize(xlen + sizeBtn.x + MARGIN, totalS.y); +#if defined(__WXMSW__) + tsize.IncBy(4*totalS.y/10 + 4, 0); +#elif defined(__WXGTK__) + tsize.IncBy(totalS.y + 10, 0); +#endif // MSW GTK + + // Check if the user requested a non-standard height. + if ( ylen > 0 ) + tsize.IncBy(0, ylen - GetCharHeight()); + + return tsize; } -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 - 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, -1, height); + wxCoord wText = width - sizeBtn.x - MARGIN; + m_textCtrl->SetSize(0, 0, wText, height); + m_spinButton->SetSize(0 + wText + MARGIN, 0, wxDefaultCoord, height); } // ---------------------------------------------------------------------------- // 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) { - if ( !wxControl::Enable(enable) ) - return FALSE; + wxSpinCtrlBase::DoEnable(enable); +} + +#endif // __WXMSW__ + +bool wxSpinCtrlGenericBase::Enable(bool enable) +{ + if ( !wxSpinCtrlBase::Enable(enable) ) + 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; + 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 + +bool wxSpinCtrlGenericBase::SetBackgroundColour(const wxColour& colour) +{ + // We need to provide this otherwise the entire composite window + // background and therefore the between component spaces + // will be changed. + if ( m_textCtrl ) + return m_textCtrl->SetBackgroundColour(colour); + + return true; } // ---------------------------------------------------------------------------- -// 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(SendEvent_None); + + int spin_value = event.GetPosition(); + double step = (event.GetEventType() == wxEVT_SCROLL_LINEUP) ? 1 : -1; + + // 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); - if ( l < GetMin() || l > GetMax() ) + 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; + // Notify about the change in wxTextCtrl too. + if ( DoSetValue(value, SendEvent_Text) ) + DoSendEvent(); } -int wxSpinCtrl::GetValue() const +void wxSpinCtrlGenericBase::OnTextLostFocus(wxFocusEvent& event) { - return m_btn ? m_btn->GetValue() : 0; + SyncSpinToText(SendEvent_Text); + 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(SendEvent_None); + + // No need to send event, it was already generated by wxTextCtrl itself. + if ( DoSetValue(value, SendEvent_None) ) + DoSendEvent(); } -int wxSpinCtrl::GetMax() const +// ---------------------------------------------------------------------------- +// Textctrl functions +// ---------------------------------------------------------------------------- + +bool wxSpinCtrlGenericBase::SyncSpinToText(SendEvent sendEvent) { - 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, sendEvent); } // ---------------------------------------------------------------------------- // 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, SendEvent_None); + } + else // not a number at all or out of range + { + m_textCtrl->ChangeValue(text); + m_textCtrl->SelectAll(); + } +} + +bool wxSpinCtrlGenericBase::DoSetValue(double val, SendEvent sendEvent) +{ + wxCHECK_MSG( m_textCtrl, false, wxT("invalid call to wxSpinCtrl::SetValue") ); + + if ( val < m_min ) + val = m_min; + if ( val > m_max ) + val = m_max; + + if ( m_snap_to_ticks && (m_increment != 0) ) + { + double snap_value = val / m_increment; - // select all text - m_text->SetSelection(0, -1); + 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; - // and give focus to the control! - m_text->SetFocus(); + switch ( sendEvent ) + { + case SendEvent_None: + m_textCtrl->ChangeValue(str); + break; + + case SendEvent_Text: + m_textCtrl->SetValue(str); + break; + } + + m_textCtrl->SelectAll(); + 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; + if ( m_value < m_min ) + DoSetValue(m_min, SendEvent_None); + m_max = max; + if ( m_value > m_max ) + DoSetValue(m_max, SendEvent_None); } -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, SendEvent_None); +} + +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->ChangeValue(DoValueToText(val)); + + return true; +} + +void wxSpinCtrl::DoSendEvent() +{ + wxSpinEvent event( wxEVT_SPINCTRL, 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(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(val), + GetMax()); + + default: + wxFAIL_MSG( wxS("Unsupported spin control base") ); + // Fall through + + case 10: + return wxString::Format("%ld", static_cast(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_SPINCTRLDOUBLE, 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); } +wxString wxSpinCtrlDouble::DoValueToText(double val) +{ + 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_format.Printf(wxT("%%0.%ulf"), digits); + + DoSetValue(m_value, SendEvent_None); +} + +#endif // wxUSE_SPINBTN + #endif // !wxPort-with-native-spinctrl + +#endif // wxUSE_SPINCTRL