src/generic/spinctlg.cpp

   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 // Licence:     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, long style=0)
  62         : wxTextCtrl(spin->GetParent(), wxID_ANY, value, wxDefaultPosition, wxDefaultSize,
  63                      ( style & wxALIGN_MASK ) | 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             if ( 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                             (style & ~wxBORDER_MASK) | wxBORDER_NONE,
 190                             wxDefaultValidator, name) )
 191     {
 192         return false;
 193     }
 194
 195     m_value = initial;
 196     m_min   = min;
 197     m_max   = max;
 198     m_increment = increment;
 199
 200     m_textCtrl   = new wxSpinCtrlTextGeneric(this, value, style);
 201     m_spinButton = new wxSpinCtrlButtonGeneric(this, style);
 202
 203     m_spin_value = m_spinButton->GetValue();
 204
 205     // the string value overrides the numeric one (for backwards compatibility
 206     // reasons and also because it is simpler to satisfy the string value which
 207     // comes much sooner in the list of arguments and leave the initial
 208     // parameter unspecified)
 209     if ( !value.empty() )
 210     {
 211         double d;
 212         if ( value.ToDouble(&d) )
 213         {
 214             m_value = d;
 215             m_textCtrl->SetValue(wxString::Format(m_format, m_value));
 216         }
 217     }
 218
 219     SetInitialSize(size);
 220     Move(pos);
 221
 222     // have to disable this window to avoid interfering it with message
 223     // processing to the text and the button... but pretend it is enabled to
 224     // make IsEnabled() return true
 225     wxControl::Enable(false); // don't use non virtual Disable() here!
 226     m_isEnabled = true;
 227
 228     // we don't even need to show this window itself - and not doing it avoids
 229     // that it overwrites the text control
 230     wxControl::Show(false);
 231     m_isShown = true;
 232     return true;
 233 }
 234
 235 wxSpinCtrlGenericBase::~wxSpinCtrlGenericBase()
 236 {
 237     // delete the controls now, don't leave them alive even though they would
 238     // still be eventually deleted by our parent - but it will be too late, the
 239     // user code expects them to be gone now
 240
 241     if (m_textCtrl)
 242     {
 243         // null this since MSW sends KILL_FOCUS on deletion, see ~wxSpinCtrlTextGeneric
 244         wxDynamicCast(m_textCtrl, wxSpinCtrlTextGeneric)->m_spin = NULL;
 245
 246         wxSpinCtrlTextGeneric *text = (wxSpinCtrlTextGeneric*)m_textCtrl;
 247         m_textCtrl = NULL;
 248         delete text;
 249     }
 250
 251     wxDELETE(m_spinButton);
 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 void wxSpinCtrlGenericBase::SetFocus()
 283 {
 284     if ( m_textCtrl )
 285         m_textCtrl->SetFocus();
 286 }
 287
 288 bool wxSpinCtrlGenericBase::Enable(bool enable)
 289 {
 290     // Notice that we never enable this control itself, it must stay disabled
 291     // to avoid interfering with the siblings event handling (see e.g. #12045
 292     // for the kind of problems which arise otherwise).
 293     if ( enable == m_isEnabled )
 294         return false;
 295
 296     m_isEnabled = enable;
 297
 298     m_spinButton->Enable(enable);
 299     m_textCtrl->Enable(enable);
 300
 301     return true;
 302 }
 303
 304 bool wxSpinCtrlGenericBase::Show(bool show)
 305 {
 306     if ( !wxControl::Show(show) )
 307         return false;
 308
 309     // under GTK Show() is called the first time before we are fully
 310     // constructed
 311     if ( m_spinButton )
 312     {
 313         m_spinButton->Show(show);
 314         m_textCtrl->Show(show);
 315     }
 316
 317     return true;
 318 }
 319
 320 bool wxSpinCtrlGenericBase::Reparent(wxWindowBase *newParent)
 321 {
 322     if ( m_spinButton )
 323     {
 324         m_spinButton->Reparent(newParent);
 325         m_textCtrl->Reparent(newParent);
 326     }
 327
 328     return true;
 329 }
 330
 331 // ----------------------------------------------------------------------------
 332 // Handle sub controls events
 333 // ----------------------------------------------------------------------------
 334
 335 void wxSpinCtrlGenericBase::OnSpinButton(wxSpinEvent& event)
 336 {
 337     event.Skip();
 338
 339     // Sync the textctrl since the user expects that the button will modify
 340     // what they see in the textctrl.
 341     SyncSpinToText();
 342
 343     int spin_value = event.GetPosition();
 344     double step = (event.GetEventType() == wxEVT_SCROLL_LINEUP) ? 1 : -1;
 345
 346     // Use the spinbutton's acceleration, if any, but not if wrapping around
 347     if (((spin_value >= 0) && (m_spin_value >= 0)) || ((spin_value <= 0) && (m_spin_value <= 0)))
 348         step *= abs(spin_value - m_spin_value);
 349
 350     double value = AdjustToFitInRange(m_value + step*m_increment);
 351
 352     // Ignore the edges when it wraps since the up/down event may be opposite
 353     // They are in GTK and Mac
 354     if (abs(spin_value - m_spin_value) > SPINCTRLBUT_MAX)
 355     {
 356         m_spin_value = spin_value;
 357         return;
 358     }
 359
 360     m_spin_value = spin_value;
 361
 362     if ( DoSetValue(value) )
 363         DoSendEvent();
 364 }
 365
 366 void wxSpinCtrlGenericBase::OnTextEnter(wxCommandEvent& event)
 367 {
 368     SyncSpinToText();
 369     DoSendEvent();
 370     event.Skip();
 371 }
 372
 373 void wxSpinCtrlGenericBase::OnTextChar(wxKeyEvent& event)
 374 {
 375     if ( !HasFlag(wxSP_ARROW_KEYS) )
 376     {
 377         event.Skip();
 378         return;
 379     }
 380
 381     double value = m_value;
 382     switch ( event.GetKeyCode() )
 383     {
 384         case WXK_UP :
 385             value += m_increment;
 386             break;
 387
 388         case WXK_DOWN :
 389             value -= m_increment;
 390             break;
 391
 392         case WXK_PAGEUP :
 393             value += m_increment * 10.0;
 394             break;
 395
 396         case WXK_PAGEDOWN :
 397             value -= m_increment * 10.0;
 398             break;
 399
 400         default:
 401             event.Skip();
 402             return;
 403     }
 404
 405     value = AdjustToFitInRange(value);
 406
 407     SyncSpinToText();
 408
 409     if ( DoSetValue(value) )
 410         DoSendEvent();
 411 }
 412
 413 // ----------------------------------------------------------------------------
 414 // Textctrl functions
 415 // ----------------------------------------------------------------------------
 416
 417 bool wxSpinCtrlGenericBase::SyncSpinToText()
 418 {
 419     if ( !m_textCtrl || !m_textCtrl->IsModified() )
 420         return false;
 421
 422     double textValue;
 423     if ( m_textCtrl->GetValue().ToDouble(&textValue) )
 424     {
 425         if (textValue > m_max)
 426             textValue = m_max;
 427         else if (textValue < m_min)
 428             textValue = m_min;
 429     }
 430     else // text contents is not a valid number at all
 431     {
 432         // replace its contents with the last valid value
 433         textValue = m_value;
 434     }
 435
 436     // we must always set the value here, even if it's equal to m_value, as
 437     // otherwise we could be left with an out of range value when leaving the
 438     // text control and the current value is already m_max for example
 439     return DoSetValue(textValue);
 440 }
 441
 442 // ----------------------------------------------------------------------------
 443 // changing value and range
 444 // ----------------------------------------------------------------------------
 445
 446 void wxSpinCtrlGenericBase::SetValue(const wxString& text)
 447 {
 448     wxCHECK_RET( m_textCtrl, wxT("invalid call to wxSpinCtrl::SetValue") );
 449
 450     double val;
 451     if ( text.ToDouble(&val) && InRange(val) )
 452     {
 453         DoSetValue(val);
 454     }
 455     else // not a number at all or out of range
 456     {
 457         m_textCtrl->SetValue(text);
 458         m_textCtrl->SetSelection(0, -1);
 459         m_textCtrl->SetInsertionPointEnd();
 460     }
 461 }
 462
 463 bool wxSpinCtrlGenericBase::DoSetValue(double val)
 464 {
 465     wxCHECK_MSG( m_textCtrl, false, wxT("invalid call to wxSpinCtrl::SetValue") );
 466
 467     if (!InRange(val))
 468         return false;
 469
 470     if ( m_snap_to_ticks && (m_increment != 0) )
 471     {
 472         double snap_value = val / m_increment;
 473
 474         if (wxFinite(snap_value)) // FIXME what to do about a failure?
 475         {
 476             if ((snap_value - floor(snap_value)) < (ceil(snap_value) - snap_value))
 477                 val = floor(snap_value) * m_increment;
 478             else
 479                 val = ceil(snap_value) * m_increment;
 480         }
 481     }
 482
 483     wxString str(wxString::Format(m_format.c_str(), val));
 484
 485     if ((val != m_value) || (str != m_textCtrl->GetValue()))
 486     {
 487         m_value = val;
 488         str.ToDouble( &m_value );    // wysiwyg for textctrl
 489         m_textCtrl->SetValue( str );
 490         m_textCtrl->SetInsertionPointEnd();
 491         m_textCtrl->DiscardEdits();
 492         return true;
 493     }
 494
 495     return false;
 496 }
 497
 498 double wxSpinCtrlGenericBase::AdjustToFitInRange(double value) const
 499 {
 500     if (value < m_min)
 501         value = HasFlag(wxSP_WRAP) ? m_max : m_min;
 502     if (value > m_max)
 503         value = HasFlag(wxSP_WRAP) ? m_min : m_max;
 504
 505     return value;
 506 }
 507
 508 void wxSpinCtrlGenericBase::DoSetRange(double min, double max)
 509 {
 510     m_min = min;
 511     m_max = max;
 512 }
 513
 514 void wxSpinCtrlGenericBase::DoSetIncrement(double inc)
 515 {
 516     m_increment = inc;
 517 }
 518
 519 void wxSpinCtrlGenericBase::SetSnapToTicks(bool snap_to_ticks)
 520 {
 521     m_snap_to_ticks = snap_to_ticks;
 522     DoSetValue(m_value);
 523 }
 524
 525 void wxSpinCtrlGenericBase::SetSelection(long from, long to)
 526 {
 527     wxCHECK_RET( m_textCtrl, wxT("invalid call to wxSpinCtrl::SetSelection") );
 528
 529     m_textCtrl->SetSelection(from, to);
 530 }
 531
 532 #ifndef wxHAS_NATIVE_SPINCTRL
 533
 534 //-----------------------------------------------------------------------------
 535 // wxSpinCtrl
 536 //-----------------------------------------------------------------------------
 537
 538 IMPLEMENT_DYNAMIC_CLASS(wxSpinCtrl, wxSpinCtrlGenericBase)
 539
 540 void wxSpinCtrl::DoSendEvent()
 541 {
 542     wxSpinEvent event( wxEVT_COMMAND_SPINCTRL_UPDATED, GetId());
 543     event.SetEventObject( this );
 544     event.SetPosition((int)(m_value + 0.5)); // FIXME should be SetValue
 545     event.SetString(m_textCtrl->GetValue());
 546     GetEventHandler()->ProcessEvent( event );
 547 }
 548
 549 #endif // !wxHAS_NATIVE_SPINCTRL
 550
 551 //-----------------------------------------------------------------------------
 552 // wxSpinCtrlDouble
 553 //-----------------------------------------------------------------------------
 554
 555 IMPLEMENT_DYNAMIC_CLASS(wxSpinCtrlDouble, wxSpinCtrlGenericBase)
 556
 557 void wxSpinCtrlDouble::DoSendEvent()
 558 {
 559     wxSpinDoubleEvent event( wxEVT_COMMAND_SPINCTRLDOUBLE_UPDATED, GetId());
 560     event.SetEventObject( this );
 561     event.SetValue(m_value);
 562     event.SetString(m_textCtrl->GetValue());
 563     GetEventHandler()->ProcessEvent( event );
 564 }
 565
 566 void wxSpinCtrlDouble::SetDigits(unsigned digits)
 567 {
 568     wxCHECK_RET( digits <= 20, "too many digits for wxSpinCtrlDouble" );
 569
 570     if ( digits == m_digits )
 571         return;
 572
 573     m_digits = digits;
 574
 575     m_format.Printf(wxT("%%0.%ulf"), digits);
 576
 577     DoSetValue(m_value);
 578 }
 579
 580 #endif // wxUSE_SPINBTN
 581
 582 #endif // !wxPort-with-native-spinctrl
 583
 584 #endif // wxUSE_SPINCTRL