// Created: 29.01.01
// RCS-ID: $Id$
// Copyright: (c) 2001 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
-// License: wxWindows license
+// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
// ============================================================================
// headers
// ----------------------------------------------------------------------------
-#ifdef __GNUG__
- #pragma implementation "spinctlg.h"
-#endif
-
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#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->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
+ 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;
+
+ m_spin = NULL;
+ }
+
+ void OnChar( wxKeyEvent &event )
+ {
+ if ( !m_spin->ProcessWindowEvent(event) )
+ event.Skip();
+ }
+
+ 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();
}
-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)
+
+ // 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->GetParent(), 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_btn->SetRange(min, max);
- m_btn->SetValue(initial);
-#ifdef __WXMAC__
- wxSize csize = size ;
- if ( size.y == -1 ) {
- csize.y = m_text->GetSize().y ;
+ 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() )
+ {
+ double d;
+ if ( DoTextToValue(value, &d) )
+ {
+ m_value = d;
+ m_textCtrl->SetValue(DoValueToText(m_value));
+ }
}
- DoSetSize(pos.x, pos.y, csize.x, csize.y);
-#else
- DoSetSize(pos.x, pos.y, size.x, size.y);
-#endif
+
+ 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
- // 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);
// 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(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();
+}
- m_btn->Enable(enable);
- m_text->Enable(enable);
+#ifdef __WXMSW__
- return TRUE;
+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);
}
-bool wxSpinCtrl::Show(bool show)
+#endif // __WXMSW__
+
+bool wxSpinCtrlGenericBase::Enable(bool enable)
+{
+ if ( !wxSpinCtrlBase::Enable(enable) )
+ return false;
+
+ m_spinButton->Enable(enable);
+ m_textCtrl->Enable(enable);
+
+ return true;
+}
+
+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_spinButton->Show(show);
+ m_textCtrl->Show(show);
+ }
+
+ 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 )
{
- m_btn->Show(show);
- m_text->Show(show);
+ if( tip )
+ m_spinButton->SetToolTip(tip->GetTip());
+ else
+ m_spinButton->SetToolTip(NULL);
}
- return TRUE;
+ 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;
+
+ // 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;
+ 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
// ----------------------------------------------------------------------------
-void wxSpinCtrl::SetTextValue(int val)
+void wxSpinCtrlGenericBase::SetValue(const wxString& text)
+{
+ wxCHECK_RET( m_textCtrl, wxT("invalid call to wxSpinCtrl::SetValue") );
+
+ 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();
+ }
+}
+
+bool wxSpinCtrlGenericBase::DoSetValue(double val)
{
- wxCHECK_RET( m_text, _T("invalid call to wxSpinCtrl::SetTextValue") );
+ wxCHECK_MSG( m_textCtrl, false, wxT("invalid call to wxSpinCtrl::SetValue") );
+
+ if (!InRange(val))
+ return false;
- m_text->SetValue(wxString::Format(_T("%d"), val));
+ 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;
+ m_textCtrl->SetValue( str );
+ m_textCtrl->SetInsertionPointEnd();
+ m_textCtrl->DiscardEdits();
+ return true;
+ }
- // and give focus to the control!
- m_text->SetFocus();
+ 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()
+{
+ wxSpinDoubleEvent event( wxEVT_COMMAND_SPINCTRLDOUBLE_UPDATED, GetId());
+ event.SetEventObject( this );
+ event.SetValue(m_value);
+ event.SetString(m_textCtrl->GetValue());
+ GetEventHandler()->ProcessEvent( event );
+}
+
+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( m_btn, _T("invalid call to wxSpinCtrl::SetRange") );
+ wxCHECK_RET( digits <= 20, "too many digits for wxSpinCtrlDouble" );
- m_btn->SetRange(min, max);
+ 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
projects / wxWidgets.git / blobdiff