// Created: 29.01.01
// RCS-ID: $Id$
// Copyright: (c) 2001 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
-// License: wxWindows licence
+// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
// ============================================================================
#endif //WX_PRECOMP
#include "wx/spinctrl.h"
+#include "wx/tooltip.h"
#if wxUSE_SPINCTRL
// 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
class wxSpinCtrlTextGeneric : public wxTextCtrl
{
public:
- wxSpinCtrlTextGeneric(wxSpinCtrlGenericBase *spin, const wxString& value)
- : wxTextCtrl(spin->GetParent(), wxID_ANY, value, wxDefaultPosition,
- wxDefaultSize, wxTE_NOHIDESEL|wxTE_PROCESS_ENTER)
+ 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;
m_spin = NULL;
}
- void OnTextEnter(wxCommandEvent& event)
+ void OnChar( wxKeyEvent &event )
{
- if (m_spin)
- m_spin->OnTextEnter(event);
+ if ( !m_spin->ProcessWindowEvent(event) )
+ event.Skip();
}
- void OnChar( wxKeyEvent &event )
+ void OnTextEvent(wxCommandEvent& event)
{
- if (m_spin)
- m_spin->OnTextChar(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->SyncSpinToText();
- m_spin->DoSendEvent();
- }
+ m_spin->ProcessWindowEvent(event);
event.Skip();
}
};
BEGIN_EVENT_TABLE(wxSpinCtrlTextGeneric, wxTextCtrl)
- EVT_TEXT_ENTER(wxID_ANY, wxSpinCtrlTextGeneric::OnTextEnter)
-
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()
{
public:
wxSpinCtrlButtonGeneric(wxSpinCtrlGenericBase *spin, int style)
- : wxSpinButton(spin->GetParent(), wxID_ANY, wxDefaultPosition,
+ : wxSpinButton(spin, wxID_ANY, wxDefaultPosition,
wxDefaultSize, style | wxSP_VERTICAL)
{
m_spin = spin;
m_max = 100;
m_increment = 1;
m_snap_to_ticks = false;
- m_format = wxS("%g");
m_spin_value = 0;
m_max = max;
m_increment = increment;
- m_textCtrl = new wxSpinCtrlTextGeneric(this, value);
+ 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
if ( !value.empty() )
{
double d;
- if ( value.ToDouble(&d) )
+ if ( DoTextToValue(value, &d) )
{
m_value = d;
- m_textCtrl->SetValue(wxString::Format(m_format, m_value));
+ m_textCtrl->SetValue(DoValueToText(m_value));
}
}
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;
-
- // we don't even need to show this window itself - and not doing it avoids
- // that it overwrites the text control
- wxControl::Show(false);
- m_isShown = true;
return true;
}
delete text;
}
- delete m_spinButton;
- m_spinButton = NULL;
+ wxDELETE(m_spinButton);
+}
+
+wxWindowList wxSpinCtrlGenericBase::GetCompositeWindowParts() const
+{
+ wxWindowList parts;
+ parts.push_back(m_textCtrl);
+ parts.push_back(m_spinButton);
+ return parts;
}
// ----------------------------------------------------------------------------
wxSize wxSpinCtrlGenericBase::DoGetBestSize() const
{
- wxSize sizeBtn = m_spinButton->GetBestSize(),
- sizeText = m_textCtrl->GetBestSize();
+ return DoGetSizeFromTextSize(m_textCtrl->GetBestSize().x, -1);
+}
+
+wxSize wxSpinCtrlGenericBase::DoGetSizeFromTextSize(int xlen, int ylen) const
+{
+ wxSize sizeBtn = m_spinButton->GetBestSize();
+ wxSize totalS( m_textCtrl->GetBestSize() );
+
+ wxSize tsize(xlen + sizeBtn.x + MARGIN, totalS.y);
+#if defined(__WXMSW__)
+ tsize.IncBy(0.4 * totalS.y + 4, 0);
+#elif defined(__WXGTK__)
+ tsize.IncBy(totalS.y + 10, 0);
+#endif // MSW GTK
- return wxSize(sizeBtn.x + sizeText.x + MARGIN, sizeText.y);
+ // Check if the user requested a non-standard height.
+ if ( ylen > 0 )
+ tsize.IncBy(0, ylen - GetCharHeight());
+
+ return tsize;
}
void wxSpinCtrlGenericBase::DoMoveWindow(int x, int y, int width, int height)
// position the subcontrols inside the client area
wxSize sizeBtn = m_spinButton->GetSize();
- wxCoord wText = width - sizeBtn.x;
- m_textCtrl->SetSize(x, y, wText, height);
- m_spinButton->SetSize(x + wText + MARGIN, y, wxDefaultCoord, 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
// ----------------------------------------------------------------------------
+void wxSpinCtrlGenericBase::SetFocus()
+{
+ if ( m_textCtrl )
+ m_textCtrl->SetFocus();
+}
+
+#ifdef __WXMSW__
+
+void wxSpinCtrlGenericBase::DoEnable(bool enable)
+{
+ wxSpinCtrlBase::DoEnable(enable);
+}
+
+#endif // __WXMSW__
+
bool wxSpinCtrlGenericBase::Enable(bool enable)
{
- if ( !wxControl::Enable(enable) )
+ if ( !wxSpinCtrlBase::Enable(enable) )
return false;
m_spinButton->Enable(enable);
return true;
}
-bool wxSpinCtrlGenericBase::Reparent(wxWindowBase *newParent)
+#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_spinButton->Reparent(newParent);
- m_textCtrl->Reparent(newParent);
+ 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;
}
// 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)
{
event.Skip();
// Sync the textctrl since the user expects that the button will modify
// what they see in the textctrl.
- if ( m_textCtrl && m_textCtrl->IsModified() )
- SyncSpinToText();
+ SyncSpinToText();
int spin_value = event.GetPosition();
double step = (event.GetEventType() == wxEVT_SCROLL_LINEUP) ? 1 : -1;
DoSendEvent();
}
-void wxSpinCtrlGenericBase::OnTextEnter(wxCommandEvent& event)
+void wxSpinCtrlGenericBase::OnTextLostFocus(wxFocusEvent& event)
{
SyncSpinToText();
DoSendEvent();
+
event.Skip();
}
value = AdjustToFitInRange(value);
- if ( m_textCtrl && m_textCtrl->IsModified() )
- SyncSpinToText();
+ SyncSpinToText();
if ( DoSetValue(value) )
DoSendEvent();
// Textctrl functions
// ----------------------------------------------------------------------------
-void wxSpinCtrlGenericBase::SyncSpinToText()
+bool wxSpinCtrlGenericBase::SyncSpinToText()
{
- if (!m_textCtrl)
- return;
+ if ( !m_textCtrl || !m_textCtrl->IsModified() )
+ return false;
double textValue;
- if ( m_textCtrl->GetValue().ToDouble(&textValue) )
+ if ( DoTextToValue(m_textCtrl->GetValue(), &textValue) )
{
if (textValue > m_max)
textValue = m_max;
else if (textValue < m_min)
textValue = m_min;
-
- if (m_value != textValue)
- {
- DoSetValue(textValue);
- }
}
- else
+ else // text contents is not a valid number at all
{
- // textctrl is out of sync, discard and reset
- DoSetValue(m_value);
+ // 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);
}
// ----------------------------------------------------------------------------
void wxSpinCtrlGenericBase::SetValue(const wxString& text)
{
- wxCHECK_RET( m_textCtrl, _T("invalid call to wxSpinCtrl::SetValue") );
+ wxCHECK_RET( m_textCtrl, wxT("invalid call to wxSpinCtrl::SetValue") );
double val;
- if ( text.ToDouble(&val) && InRange(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->SelectAll();
}
}
bool wxSpinCtrlGenericBase::DoSetValue(double val)
{
- wxCHECK_MSG( m_textCtrl, false, _T("invalid call to wxSpinCtrl::SetValue") );
+ wxCHECK_MSG( m_textCtrl, false, wxT("invalid call to wxSpinCtrl::SetValue") );
if (!InRange(val))
return false;
}
}
- wxString str(wxString::Format(m_format.c_str(), val));
+ wxString str(DoValueToText(val));
if ((val != m_value) || (str != m_textCtrl->GetValue()))
{
- m_value = val;
- str.ToDouble( &m_value ); // wysiwyg for textctrl
+ if ( !DoTextToValue(str, &m_value ) ) // wysiwyg for textctrl
+ m_value = val;
m_textCtrl->SetValue( str );
+ m_textCtrl->SelectAll();
m_textCtrl->DiscardEdits();
return true;
}
void wxSpinCtrlGenericBase::SetSelection(long from, long to)
{
- wxCHECK_RET( m_textCtrl, _T("invalid call to wxSpinCtrl::SetSelection") );
+ wxCHECK_RET( m_textCtrl, wxT("invalid call to wxSpinCtrl::SetSelection") );
m_textCtrl->SetSelection(from, to);
}
// wxSpinCtrl
//-----------------------------------------------------------------------------
-IMPLEMENT_DYNAMIC_CLASS(wxSpinCtrl, wxSpinCtrlGenericBase)
+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());
+ 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<double>(lval);
+
+ return true;
+}
+
+wxString wxSpinCtrl::DoValueToText(double val)
+{
+ switch ( GetBase() )
+ {
+ 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));
+ }
+}
+
#endif // !wxHAS_NATIVE_SPINCTRL
//-----------------------------------------------------------------------------
void wxSpinCtrlDouble::DoSendEvent()
{
- wxSpinDoubleEvent event( wxEVT_COMMAND_SPINCTRLDOUBLE_UPDATED, GetId());
+ wxSpinDoubleEvent event( wxEVT_SPINCTRLDOUBLE, 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( 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);
projects / wxWidgets.git / blobdiff