X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/9f081f02ead106131223cb8078713dbc7844e885..04fa04d8067d235ab45b5bc05b65f0679634b541:/src/generic/spinctlg.cpp?ds=sidebyside diff --git a/src/generic/spinctlg.cpp b/src/generic/spinctlg.cpp index c0dca645a1..e9a7a32a37 100644 --- 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 -// License: wxWindows license +// Licence: wxWindows licence /////////////////////////////////////////////////////////////////////////////// // ============================================================================ @@ -17,10 +17,6 @@ // headers // ---------------------------------------------------------------------------- -#ifdef __GNUG__ - #pragma implementation "spinctlg.h" -#endif - // For compilers that support precompilation, includes "wx.h". #include "wx/wxprec.h" @@ -28,343 +24,590 @@ #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/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" -#include "wx/spinctrl.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->GetParent(), wxID_ANY, value, wxDefaultPosition, wxDefaultSize, + style & wxALIGN_MASK) { 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; + if (m_spin) + m_spin->ProcessWindowEvent(event); + } + + void OnKillFocus(wxFocusEvent& event) + { + if (m_spin) + m_spin->ProcessWindowEvent(event); - return wxTextCtrl::ProcessEvent( event ); + event.Skip(); } -private: - wxSpinCtrl *m_spin; + 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) + + 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->GetParent(), wxID_ANY, wxDefaultPosition, + wxDefaultSize, style | wxSP_VERTICAL) { m_spin = spin; - SetWindowStyle(style | wxSP_VERTICAL); + SetRange(-SPINCTRLBUT_MAX, SPINCTRLBUT_MAX); + + // remove the default minsize, the spinctrl will have one instead + SetSizeHints(wxDefaultCoord, wxDefaultCoord); } -protected: - void OnSpinButton(wxSpinEvent& eventSpin) + void OnSpinButton(wxSpinEvent& event) { -#ifdef __WXMAC__ - 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); -#else - m_spin->SetTextValue(eventSpin.GetPosition()); - eventSpin.Skip(); -#endif + 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_format = wxS("%g"); + + 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, 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; + 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() ) { - long l; - if ( value.ToLong(&l) ) - initial = l; + double d; + if ( value.ToDouble(&d) ) + { + m_value = d; + m_textCtrl->SetValue(wxString::Format(m_format, m_value)); + } } - SetBackgroundColour(*wxRED); - m_text = new wxSpinCtrlText(this, value); - m_btn = new wxSpinCtrlButton(this, style); + SetInitialSize(size); + Move(pos); - m_btn->SetRange(min, max); - m_btn->SetValue(initial); -#ifdef __WXMAC__ - wxSize csize = size ; - if ( size.y == -1 ) { - csize.y = m_text->GetSize().y ; - } - 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; + // 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; + wxControl::Show(false); + m_isShown = true; + 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); } // ---------------------------------------------------------------------------- // geometry // ---------------------------------------------------------------------------- -wxSize wxSpinCtrl::DoGetBestClientSize() 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); } -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); - wxPoint p = GetParent() ? - GetParent()->GetClientAreaOrigin() : wxPoint(0,0); - // position the subcontrols inside the client area - wxSize sizeBtn = m_btn->GetSize(); - - wxCoord wText = width - sizeBtn.x; - m_text->SetSize(x-p.x, y-p.y, wText, height); -#ifdef __WXMAC__ - m_btn->SetSize(x-p.x + wText + MARGIN, y-p.y, -1, -1); -#else - m_btn->SetSize(x-p.x + wText + MARGIN, y-p.y, -1, height); -#endif + wxSize sizeBtn = m_spinButton->GetSize(); + + 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 // ---------------------------------------------------------------------------- -bool wxSpinCtrl::Enable(bool enable) +void wxSpinCtrlGenericBase::SetFocus() { - if ( !wxControl::Enable(enable) ) - return FALSE; + if ( m_textCtrl ) + m_textCtrl->SetFocus(); +} + +bool wxSpinCtrlGenericBase::Enable(bool enable) +{ + // Notice that 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 == m_isEnabled ) + return false; - m_btn->Enable(enable); - m_text->Enable(enable); + m_isEnabled = enable; - return TRUE; + m_spinButton->Enable(enable); + m_textCtrl->Enable(enable); + + 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; } -// ---------------------------------------------------------------------------- -// value and range access -// ---------------------------------------------------------------------------- - -bool wxSpinCtrl::GetTextValue(int *val) const +bool wxSpinCtrlGenericBase::Reparent(wxWindowBase *newParent) { - long l; - if ( !m_text->GetValue().ToLong(&l) ) + if ( m_spinButton ) { - // not a number at all - return FALSE; + m_spinButton->Reparent(newParent); + m_textCtrl->Reparent(newParent); } - if ( l < GetMin() || l > GetMax() ) + 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 ) { - // out of range - return FALSE; + if ( tip ) + m_textCtrl->SetToolTip(tip->GetTip()); + else + m_textCtrl->SetToolTip(NULL); } - *val = l; + if ( m_spinButton ) + { + if( tip ) + m_spinButton->SetToolTip(tip->GetTip()); + else + m_spinButton->SetToolTip(NULL); + } - return TRUE; + wxWindowBase::DoSetToolTip(tip); } +#endif // wxUSE_TOOLTIPS -int wxSpinCtrl::GetValue() const +// ---------------------------------------------------------------------------- +// Handle sub controls events +// ---------------------------------------------------------------------------- + +BEGIN_EVENT_TABLE(wxSpinCtrlGenericBase, wxSpinCtrlBase) + EVT_CHAR(wxSpinCtrlGenericBase::OnTextChar) + EVT_KILL_FOCUS(wxSpinCtrlGenericBase::OnTextLostFocus) +END_EVENT_TABLE() + +void wxSpinCtrlGenericBase::OnSpinButton(wxSpinEvent& event) { - return m_btn ? m_btn->GetValue() : 0; + 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; + + // 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) + { + m_spin_value = spin_value; + return; + } + + m_spin_value = spin_value; + + if ( DoSetValue(value) ) + DoSendEvent(); } -int wxSpinCtrl::GetMin() const +void wxSpinCtrlGenericBase::OnTextLostFocus(wxFocusEvent& event) { - return m_btn ? m_btn->GetMin() : 0; + SyncSpinToText(); + DoSendEvent(); + + event.Skip(); } -int wxSpinCtrl::GetMax() const +void wxSpinCtrlGenericBase::OnTextChar(wxKeyEvent& event) { - return m_btn ? m_btn->GetMax() : 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(); } // ---------------------------------------------------------------------------- -// changing value and range +// Textctrl functions // ---------------------------------------------------------------------------- -void wxSpinCtrl::SetTextValue(int val) +bool wxSpinCtrlGenericBase::SyncSpinToText() { - wxCHECK_RET( m_text, _T("invalid call to wxSpinCtrl::SetTextValue") ); + if ( !m_textCtrl || !m_textCtrl->IsModified() ) + return false; - m_text->SetValue(wxString::Format(_T("%d"), val)); - - // select all text - m_text->SetSelection(0, -1); + double textValue; + if ( m_textCtrl->GetValue().ToDouble(&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; + } - // and give focus to the control! - m_text->SetFocus(); + // 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); } -void wxSpinCtrl::SetValue(int val) -{ - wxCHECK_RET( m_btn, _T("invalid call to wxSpinCtrl::SetValue") ); +// ---------------------------------------------------------------------------- +// changing value and range +// ---------------------------------------------------------------------------- - SetTextValue(val); +void wxSpinCtrlGenericBase::SetValue(const wxString& text) +{ + wxCHECK_RET( m_textCtrl, wxT("invalid call to wxSpinCtrl::SetValue") ); - m_btn->SetValue(val); + double val; + if ( text.ToDouble(&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(); + } } -void wxSpinCtrl::SetValue(const wxString& text) +bool wxSpinCtrlGenericBase::DoSetValue(double val) { - wxCHECK_RET( m_text, _T("invalid call to wxSpinCtrl::SetValue") ); + wxCHECK_MSG( m_textCtrl, false, wxT("invalid call to wxSpinCtrl::SetValue") ); + + if (!InRange(val)) + return false; - long val; - if ( text.ToLong(&val) && ((val > INT_MIN) && (val < INT_MAX)) ) + if ( m_snap_to_ticks && (m_increment != 0) ) { - SetValue((int)val); + 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; + } } - else // not a number at all or out of range + + wxString str(wxString::Format(m_format.c_str(), val)); + + if ((val != m_value) || (str != m_textCtrl->GetValue())) { - m_text->SetValue(text); - m_text->SetSelection(0, -1); + m_value = val; + str.ToDouble( &m_value ); // wysiwyg for textctrl + m_textCtrl->SetValue( str ); + m_textCtrl->SetInsertionPointEnd(); + m_textCtrl->DiscardEdits(); + return true; } + + return false; } -void wxSpinCtrl::SetRange(int min, int max) +double wxSpinCtrlGenericBase::AdjustToFitInRange(double value) const { - wxCHECK_RET( m_btn, _T("invalid call to wxSpinCtrl::SetRange") ); + if (value < m_min) + value = HasFlag(wxSP_WRAP) ? m_max : m_min; + if (value > m_max) + value = HasFlag(wxSP_WRAP) ? m_min : m_max; - m_btn->SetRange(min, max); + return value; } -#endif // wxUSE_SPINCTRL +void wxSpinCtrlGenericBase::DoSetRange(double min, double max) +{ + m_min = min; + m_max = max; +} + +void wxSpinCtrlGenericBase::DoSetIncrement(double inc) +{ + m_increment = inc; +} + +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 +//----------------------------------------------------------------------------- + +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 ); +} + +#endif // !wxHAS_NATIVE_SPINCTRL + +//----------------------------------------------------------------------------- +// wxSpinCtrlDouble +//----------------------------------------------------------------------------- + +IMPLEMENT_DYNAMIC_CLASS(wxSpinCtrlDouble, wxSpinCtrlGenericBase) + +void wxSpinCtrlDouble::DoSendEvent() +{ + wxSpinDoubleEvent event( wxEVT_COMMAND_SPINCTRLDOUBLE_UPDATED, GetId()); + event.SetEventObject( this ); + event.SetValue(m_value); + event.SetString(m_textCtrl->GetValue()); + GetEventHandler()->ProcessEvent( event ); +} + +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); +} + +#endif // wxUSE_SPINBTN + #endif // !wxPort-with-native-spinctrl + +#endif // wxUSE_SPINCTRL