src/generic/spinctlg.cpp

///////////////////////////////////////////////////////////////////////////////
// Name:        src/generic/spinctlg.cpp
// Purpose:     implements wxSpinCtrl as a composite control
// Author:      Vadim Zeitlin
// Modified by:
// Created:     29.01.01
// RCS-ID:      $Id$
// Copyright:   (c) 2001 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
// License:     wxWindows licence
///////////////////////////////////////////////////////////////////////////////

// ============================================================================
// declarations
// ============================================================================

// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#ifndef WX_PRECOMP
    #include "wx/textctrl.h"
#endif //WX_PRECOMP

#include "wx/spinctrl.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;

#define SPINCTRLBUT_MAX 32000 // large to avoid wrap around trouble

// ----------------------------------------------------------------------------
// wxSpinCtrlTextGeneric: text control used by spin control
// ----------------------------------------------------------------------------

class wxSpinCtrlTextGeneric : public wxTextCtrl
{
public:
    wxSpinCtrlTextGeneric(wxSpinCtrlGenericBase *spin, const wxString& value)
        : wxTextCtrl(spin->GetParent(), wxID_ANY, value, wxDefaultPosition,
                     wxDefaultSize, wxTE_NOHIDESEL|wxTE_PROCESS_ENTER)
    {
        m_spin = spin;

        // remove the default minsize, the spinctrl will have one instead
        SetSizeHints(wxDefaultCoord, wxDefaultCoord);
    }

    virtual ~wxSpinCtrlTextGeneric()
    {
        // MSW sends extra kill focus event on destroy
        if (m_spin)
            m_spin->m_textCtrl = NULL;

        m_spin = NULL;
    }

    void OnTextEnter(wxCommandEvent& event)
    {
        if (m_spin)
            m_spin->OnTextEnter(event);
    }

    void OnChar( wxKeyEvent &event )
    {
        if (m_spin)
            m_spin->OnTextChar(event);
    }

    void OnKillFocus(wxFocusEvent& event)
    {
        if (m_spin)
        {
            m_spin->SyncSpinToText();
            m_spin->DoSendEvent();
        }

        event.Skip();
    }

    wxSpinCtrlGenericBase *m_spin;

private:
    DECLARE_EVENT_TABLE()
};

BEGIN_EVENT_TABLE(wxSpinCtrlTextGeneric, wxTextCtrl)
    EVT_TEXT_ENTER(wxID_ANY, wxSpinCtrlTextGeneric::OnTextEnter)

    EVT_CHAR(wxSpinCtrlTextGeneric::OnChar)

    EVT_KILL_FOCUS(wxSpinCtrlTextGeneric::OnKillFocus)
END_EVENT_TABLE()

// ----------------------------------------------------------------------------
// wxSpinCtrlButtonGeneric: spin button used by spin control
// ----------------------------------------------------------------------------

class wxSpinCtrlButtonGeneric : public wxSpinButton
{
public:
    wxSpinCtrlButtonGeneric(wxSpinCtrlGenericBase *spin, int style)
        : wxSpinButton(spin->GetParent(), wxID_ANY, wxDefaultPosition,
                       wxDefaultSize, style | wxSP_VERTICAL)
    {
        m_spin = spin;

        SetRange(-SPINCTRLBUT_MAX, SPINCTRLBUT_MAX);

        // remove the default minsize, the spinctrl will have one instead
        SetSizeHints(wxDefaultCoord, wxDefaultCoord);
    }

    void OnSpinButton(wxSpinEvent& event)
    {
        if (m_spin)
            m_spin->OnSpinButton(event);
    }

    wxSpinCtrlGenericBase *m_spin;

private:
    DECLARE_EVENT_TABLE()
};

BEGIN_EVENT_TABLE(wxSpinCtrlButtonGeneric, wxSpinButton)
    EVT_SPIN_UP(  wxID_ANY, wxSpinCtrlButtonGeneric::OnSpinButton)
    EVT_SPIN_DOWN(wxID_ANY, wxSpinCtrlButtonGeneric::OnSpinButton)
END_EVENT_TABLE()

// ============================================================================
// wxSpinCtrlGenericBase
// ============================================================================

// ----------------------------------------------------------------------------
// wxSpinCtrlGenericBase creation
// ----------------------------------------------------------------------------

void wxSpinCtrlGenericBase::Init()
{
    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 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)
{
    // 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,
                            wxBORDER_NONE, wxDefaultValidator, name) )
    {
        return false;
    }

    m_value = initial;
    m_min   = min;
    m_max   = max;
    m_increment = increment;

    m_textCtrl   = new wxSpinCtrlTextGeneric(this, value);
    m_spinButton = new wxSpinCtrlButtonGeneric(this, style);

    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 ( value.ToDouble(&d) )
        {
            m_value = d;
            m_textCtrl->SetValue(wxString::Format(m_format, 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;
}

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

    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;
    }

    delete m_spinButton;
    m_spinButton = NULL;
}

// ----------------------------------------------------------------------------
// geometry
// ----------------------------------------------------------------------------

wxSize wxSpinCtrlGenericBase::DoGetBestSize() const
{
    wxSize sizeBtn  = m_spinButton->GetBestSize(),
           sizeText = m_textCtrl->GetBestSize();

    return wxSize(sizeBtn.x + sizeText.x + MARGIN, sizeText.y);
}

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_spinButton->GetSize();

    wxCoord wText = width - sizeBtn.x;
    m_textCtrl->SetSize(x, y, wText, height);
    m_spinButton->SetSize(x + wText + MARGIN, y, wxDefaultCoord, height);
}

// ----------------------------------------------------------------------------
// operations forwarded to the subcontrols
// ----------------------------------------------------------------------------

bool wxSpinCtrlGenericBase::Enable(bool enable)
{
    if ( !wxControl::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;

    // under GTK Show() is called the first time before we are fully
    // constructed
    if ( m_spinButton )
    {
        m_spinButton->Show(show);
        m_textCtrl->Show(show);
    }

    return true;
}

bool wxSpinCtrlGenericBase::Reparent(wxWindowBase *newParent)
{
    if ( m_spinButton )
    {
        m_spinButton->Reparent(newParent);
        m_textCtrl->Reparent(newParent);
    }

    return true;
}

// ----------------------------------------------------------------------------
// Handle sub controls events
// ----------------------------------------------------------------------------

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();

    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 = m_value + step*m_increment;

    // we can always reach the ends using the spinbutton
    if (value < m_min) value = m_min;
    if (value > m_max) value = m_max;

    // 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 (InRange(value) && DoSetValue(value))
        DoSendEvent();
}

void wxSpinCtrlGenericBase::OnTextEnter(wxCommandEvent& event)
{
    SyncSpinToText();
    DoSendEvent();
    event.Skip();
}

void wxSpinCtrlGenericBase::OnTextChar(wxKeyEvent& event)
{
    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;
    }

    if ( m_textCtrl && m_textCtrl->IsModified() )
        SyncSpinToText();

    if ( DoSetValue(value) )
        DoSendEvent();
}

// ----------------------------------------------------------------------------
// Textctrl functions
// ----------------------------------------------------------------------------

void wxSpinCtrlGenericBase::SyncSpinToText()
{
    if (!m_textCtrl)
        return;

    double textValue;
    if ( m_textCtrl->GetValue().ToDouble(&textValue) )
    {
        if (textValue > m_max)
            textValue = m_max;
        else if (textValue < m_min)
            textValue = m_min;

        if (m_value != textValue)
        {
            DoSetValue(textValue);
        }
    }
    else
    {
        // textctrl is out of sync, discard and reset
        DoSetValue(m_value);
    }
}

// ----------------------------------------------------------------------------
// changing value and range
// ----------------------------------------------------------------------------

void wxSpinCtrlGenericBase::SetValue(const wxString& text)
{
    wxCHECK_RET( m_textCtrl, _T("invalid call to wxSpinCtrl::SetValue") );

    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);
    }
}

bool wxSpinCtrlGenericBase::DoSetValue(double val)
{
    wxCHECK_MSG( m_textCtrl, false, _T("invalid call to wxSpinCtrl::SetValue") );

    if (!InRange(val))
        return false;

    if ( m_snap_to_ticks && (m_increment != 0) )
    {
        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;
        }
    }

    wxString str(wxString::Format(m_format.c_str(), val));

    if ((val != m_value) || (str != m_textCtrl->GetValue()))
    {
        m_value = val;
        str.ToDouble( &m_value );    // wysiwyg for textctrl
        m_textCtrl->SetValue( str );
        m_textCtrl->DiscardEdits();
        return true;
    }

    return false;
}

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, _T("invalid call to wxSpinCtrl::SetSelection") );

    m_textCtrl->SetSelection(from, to);
}

#ifndef wxHAS_NATIVE_SPINCTRL

//-----------------------------------------------------------------------------
// wxSpinCtrl
//-----------------------------------------------------------------------------

IMPLEMENT_DYNAMIC_CLASS(wxSpinCtrl, wxSpinCtrlGenericBase)

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" );

    m_format.Printf(wxT("%%0.%ulf"), digits);

    DoSetValue(m_value);
}

#endif // wxUSE_SPINBTN

#endif // !wxPort-with-native-spinctrl

#endif // wxUSE_SPINCTRL
Commit	Line	Data
	1	///////////////////////////////////////////////////////////////////////////////
	2	// Name: src/generic/spinctlg.cpp
	3	// Purpose: implements wxSpinCtrl as a composite control
	4	// Author: Vadim Zeitlin
	5	// Modified by:
	6	// Created: 29.01.01
	7	// RCS-ID: $Id$
	8	// Copyright: (c) 2001 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
	9	// License: wxWindows licence
	10	///////////////////////////////////////////////////////////////////////////////
	11
	12	// ============================================================================
	13	// declarations
	14	// ============================================================================
	15
	16	// ----------------------------------------------------------------------------
	17	// headers
	18	// ----------------------------------------------------------------------------
	19
	20	// For compilers that support precompilation, includes "wx.h".
	21	#include "wx/wxprec.h"
	22
	23	#ifdef __BORLANDC__
	24	#pragma hdrstop
	25	#endif
	26
	27	#ifndef WX_PRECOMP
	28	#include "wx/textctrl.h"
	29	#endif //WX_PRECOMP
	30
	31	#include "wx/spinctrl.h"
	32
	33	#if wxUSE_SPINCTRL
	34
	35	IMPLEMENT_DYNAMIC_CLASS(wxSpinDoubleEvent, wxNotifyEvent)
	36
	37	// There are port-specific versions for the wxSpinCtrl, so exclude the
	38	// contents of this file in those cases
	39	#if !defined(wxHAS_NATIVE_SPINCTRL) \|\| !defined(wxHAS_NATIVE_SPINCTRLDOUBLE)
	40
	41	#include "wx/spinbutt.h"
	42
	43	#if wxUSE_SPINBTN
	44
	45	// ----------------------------------------------------------------------------
	46	// constants
	47	// ----------------------------------------------------------------------------
	48
	49	// the margin between the text control and the spin
	50	static const wxCoord MARGIN = 2;
	51
	52	#define SPINCTRLBUT_MAX 32000 // large to avoid wrap around trouble
	53
	54	// ----------------------------------------------------------------------------
	55	// wxSpinCtrlTextGeneric: text control used by spin control
	56	// ----------------------------------------------------------------------------
	57
	58	class wxSpinCtrlTextGeneric : public wxTextCtrl
	59	{
	60	public:
	61	wxSpinCtrlTextGeneric(wxSpinCtrlGenericBase *spin, const wxString& value)
	62	: wxTextCtrl(spin->GetParent(), wxID_ANY, value, wxDefaultPosition,
	63	wxDefaultSize, wxTE_NOHIDESEL\|wxTE_PROCESS_ENTER)
	64	{
	65	m_spin = spin;
	66
	67	// remove the default minsize, the spinctrl will have one instead
	68	SetSizeHints(wxDefaultCoord, wxDefaultCoord);
	69	}
	70
	71	virtual ~wxSpinCtrlTextGeneric()
	72	{
	73	// MSW sends extra kill focus event on destroy
	74	if (m_spin)
	75	m_spin->m_textCtrl = NULL;
	76
	77	m_spin = NULL;
	78	}
	79
	80	void OnTextEnter(wxCommandEvent& event)
	81	{
	82	if (m_spin)
	83	m_spin->OnTextEnter(event);
	84	}
	85
	86	void OnChar( wxKeyEvent &event )
	87	{
	88	if (m_spin)
	89	m_spin->OnTextChar(event);
	90	}
	91
	92	void OnKillFocus(wxFocusEvent& event)
	93	{
	94	if (m_spin)
	95	{
	96	m_spin->SyncSpinToText();
	97	m_spin->DoSendEvent();
	98	}
	99
	100	event.Skip();
	101	}
	102
	103	wxSpinCtrlGenericBase *m_spin;
	104
	105	private:
	106	DECLARE_EVENT_TABLE()
	107	};
	108
	109	BEGIN_EVENT_TABLE(wxSpinCtrlTextGeneric, wxTextCtrl)
	110	EVT_TEXT_ENTER(wxID_ANY, wxSpinCtrlTextGeneric::OnTextEnter)
	111
	112	EVT_CHAR(wxSpinCtrlTextGeneric::OnChar)
	113
	114	EVT_KILL_FOCUS(wxSpinCtrlTextGeneric::OnKillFocus)
	115	END_EVENT_TABLE()
	116
	117	// ----------------------------------------------------------------------------
	118	// wxSpinCtrlButtonGeneric: spin button used by spin control
	119	// ----------------------------------------------------------------------------
	120
	121	class wxSpinCtrlButtonGeneric : public wxSpinButton
	122	{
	123	public:
	124	wxSpinCtrlButtonGeneric(wxSpinCtrlGenericBase *spin, int style)
	125	: wxSpinButton(spin->GetParent(), wxID_ANY, wxDefaultPosition,
	126	wxDefaultSize, style \| wxSP_VERTICAL)
	127	{
	128	m_spin = spin;
	129
	130	SetRange(-SPINCTRLBUT_MAX, SPINCTRLBUT_MAX);
	131
	132	// remove the default minsize, the spinctrl will have one instead
	133	SetSizeHints(wxDefaultCoord, wxDefaultCoord);
	134	}
	135
	136	void OnSpinButton(wxSpinEvent& event)
	137	{
	138	if (m_spin)
	139	m_spin->OnSpinButton(event);
	140	}
	141
	142	wxSpinCtrlGenericBase *m_spin;
	143
	144	private:
	145	DECLARE_EVENT_TABLE()
	146	};
	147
	148	BEGIN_EVENT_TABLE(wxSpinCtrlButtonGeneric, wxSpinButton)
	149	EVT_SPIN_UP( wxID_ANY, wxSpinCtrlButtonGeneric::OnSpinButton)
	150	EVT_SPIN_DOWN(wxID_ANY, wxSpinCtrlButtonGeneric::OnSpinButton)
	151	END_EVENT_TABLE()
	152
	153	// ============================================================================
	154	// wxSpinCtrlGenericBase
	155	// ============================================================================
	156
	157	// ----------------------------------------------------------------------------
	158	// wxSpinCtrlGenericBase creation
	159	// ----------------------------------------------------------------------------
	160
	161	void wxSpinCtrlGenericBase::Init()
	162	{
	163	m_value = 0;
	164	m_min = 0;
	165	m_max = 100;
	166	m_increment = 1;
	167	m_snap_to_ticks = false;
	168	m_format = wxS("%g");
	169
	170	m_spin_value = 0;
	171
	172	m_textCtrl = NULL;
	173	m_spinButton = NULL;
	174	}
	175
	176	bool wxSpinCtrlGenericBase::Create(wxWindow *parent,
	177	wxWindowID id,
	178	const wxString& value,
	179	const wxPoint& pos, const wxSize& size,
	180	long style,
	181	double min, double max, double initial,
	182	double increment,
	183	const wxString& name)
	184	{
	185	// don't use borders for this control itself, it wouldn't look good with
	186	// the text control borders (but we might want to use style border bits to
	187	// select the text control style)
	188	if ( !wxControl::Create(parent, id, wxDefaultPosition, wxDefaultSize,
	189	wxBORDER_NONE, wxDefaultValidator, name) )
	190	{
	191	return false;
	192	}
	193
	194	m_value = initial;
	195	m_min = min;
	196	m_max = max;
	197	m_increment = increment;
	198
	199	m_textCtrl = new wxSpinCtrlTextGeneric(this, value);
	200	m_spinButton = new wxSpinCtrlButtonGeneric(this, style);
	201
	202	m_spin_value = m_spinButton->GetValue();
	203
	204	// the string value overrides the numeric one (for backwards compatibility
	205	// reasons and also because it is simpler to satisfy the string value which
	206	// comes much sooner in the list of arguments and leave the initial
	207	// parameter unspecified)
	208	if ( !value.empty() )
	209	{
	210	double d;
	211	if ( value.ToDouble(&d) )
	212	{
	213	m_value = d;
	214	m_textCtrl->SetValue(wxString::Format(m_format, m_value));
	215	}
	216	}
	217
	218	SetInitialSize(size);
	219	Move(pos);
	220
	221	// have to disable this window to avoid interfering it with message
	222	// processing to the text and the button... but pretend it is enabled to
	223	// make IsEnabled() return true
	224	wxControl::Enable(false); // don't use non virtual Disable() here!
	225	m_isEnabled = true;
	226
	227	// we don't even need to show this window itself - and not doing it avoids
	228	// that it overwrites the text control
	229	wxControl::Show(false);
	230	m_isShown = true;
	231	return true;
	232	}
	233
	234	wxSpinCtrlGenericBase::~wxSpinCtrlGenericBase()
	235	{
	236	// delete the controls now, don't leave them alive even though they would
	237	// still be eventually deleted by our parent - but it will be too late, the
	238	// user code expects them to be gone now
	239
	240	if (m_textCtrl)
	241	{
	242	// null this since MSW sends KILL_FOCUS on deletion, see ~wxSpinCtrlTextGeneric
	243	wxDynamicCast(m_textCtrl, wxSpinCtrlTextGeneric)->m_spin = NULL;
	244
	245	wxSpinCtrlTextGeneric text = (wxSpinCtrlTextGeneric)m_textCtrl;
	246	m_textCtrl = NULL;
	247	delete text;
	248	}
	249
	250	delete m_spinButton;
	251	m_spinButton = NULL;
	252	}
	253
	254	// ----------------------------------------------------------------------------
	255	// geometry
	256	// ----------------------------------------------------------------------------
	257
	258	wxSize wxSpinCtrlGenericBase::DoGetBestSize() const
	259	{
	260	wxSize sizeBtn = m_spinButton->GetBestSize(),
	261	sizeText = m_textCtrl->GetBestSize();
	262
	263	return wxSize(sizeBtn.x + sizeText.x + MARGIN, sizeText.y);
	264	}
	265
	266	void wxSpinCtrlGenericBase::DoMoveWindow(int x, int y, int width, int height)
	267	{
	268	wxControl::DoMoveWindow(x, y, width, height);
	269
	270	// position the subcontrols inside the client area
	271	wxSize sizeBtn = m_spinButton->GetSize();
	272
	273	wxCoord wText = width - sizeBtn.x;
	274	m_textCtrl->SetSize(x, y, wText, height);
	275	m_spinButton->SetSize(x + wText + MARGIN, y, wxDefaultCoord, height);
	276	}
	277
	278	// ----------------------------------------------------------------------------
	279	// operations forwarded to the subcontrols
	280	// ----------------------------------------------------------------------------
	281
	282	bool wxSpinCtrlGenericBase::Enable(bool enable)
	283	{
	284	if ( !wxControl::Enable(enable) )
	285	return false;
	286
	287	m_spinButton->Enable(enable);
	288	m_textCtrl->Enable(enable);
	289
	290	return true;
	291	}
	292
	293	bool wxSpinCtrlGenericBase::Show(bool show)
	294	{
	295	if ( !wxControl::Show(show) )
	296	return false;
	297
	298	// under GTK Show() is called the first time before we are fully
	299	// constructed
	300	if ( m_spinButton )
	301	{
	302	m_spinButton->Show(show);
	303	m_textCtrl->Show(show);
	304	}
	305
	306	return true;
	307	}
	308
	309	bool wxSpinCtrlGenericBase::Reparent(wxWindowBase *newParent)
	310	{
	311	if ( m_spinButton )
	312	{
	313	m_spinButton->Reparent(newParent);
	314	m_textCtrl->Reparent(newParent);
	315	}
	316
	317	return true;
	318	}
	319
	320	// ----------------------------------------------------------------------------
	321	// Handle sub controls events
	322	// ----------------------------------------------------------------------------
	323
	324	void wxSpinCtrlGenericBase::OnSpinButton(wxSpinEvent& event)
	325	{
	326	event.Skip();
	327
	328	// Sync the textctrl since the user expects that the button will modify
	329	// what they see in the textctrl.
	330	if ( m_textCtrl && m_textCtrl->IsModified() )
	331	SyncSpinToText();
	332
	333	int spin_value = event.GetPosition();
	334	double step = (event.GetEventType() == wxEVT_SCROLL_LINEUP) ? 1 : -1;
	335
	336	// Use the spinbutton's acceleration, if any, but not if wrapping around
	337	if (((spin_value >= 0) && (m_spin_value >= 0)) \|\| ((spin_value <= 0) && (m_spin_value <= 0)))
	338	step *= abs(spin_value - m_spin_value);
	339
	340	double value = m_value + step*m_increment;
	341
	342	// we can always reach the ends using the spinbutton
	343	if (value < m_min) value = m_min;
	344	if (value > m_max) value = m_max;
	345
	346	// Ignore the edges when it wraps since the up/down event may be opposite
	347	// They are in GTK and Mac
	348	if (abs(spin_value - m_spin_value) > SPINCTRLBUT_MAX)
	349	{
	350	m_spin_value = spin_value;
	351	return;
	352	}
	353
	354	m_spin_value = spin_value;
	355
	356	if (InRange(value) && DoSetValue(value))
	357	DoSendEvent();
	358	}
	359
	360	void wxSpinCtrlGenericBase::OnTextEnter(wxCommandEvent& event)
	361	{
	362	SyncSpinToText();
	363	DoSendEvent();
	364	event.Skip();
	365	}
	366
	367	void wxSpinCtrlGenericBase::OnTextChar(wxKeyEvent& event)
	368	{
	369	double value = m_value;
	370	switch ( event.GetKeyCode() )
	371	{
	372	case WXK_UP :
	373	value += m_increment;
	374	break;
	375
	376	case WXK_DOWN :
	377	value -= m_increment;
	378	break;
	379
	380	case WXK_PAGEUP :
	381	value += m_increment * 10.0;
	382	break;
	383
	384	case WXK_PAGEDOWN :
	385	value -= m_increment * 10.0;
	386	break;
	387
	388	default:
	389	event.Skip();
	390	return;
	391	}
	392
	393	if ( m_textCtrl && m_textCtrl->IsModified() )
	394	SyncSpinToText();
	395
	396	if ( DoSetValue(value) )
	397	DoSendEvent();
	398	}
	399
	400	// ----------------------------------------------------------------------------
	401	// Textctrl functions
	402	// ----------------------------------------------------------------------------
	403
	404	void wxSpinCtrlGenericBase::SyncSpinToText()
	405	{
	406	if (!m_textCtrl)
	407	return;
	408
	409	double textValue;
	410	if ( m_textCtrl->GetValue().ToDouble(&textValue) )
	411	{
	412	if (textValue > m_max)
	413	textValue = m_max;
	414	else if (textValue < m_min)
	415	textValue = m_min;
	416
	417	if (m_value != textValue)
	418	{
	419	DoSetValue(textValue);
	420	}
	421	}
	422	else
	423	{
	424	// textctrl is out of sync, discard and reset
	425	DoSetValue(m_value);
	426	}
	427	}
	428
	429	// ----------------------------------------------------------------------------
	430	// changing value and range
	431	// ----------------------------------------------------------------------------
	432
	433	void wxSpinCtrlGenericBase::SetValue(const wxString& text)
	434	{
	435	wxCHECK_RET( m_textCtrl, _T("invalid call to wxSpinCtrl::SetValue") );
	436
	437	double val;
	438	if ( text.ToDouble(&val) && InRange(val) )
	439	{
	440	DoSetValue(val);
	441	}
	442	else // not a number at all or out of range
	443	{
	444	m_textCtrl->SetValue(text);
	445	m_textCtrl->SetSelection(0, -1);
	446	}
	447	}
	448
	449	bool wxSpinCtrlGenericBase::DoSetValue(double val)
	450	{
	451	wxCHECK_MSG( m_textCtrl, false, _T("invalid call to wxSpinCtrl::SetValue") );
	452
	453	if (!InRange(val))
	454	return false;
	455
	456	if ( m_snap_to_ticks && (m_increment != 0) )
	457	{
	458	double snap_value = val / m_increment;
	459
	460	if (wxFinite(snap_value)) // FIXME what to do about a failure?
	461	{
	462	if ((snap_value - floor(snap_value)) < (ceil(snap_value) - snap_value))
	463	val = floor(snap_value) * m_increment;
	464	else
	465	val = ceil(snap_value) * m_increment;
	466	}
	467	}
	468
	469	wxString str(wxString::Format(m_format.c_str(), val));
	470
	471	if ((val != m_value) \|\| (str != m_textCtrl->GetValue()))
	472	{
	473	m_value = val;
	474	str.ToDouble( &m_value ); // wysiwyg for textctrl
	475	m_textCtrl->SetValue( str );
	476	m_textCtrl->DiscardEdits();
	477	return true;
	478	}
	479
	480	return false;
	481	}
	482
	483	void wxSpinCtrlGenericBase::DoSetRange(double min, double max)
	484	{
	485	m_min = min;
	486	m_max = max;
	487	}
	488
	489	void wxSpinCtrlGenericBase::DoSetIncrement(double inc)
	490	{
	491	m_increment = inc;
	492	}
	493
	494	void wxSpinCtrlGenericBase::SetSnapToTicks(bool snap_to_ticks)
	495	{
	496	m_snap_to_ticks = snap_to_ticks;
	497	DoSetValue(m_value);
	498	}
	499
	500	void wxSpinCtrlGenericBase::SetSelection(long from, long to)
	501	{
	502	wxCHECK_RET( m_textCtrl, _T("invalid call to wxSpinCtrl::SetSelection") );
	503
	504	m_textCtrl->SetSelection(from, to);
	505	}
	506
	507	#ifndef wxHAS_NATIVE_SPINCTRL
	508
	509	//-----------------------------------------------------------------------------
	510	// wxSpinCtrl
	511	//-----------------------------------------------------------------------------
	512
	513	IMPLEMENT_DYNAMIC_CLASS(wxSpinCtrl, wxSpinCtrlGenericBase)
	514
	515	void wxSpinCtrl::DoSendEvent()
	516	{
	517	wxSpinEvent event( wxEVT_COMMAND_SPINCTRL_UPDATED, GetId());
	518	event.SetEventObject( this );
	519	event.SetPosition((int)(m_value + 0.5)); // FIXME should be SetValue
	520	event.SetString(m_textCtrl->GetValue());
	521	GetEventHandler()->ProcessEvent( event );
	522	}
	523
	524	#endif // !wxHAS_NATIVE_SPINCTRL
	525
	526	//-----------------------------------------------------------------------------
	527	// wxSpinCtrlDouble
	528	//-----------------------------------------------------------------------------
	529
	530	IMPLEMENT_DYNAMIC_CLASS(wxSpinCtrlDouble, wxSpinCtrlGenericBase)
	531
	532	void wxSpinCtrlDouble::DoSendEvent()
	533	{
	534	wxSpinDoubleEvent event( wxEVT_COMMAND_SPINCTRLDOUBLE_UPDATED, GetId());
	535	event.SetEventObject( this );
	536	event.SetValue(m_value);
	537	event.SetString(m_textCtrl->GetValue());
	538	GetEventHandler()->ProcessEvent( event );
	539	}
	540
	541	void wxSpinCtrlDouble::SetDigits(unsigned digits)
	542	{
	543	wxCHECK_RET( digits <= 20, "too many digits for wxSpinCtrlDouble" );
	544
	545	m_format.Printf(wxT("%%0.%ulf"), digits);
	546
	547	DoSetValue(m_value);
	548	}
	549
	550	#endif // wxUSE_SPINBTN
	551
	552	#endif // !wxPort-with-native-spinctrl
	553
	554	#endif // wxUSE_SPINCTRL