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