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