Fix harmless unused parameter warning in !wxUSE_GRAPHICS_CONTEXT build.

[wxWidgets.git] / src / generic / spinctlg.cpp

diff --git a/src/generic/spinctlg.cpp b/src/generic/spinctlg.cpp
index d872780e9c59fe8e29b3235f40a01ce29f4c27b9..90d087da873d24c7424f918c13edbea39f213431 100644 (file)
--- a/src/generic/spinctlg.cpp
+++ b/src/generic/spinctlg.cpp
@@ -29,6 +29,7 @@
 #endif //WX_PRECOMP
 
 #include "wx/spinctrl.h"
 #endif //WX_PRECOMP
 
 #include "wx/spinctrl.h"

+#include "wx/tooltip.h"

 
 #if wxUSE_SPINCTRL
 
 
 #if wxUSE_SPINCTRL
 


@@ -46,8 +47,12 @@ IMPLEMENT_DYNAMIC_CLASS(wxSpinDoubleEvent, wxNotifyEvent)
 // constants
 // ----------------------------------------------------------------------------
 
 // 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
 
 
 #define SPINCTRLBUT_MAX 32000 // large to avoid wrap around trouble
 


@@ -59,8 +64,12 @@ class wxSpinCtrlTextGeneric : public wxTextCtrl
 {
 public:
     wxSpinCtrlTextGeneric(wxSpinCtrlGenericBase *spin, const wxString& value, long style=0)
 {
 public:
     wxSpinCtrlTextGeneric(wxSpinCtrlGenericBase *spin, const wxString& value, long style=0)

-        : wxTextCtrl(spin->GetParent(), wxID_ANY, value, wxDefaultPosition, wxDefaultSize,
-                     ( style & wxALIGN_MASK ) | wxTE_NOHIDESEL | wxTE_PROCESS_ENTER)
+        : 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 = spin;
 


@@ -77,25 +86,24 @@ public:
         m_spin = NULL;
     }
 
         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)
     }
 
     void OnKillFocus(wxFocusEvent& event)
     {
         if (m_spin)

-        {
-            if ( m_spin->SyncSpinToText() )
-                m_spin->DoSendEvent();
-        }
+            m_spin->ProcessWindowEvent(event);

 
         event.Skip();
     }
 
         event.Skip();
     }


@@ -107,10 +115,17 @@ private:
 };
 
 BEGIN_EVENT_TABLE(wxSpinCtrlTextGeneric, wxTextCtrl)
 };
 
 BEGIN_EVENT_TABLE(wxSpinCtrlTextGeneric, wxTextCtrl)

-    EVT_TEXT_ENTER(wxID_ANY, wxSpinCtrlTextGeneric::OnTextEnter)
-

     EVT_CHAR(wxSpinCtrlTextGeneric::OnChar)
 
     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()
 
     EVT_KILL_FOCUS(wxSpinCtrlTextGeneric::OnKillFocus)
 END_EVENT_TABLE()
 


@@ -122,7 +137,7 @@ class wxSpinCtrlButtonGeneric : public wxSpinButton
 {
 public:
     wxSpinCtrlButtonGeneric(wxSpinCtrlGenericBase *spin, int style)
 {
 public:
     wxSpinCtrlButtonGeneric(wxSpinCtrlGenericBase *spin, int style)

-        : wxSpinButton(spin->GetParent(), wxID_ANY, wxDefaultPosition,
+        : wxSpinButton(spin, wxID_ANY, wxDefaultPosition,

                        wxDefaultSize, style | wxSP_VERTICAL)
     {
         m_spin = spin;
                        wxDefaultSize, style | wxSP_VERTICAL)
     {
         m_spin = spin;


@@ -165,7 +180,6 @@ void wxSpinCtrlGenericBase::Init()
     m_max           = 100;
     m_increment     = 1;
     m_snap_to_ticks = false;
     m_max           = 100;
     m_increment     = 1;
     m_snap_to_ticks = false;

-    m_format        = wxS("%g");

 
     m_spin_value    = 0;
 
 
     m_spin_value    = 0;
 


@@ -200,6 +214,11 @@ bool wxSpinCtrlGenericBase::Create(wxWindow *parent,
     m_textCtrl   = new wxSpinCtrlTextGeneric(this, value, style);
     m_spinButton = new wxSpinCtrlButtonGeneric(this, style);
 
     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
     m_spin_value = m_spinButton->GetValue();
 
     // the string value overrides the numeric one (for backwards compatibility


@@ -209,26 +228,16 @@ bool wxSpinCtrlGenericBase::Create(wxWindow *parent,
     if ( !value.empty() )
     {
         double d;
     if ( !value.empty() )
     {
         double d;

-        if ( value.ToDouble(&d) )
+        if ( DoTextToValue(value, &d) )

         {
             m_value = d;
         {
             m_value = d;

-            m_textCtrl->SetValue(wxString::Format(m_format, m_value));
+            m_textCtrl->SetValue(DoValueToText(m_value));

         }
     }
 
     SetInitialSize(size);
     Move(pos);
 
         }
     }
 
     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;
 }
 
     return true;
 }
 


@@ -251,16 +260,40 @@ wxSpinCtrlGenericBase::~wxSpinCtrlGenericBase()
     wxDELETE(m_spinButton);
 }
 
     wxDELETE(m_spinButton);
 }
 

+wxWindowList wxSpinCtrlGenericBase::GetCompositeWindowParts() const
+{
+    wxWindowList parts;
+    parts.push_back(m_textCtrl);
+    parts.push_back(m_spinButton);
+    return parts;
+}
+

 // ----------------------------------------------------------------------------
 // geometry
 // ----------------------------------------------------------------------------
 
 wxSize wxSpinCtrlGenericBase::DoGetBestSize() const
 {
 // ----------------------------------------------------------------------------
 // geometry
 // ----------------------------------------------------------------------------
 
 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(4*totalS.y/10 + 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)
 }
 
 void wxSpinCtrlGenericBase::DoMoveWindow(int x, int y, int width, int height)


@@ -270,25 +303,35 @@ void wxSpinCtrlGenericBase::DoMoveWindow(int x, int y, int width, int height)
     // position the subcontrols inside the client area
     wxSize sizeBtn = m_spinButton->GetSize();
 
     // 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
 // ----------------------------------------------------------------------------
 
 }
 
 // ----------------------------------------------------------------------------
 // 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)
 {
 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 )
+    if ( !wxSpinCtrlBase::Enable(enable) )

         return false;
 
         return false;
 

-    m_isEnabled = enable;
-

     m_spinButton->Enable(enable);
     m_textCtrl->Enable(enable);
 
     m_spinButton->Enable(enable);
     m_textCtrl->Enable(enable);
 


@@ -311,14 +354,41 @@ bool wxSpinCtrlGenericBase::Show(bool show)
     return true;
 }
 
     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 )
     {
     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;
 }
 
     return true;
 }
 


@@ -326,6 +396,11 @@ bool wxSpinCtrlGenericBase::Reparent(wxWindowBase *newParent)
 // Handle sub controls events
 // ----------------------------------------------------------------------------
 
 // 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();
 void wxSpinCtrlGenericBase::OnSpinButton(wxSpinEvent& event)
 {
     event.Skip();


@@ -357,10 +432,11 @@ void wxSpinCtrlGenericBase::OnSpinButton(wxSpinEvent& event)
         DoSendEvent();
 }
 
         DoSendEvent();
 }
 

-void wxSpinCtrlGenericBase::OnTextEnter(wxCommandEvent& event)
+void wxSpinCtrlGenericBase::OnTextLostFocus(wxFocusEvent& event)

 {
     SyncSpinToText();
     DoSendEvent();
 {
     SyncSpinToText();
     DoSendEvent();

+

     event.Skip();
 }
 
     event.Skip();
 }
 


@@ -414,7 +490,7 @@ bool wxSpinCtrlGenericBase::SyncSpinToText()
         return false;
 
     double textValue;
         return false;
 
     double textValue;

-    if ( m_textCtrl->GetValue().ToDouble(&textValue) )
+    if ( DoTextToValue(m_textCtrl->GetValue(), &textValue) )

     {
         if (textValue > m_max)
             textValue = m_max;
     {
         if (textValue > m_max)
             textValue = m_max;


@@ -442,15 +518,14 @@ void wxSpinCtrlGenericBase::SetValue(const wxString& text)
     wxCHECK_RET( m_textCtrl, wxT("invalid call to wxSpinCtrl::SetValue") );
 
     double val;
     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);
     {
         DoSetValue(val);
     }
     else // not a number at all or out of range
     {
         m_textCtrl->SetValue(text);

-        m_textCtrl->SetSelection(0, -1);
-        m_textCtrl->SetInsertionPointEnd();
+        m_textCtrl->SelectAll();

     }
 }
 
     }
 }
 


@@ -458,9 +533,11 @@ bool wxSpinCtrlGenericBase::DoSetValue(double val)
 {
     wxCHECK_MSG( m_textCtrl, false, wxT("invalid call to wxSpinCtrl::SetValue") );
 
 {
     wxCHECK_MSG( m_textCtrl, false, wxT("invalid call to wxSpinCtrl::SetValue") );
 

-    if (!InRange(val))
-        return false;
-
+    if ( val < m_min )
+        val = m_min;
+    if ( val > m_max )
+        val = m_max;
+    

     if ( m_snap_to_ticks && (m_increment != 0) )
     {
         double snap_value = val / m_increment;
     if ( m_snap_to_ticks && (m_increment != 0) )
     {
         double snap_value = val / m_increment;


@@ -474,14 +551,14 @@ bool wxSpinCtrlGenericBase::DoSetValue(double val)
         }
     }
 
         }
     }
 

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

 
     if ((val != m_value) || (str != m_textCtrl->GetValue()))
     {
 
     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->SetValue( str );

-        m_textCtrl->SetInsertionPointEnd();
+        m_textCtrl->SelectAll();

         m_textCtrl->DiscardEdits();
         return true;
     }
         m_textCtrl->DiscardEdits();
         return true;
     }


@@ -502,7 +579,11 @@ double wxSpinCtrlGenericBase::AdjustToFitInRange(double value) const
 void wxSpinCtrlGenericBase::DoSetRange(double min, double max)
 {
     m_min = min;
 void wxSpinCtrlGenericBase::DoSetRange(double min, double max)
 {
     m_min = min;

+    if ( m_value < m_min )
+        DoSetValue(m_min);

     m_max = max;
     m_max = max;

+    if ( m_value > m_max )
+        DoSetValue(m_max);

 }
 
 void wxSpinCtrlGenericBase::DoSetIncrement(double inc)
 }
 
 void wxSpinCtrlGenericBase::DoSetIncrement(double inc)


@@ -529,17 +610,67 @@ void wxSpinCtrlGenericBase::SetSelection(long from, long to)
 // wxSpinCtrl
 //-----------------------------------------------------------------------------
 
 // 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()
 {
 
 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 );
 }
 
     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
 
 //-----------------------------------------------------------------------------
 #endif // !wxHAS_NATIVE_SPINCTRL
 
 //-----------------------------------------------------------------------------


@@ -550,13 +681,23 @@ IMPLEMENT_DYNAMIC_CLASS(wxSpinCtrlDouble, wxSpinCtrlGenericBase)
 
 void wxSpinCtrlDouble::DoSendEvent()
 {
 
 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 );
 }
 
     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" );
 void wxSpinCtrlDouble::SetDigits(unsigned digits)
 {
     wxCHECK_RET( digits <= 20, "too many digits for wxSpinCtrlDouble" );