X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/170acdc90e9f92f8b8120fa6c04acdbf45c89582..1680c3561bc4f44c63a026e0d1a5324a39336156:/src/generic/spinctlg.cpp diff --git a/src/generic/spinctlg.cpp b/src/generic/spinctlg.cpp index 88de174cfd..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 licence +// Licence: wxWindows licence /////////////////////////////////////////////////////////////////////////////// // ============================================================================ @@ -24,165 +24,196 @@ #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 +#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(), wxID_ANY, 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); + 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); + } - return wxTextCtrl::ProcessEvent( event ); + void OnKillFocus(wxFocusEvent& event) + { + if (m_spin) + m_spin->ProcessWindowEvent(event); + + event.Skip(); } -private: - wxSpinCtrl *m_spin; + wxSpinCtrlGenericBase *m_spin; +private: DECLARE_EVENT_TABLE() }; -BEGIN_EVENT_TABLE(wxSpinCtrlText, wxTextCtrl) - EVT_TEXT(wxID_ANY, 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); + 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() }; -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() -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; } + 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)); + } } - m_text = new wxSpinCtrlText(this, value); - m_btn = new wxSpinCtrlButton(this, style); - - m_btn->SetRange(min, max); - m_btn->SetValue(initial); SetInitialSize(size); Move(pos); @@ -199,166 +230,384 @@ bool wxSpinCtrl::Create(wxWindow *parent, 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 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 // ---------------------------------------------------------------------------- -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); } -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, 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 // ---------------------------------------------------------------------------- -bool wxSpinCtrl::Enable(bool enable) +void wxSpinCtrlGenericBase::SetFocus() { - if ( !wxControl::Enable(enable) ) + 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; + + 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; // 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; } -// ---------------------------------------------------------------------------- -// 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 + +// ---------------------------------------------------------------------------- +// Handle sub controls events +// ---------------------------------------------------------------------------- -int wxSpinCtrl::GetValue() const +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") ); - - m_text->SetValue(wxString::Format(_T("%d"), val)); + if ( !m_textCtrl || !m_textCtrl->IsModified() ) + return false; - // 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(); Why???? TODO. + // 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; } -void wxSpinCtrl::SetSelection(long from, long to) +void wxSpinCtrlGenericBase::DoSetRange(double min, double max) { - wxCHECK_RET( m_text, _T("invalid call to wxSpinCtrl::SetSelection") ); + m_min = min; + m_max = max; +} - m_text->SetSelection(from, to); +void wxSpinCtrlGenericBase::DoSetIncrement(double inc) +{ + m_increment = inc; } -#endif // wxUSE_SPINCTRL +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