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 #include "wx/tooltip.h"
  33
  34 #if wxUSE_SPINCTRL
  35
  36 IMPLEMENT_DYNAMIC_CLASS(wxSpinDoubleEvent, wxNotifyEvent)
  37
  38 // There are port-specific versions for the wxSpinCtrl, so exclude the
  39 // contents of this file in those cases
  40 #if !defined(wxHAS_NATIVE_SPINCTRL) || !defined(wxHAS_NATIVE_SPINCTRLDOUBLE)
  41
  42 #include "wx/spinbutt.h"
  43
  44 #if wxUSE_SPINBTN
  45
  46 // ----------------------------------------------------------------------------
  47 // constants
  48 // ----------------------------------------------------------------------------
  49
  50 // The margin between the text control and the spin: the value here is the same
  51 // as the margin between the spin button and its "buddy" text control in wxMSW
  52 // so the generic control looks similarly to the native one there, we might
  53 // need to use different value for the other platforms (and maybe even
  54 // determine it dynamically?).
  55 static const wxCoord MARGIN = 1;
  56
  57 #define SPINCTRLBUT_MAX 32000 // large to avoid wrap around trouble
  58
  59 // ----------------------------------------------------------------------------
  60 // wxSpinCtrlTextGeneric: text control used by spin control
  61 // ----------------------------------------------------------------------------
  62
  63 class wxSpinCtrlTextGeneric : public wxTextCtrl
  64 {
  65 public:
  66     wxSpinCtrlTextGeneric(wxSpinCtrlGenericBase *spin, const wxString& value, long style=0)
  67         : wxTextCtrl(spin->GetParent(), wxID_ANY, value, wxDefaultPosition, wxDefaultSize,
  68                      // This is tricky: we want to honour any alignment flags
  69                      // but not wxALIGN_CENTER_VERTICAL because it's the same
  70                      // as wxTE_PASSWORD and we definitely don't want to show
  71                      // asterisks in spin control.
  72                      style & (wxALIGN_MASK | wxTE_PROCESS_ENTER) & ~wxTE_PASSWORD)
  73     {
  74         m_spin = spin;
  75
  76         // remove the default minsize, the spinctrl will have one instead
  77         SetSizeHints(wxDefaultCoord, wxDefaultCoord);
  78     }
  79
  80     virtual ~wxSpinCtrlTextGeneric()
  81     {
  82         // MSW sends extra kill focus event on destroy
  83         if (m_spin)
  84             m_spin->m_textCtrl = NULL;
  85
  86         m_spin = NULL;
  87     }
  88
  89     void OnChar( wxKeyEvent &event )
  90     {
  91         if ( !m_spin->ProcessWindowEvent(event) )
  92             event.Skip();
  93     }
  94
  95     void OnTextEvent(wxCommandEvent& event)
  96     {
  97         wxCommandEvent eventCopy(event);
  98         eventCopy.SetEventObject(m_spin);
  99         eventCopy.SetId(m_spin->GetId());
 100         m_spin->ProcessWindowEvent(eventCopy);
 101     }
 102
 103     void OnKillFocus(wxFocusEvent& event)
 104     {
 105         if (m_spin)
 106             m_spin->ProcessWindowEvent(event);
 107
 108         event.Skip();
 109     }
 110
 111     wxSpinCtrlGenericBase *m_spin;
 112
 113 private:
 114     DECLARE_EVENT_TABLE()
 115 };
 116
 117 BEGIN_EVENT_TABLE(wxSpinCtrlTextGeneric, wxTextCtrl)
 118     EVT_CHAR(wxSpinCtrlTextGeneric::OnChar)
 119
 120     // Forward the text events to wxSpinCtrl itself adjusting them slightly in
 121     // the process.
 122     EVT_TEXT(wxID_ANY, wxSpinCtrlTextGeneric::OnTextEvent)
 123
 124     // And we need to forward this one too as wxSpinCtrl is supposed to
 125     // generate it if wxTE_PROCESS_ENTER is used with it (and if it isn't,
 126     // we're never going to get EVT_TEXT_ENTER in the first place).
 127     EVT_TEXT_ENTER(wxID_ANY, wxSpinCtrlTextGeneric::OnTextEvent)
 128
 129     EVT_KILL_FOCUS(wxSpinCtrlTextGeneric::OnKillFocus)
 130 END_EVENT_TABLE()
 131
 132 // ----------------------------------------------------------------------------
 133 // wxSpinCtrlButtonGeneric: spin button used by spin control
 134 // ----------------------------------------------------------------------------
 135
 136 class wxSpinCtrlButtonGeneric : public wxSpinButton
 137 {
 138 public:
 139     wxSpinCtrlButtonGeneric(wxSpinCtrlGenericBase *spin, int style)
 140         : wxSpinButton(spin->GetParent(), wxID_ANY, wxDefaultPosition,
 141                        wxDefaultSize, style | wxSP_VERTICAL)
 142     {
 143         m_spin = spin;
 144
 145         SetRange(-SPINCTRLBUT_MAX, SPINCTRLBUT_MAX);
 146
 147         // remove the default minsize, the spinctrl will have one instead
 148         SetSizeHints(wxDefaultCoord, wxDefaultCoord);
 149     }
 150
 151     void OnSpinButton(wxSpinEvent& event)
 152     {
 153         if (m_spin)
 154             m_spin->OnSpinButton(event);
 155     }
 156
 157     wxSpinCtrlGenericBase *m_spin;
 158
 159 private:
 160     DECLARE_EVENT_TABLE()
 161 };
 162
 163 BEGIN_EVENT_TABLE(wxSpinCtrlButtonGeneric, wxSpinButton)
 164     EVT_SPIN_UP(  wxID_ANY, wxSpinCtrlButtonGeneric::OnSpinButton)
 165     EVT_SPIN_DOWN(wxID_ANY, wxSpinCtrlButtonGeneric::OnSpinButton)
 166 END_EVENT_TABLE()
 167
 168 // ============================================================================
 169 // wxSpinCtrlGenericBase
 170 // ============================================================================
 171
 172 // ----------------------------------------------------------------------------
 173 // wxSpinCtrlGenericBase creation
 174 // ----------------------------------------------------------------------------
 175
 176 void wxSpinCtrlGenericBase::Init()
 177 {
 178     m_value         = 0;
 179     m_min           = 0;
 180     m_max           = 100;
 181     m_increment     = 1;
 182     m_snap_to_ticks = false;
 183
 184     m_spin_value    = 0;
 185
 186     m_textCtrl = NULL;
 187     m_spinButton  = NULL;
 188 }
 189
 190 bool wxSpinCtrlGenericBase::Create(wxWindow *parent,
 191                                    wxWindowID id,
 192                                    const wxString& value,
 193                                    const wxPoint& pos, const wxSize& size,
 194                                    long style,
 195                                    double min, double max, double initial,
 196                                    double increment,
 197                                    const wxString& name)
 198 {
 199     // don't use borders for this control itself, it wouldn't look good with
 200     // the text control borders (but we might want to use style border bits to
 201     // select the text control style)
 202     if ( !wxControl::Create(parent, id, wxDefaultPosition, wxDefaultSize,
 203                             (style & ~wxBORDER_MASK) | wxBORDER_NONE,
 204                             wxDefaultValidator, name) )
 205     {
 206         return false;
 207     }
 208
 209     m_value = initial;
 210     m_min   = min;
 211     m_max   = max;
 212     m_increment = increment;
 213
 214     m_textCtrl   = new wxSpinCtrlTextGeneric(this, value, style);
 215     m_spinButton = new wxSpinCtrlButtonGeneric(this, style);
 216 #if wxUSE_TOOLTIPS
 217     m_textCtrl->SetToolTip(GetToolTipText());
 218     m_spinButton->SetToolTip(GetToolTipText());
 219 #endif // wxUSE_TOOLTIPS
 220
 221     m_spin_value = m_spinButton->GetValue();
 222
 223     // the string value overrides the numeric one (for backwards compatibility
 224     // reasons and also because it is simpler to satisfy the string value which
 225     // comes much sooner in the list of arguments and leave the initial
 226     // parameter unspecified)
 227     if ( !value.empty() )
 228     {
 229         double d;
 230         if ( DoTextToValue(value, &d) )
 231         {
 232             m_value = d;
 233             m_textCtrl->SetValue(DoValueToText(m_value));
 234         }
 235     }
 236
 237     SetInitialSize(size);
 238     Move(pos);
 239
 240     // have to disable this window to avoid interfering it with message
 241     // processing to the text and the button... but pretend it is enabled to
 242     // make IsEnabled() return true
 243     wxControl::Enable(false); // don't use non virtual Disable() here!
 244     m_isEnabled = true;
 245
 246     // we don't even need to show this window itself - and not doing it avoids
 247     // that it overwrites the text control
 248     wxControl::Show(false);
 249     m_isShown = true;
 250     return true;
 251 }
 252
 253 wxSpinCtrlGenericBase::~wxSpinCtrlGenericBase()
 254 {
 255     // delete the controls now, don't leave them alive even though they would
 256     // still be eventually deleted by our parent - but it will be too late, the
 257     // user code expects them to be gone now
 258
 259     if (m_textCtrl)
 260     {
 261         // null this since MSW sends KILL_FOCUS on deletion, see ~wxSpinCtrlTextGeneric
 262         wxDynamicCast(m_textCtrl, wxSpinCtrlTextGeneric)->m_spin = NULL;
 263
 264         wxSpinCtrlTextGeneric *text = (wxSpinCtrlTextGeneric*)m_textCtrl;
 265         m_textCtrl = NULL;
 266         delete text;
 267     }
 268
 269     wxDELETE(m_spinButton);
 270 }
 271
 272 wxWindowList wxSpinCtrlGenericBase::GetCompositeWindowParts() const
 273 {
 274     wxWindowList parts;
 275     parts.push_back(m_textCtrl);
 276     parts.push_back(m_spinButton);
 277     return parts;
 278 }
 279
 280 // ----------------------------------------------------------------------------
 281 // geometry
 282 // ----------------------------------------------------------------------------
 283
 284 wxSize wxSpinCtrlGenericBase::DoGetBestSize() const
 285 {
 286     return DoGetSizeFromTextSize(m_textCtrl->GetBestSize().x, -1);
 287 }
 288
 289 wxSize wxSpinCtrlGenericBase::DoGetSizeFromTextSize(int xlen, int ylen) const
 290 {
 291     wxSize sizeBtn  = m_spinButton->GetBestSize();
 292     wxSize totalS( m_textCtrl->GetBestSize() );
 293
 294     wxSize tsize(xlen + sizeBtn.x + MARGIN, totalS.y);
 295 #if defined(__WXMSW__)
 296     tsize.IncBy(0.4 * totalS.y + 4, 0);
 297 #elif defined(__WXGTK__)
 298     tsize.IncBy(totalS.y + 10, 0);
 299 #endif // MSW GTK
 300
 301     // Check if the user requested a non-standard height.
 302     if ( ylen > 0 )
 303         tsize.IncBy(0, ylen - GetCharHeight());
 304
 305     return tsize;
 306 }
 307
 308 void wxSpinCtrlGenericBase::DoMoveWindow(int x, int y, int width, int height)
 309 {
 310     wxControl::DoMoveWindow(x, y, width, height);
 311
 312     // position the subcontrols inside the client area
 313     wxSize sizeBtn = m_spinButton->GetSize();
 314
 315     wxCoord wText = width - sizeBtn.x - MARGIN;
 316     m_textCtrl->SetSize(x, y, wText, height);
 317     m_spinButton->SetSize(x + wText + MARGIN, y, wxDefaultCoord, height);
 318 }
 319
 320 // ----------------------------------------------------------------------------
 321 // operations forwarded to the subcontrols
 322 // ----------------------------------------------------------------------------
 323
 324 void wxSpinCtrlGenericBase::SetFocus()
 325 {
 326     if ( m_textCtrl )
 327         m_textCtrl->SetFocus();
 328 }
 329
 330 #ifdef __WXMSW__
 331
 332 void wxSpinCtrlGenericBase::DoEnable(bool enable)
 333 {
 334     // We never enable this control itself, it must stay disabled to avoid
 335     // interfering with the siblings event handling (see e.g. #12045 for the
 336     // kind of problems which arise otherwise).
 337     if ( !enable )
 338         wxSpinCtrlBase::DoEnable(enable);
 339 }
 340
 341 #endif // __WXMSW__
 342
 343 bool wxSpinCtrlGenericBase::Enable(bool enable)
 344 {
 345     if ( !wxSpinCtrlBase::Enable(enable) )
 346         return false;
 347
 348     m_spinButton->Enable(enable);
 349     m_textCtrl->Enable(enable);
 350
 351     return true;
 352 }
 353
 354 bool wxSpinCtrlGenericBase::Show(bool show)
 355 {
 356     if ( !wxControl::Show(show) )
 357         return false;
 358
 359     // under GTK Show() is called the first time before we are fully
 360     // constructed
 361     if ( m_spinButton )
 362     {
 363         m_spinButton->Show(show);
 364         m_textCtrl->Show(show);
 365     }
 366
 367     return true;
 368 }
 369
 370 #if wxUSE_TOOLTIPS
 371 void wxSpinCtrlGenericBase::DoSetToolTip(wxToolTip *tip)
 372 {
 373     // Notice that we must check for the subcontrols not being NULL (as they
 374     // could be if we were created with the default ctor and this is called
 375     // before Create() for some reason) and that we can't call SetToolTip(tip)
 376     // because this would take ownership of the wxToolTip object (twice).
 377     if ( m_textCtrl )
 378     {
 379         if ( tip )
 380             m_textCtrl->SetToolTip(tip->GetTip());
 381         else
 382             m_textCtrl->SetToolTip(NULL);
 383     }
 384
 385     if ( m_spinButton )
 386     {
 387         if( tip )
 388             m_spinButton->SetToolTip(tip->GetTip());
 389         else
 390             m_spinButton->SetToolTip(NULL);
 391     }
 392
 393     wxWindowBase::DoSetToolTip(tip);
 394 }
 395 #endif // wxUSE_TOOLTIPS
 396
 397 // ----------------------------------------------------------------------------
 398 // Handle sub controls events
 399 // ----------------------------------------------------------------------------
 400
 401 BEGIN_EVENT_TABLE(wxSpinCtrlGenericBase, wxSpinCtrlBase)
 402     EVT_CHAR(wxSpinCtrlGenericBase::OnTextChar)
 403     EVT_KILL_FOCUS(wxSpinCtrlGenericBase::OnTextLostFocus)
 404 END_EVENT_TABLE()
 405
 406 void wxSpinCtrlGenericBase::OnSpinButton(wxSpinEvent& event)
 407 {
 408     event.Skip();
 409
 410     // Sync the textctrl since the user expects that the button will modify
 411     // what they see in the textctrl.
 412     SyncSpinToText();
 413
 414     int spin_value = event.GetPosition();
 415     double step = (event.GetEventType() == wxEVT_SCROLL_LINEUP) ? 1 : -1;
 416
 417     // Use the spinbutton's acceleration, if any, but not if wrapping around
 418     if (((spin_value >= 0) && (m_spin_value >= 0)) || ((spin_value <= 0) && (m_spin_value <= 0)))
 419         step *= abs(spin_value - m_spin_value);
 420
 421     double value = AdjustToFitInRange(m_value + step*m_increment);
 422
 423     // Ignore the edges when it wraps since the up/down event may be opposite
 424     // They are in GTK and Mac
 425     if (abs(spin_value - m_spin_value) > SPINCTRLBUT_MAX)
 426     {
 427         m_spin_value = spin_value;
 428         return;
 429     }
 430
 431     m_spin_value = spin_value;
 432
 433     if ( DoSetValue(value) )
 434         DoSendEvent();
 435 }
 436
 437 void wxSpinCtrlGenericBase::OnTextLostFocus(wxFocusEvent& event)
 438 {
 439     SyncSpinToText();
 440     DoSendEvent();
 441
 442     event.Skip();
 443 }
 444
 445 void wxSpinCtrlGenericBase::OnTextChar(wxKeyEvent& event)
 446 {
 447     if ( !HasFlag(wxSP_ARROW_KEYS) )
 448     {
 449         event.Skip();
 450         return;
 451     }
 452
 453     double value = m_value;
 454     switch ( event.GetKeyCode() )
 455     {
 456         case WXK_UP :
 457             value += m_increment;
 458             break;
 459
 460         case WXK_DOWN :
 461             value -= m_increment;
 462             break;
 463
 464         case WXK_PAGEUP :
 465             value += m_increment * 10.0;
 466             break;
 467
 468         case WXK_PAGEDOWN :
 469             value -= m_increment * 10.0;
 470             break;
 471
 472         default:
 473             event.Skip();
 474             return;
 475     }
 476
 477     value = AdjustToFitInRange(value);
 478
 479     SyncSpinToText();
 480
 481     if ( DoSetValue(value) )
 482         DoSendEvent();
 483 }
 484
 485 // ----------------------------------------------------------------------------
 486 // Textctrl functions
 487 // ----------------------------------------------------------------------------
 488
 489 bool wxSpinCtrlGenericBase::SyncSpinToText()
 490 {
 491     if ( !m_textCtrl || !m_textCtrl->IsModified() )
 492         return false;
 493
 494     double textValue;
 495     if ( DoTextToValue(m_textCtrl->GetValue(), &textValue) )
 496     {
 497         if (textValue > m_max)
 498             textValue = m_max;
 499         else if (textValue < m_min)
 500             textValue = m_min;
 501     }
 502     else // text contents is not a valid number at all
 503     {
 504         // replace its contents with the last valid value
 505         textValue = m_value;
 506     }
 507
 508     // we must always set the value here, even if it's equal to m_value, as
 509     // otherwise we could be left with an out of range value when leaving the
 510     // text control and the current value is already m_max for example
 511     return DoSetValue(textValue);
 512 }
 513
 514 // ----------------------------------------------------------------------------
 515 // changing value and range
 516 // ----------------------------------------------------------------------------
 517
 518 void wxSpinCtrlGenericBase::SetValue(const wxString& text)
 519 {
 520     wxCHECK_RET( m_textCtrl, wxT("invalid call to wxSpinCtrl::SetValue") );
 521
 522     double val;
 523     if ( DoTextToValue(text, &val) && InRange(val) )
 524     {
 525         DoSetValue(val);
 526     }
 527     else // not a number at all or out of range
 528     {
 529         m_textCtrl->SetValue(text);
 530         m_textCtrl->SelectAll();
 531     }
 532 }
 533
 534 bool wxSpinCtrlGenericBase::DoSetValue(double val)
 535 {
 536     wxCHECK_MSG( m_textCtrl, false, wxT("invalid call to wxSpinCtrl::SetValue") );
 537
 538     if (!InRange(val))
 539         return false;
 540
 541     if ( m_snap_to_ticks && (m_increment != 0) )
 542     {
 543         double snap_value = val / m_increment;
 544
 545         if (wxFinite(snap_value)) // FIXME what to do about a failure?
 546         {
 547             if ((snap_value - floor(snap_value)) < (ceil(snap_value) - snap_value))
 548                 val = floor(snap_value) * m_increment;
 549             else
 550                 val = ceil(snap_value) * m_increment;
 551         }
 552     }
 553
 554     wxString str(DoValueToText(val));
 555
 556     if ((val != m_value) || (str != m_textCtrl->GetValue()))
 557     {
 558         if ( !DoTextToValue(str, &m_value ) )    // wysiwyg for textctrl
 559             m_value = val;
 560         m_textCtrl->SetValue( str );
 561         m_textCtrl->SelectAll();
 562         m_textCtrl->DiscardEdits();
 563         return true;
 564     }
 565
 566     return false;
 567 }
 568
 569 double wxSpinCtrlGenericBase::AdjustToFitInRange(double value) const
 570 {
 571     if (value < m_min)
 572         value = HasFlag(wxSP_WRAP) ? m_max : m_min;
 573     if (value > m_max)
 574         value = HasFlag(wxSP_WRAP) ? m_min : m_max;
 575
 576     return value;
 577 }
 578
 579 void wxSpinCtrlGenericBase::DoSetRange(double min, double max)
 580 {
 581     m_min = min;
 582     m_max = max;
 583 }
 584
 585 void wxSpinCtrlGenericBase::DoSetIncrement(double inc)
 586 {
 587     m_increment = inc;
 588 }
 589
 590 void wxSpinCtrlGenericBase::SetSnapToTicks(bool snap_to_ticks)
 591 {
 592     m_snap_to_ticks = snap_to_ticks;
 593     DoSetValue(m_value);
 594 }
 595
 596 void wxSpinCtrlGenericBase::SetSelection(long from, long to)
 597 {
 598     wxCHECK_RET( m_textCtrl, wxT("invalid call to wxSpinCtrl::SetSelection") );
 599
 600     m_textCtrl->SetSelection(from, to);
 601 }
 602
 603 #ifndef wxHAS_NATIVE_SPINCTRL
 604
 605 //-----------------------------------------------------------------------------
 606 // wxSpinCtrl
 607 //-----------------------------------------------------------------------------
 608
 609 bool wxSpinCtrl::SetBase(int base)
 610 {
 611     // Currently we only support base 10 and 16. We could add support for base
 612     // 8 quite easily but wxMSW doesn't support it natively so don't bother.
 613     if ( base != 10 && base != 16 )
 614         return false;
 615
 616     if ( base == m_base )
 617         return true;
 618
 619     // Update the current control contents to show in the new base: be careful
 620     // to call DoTextToValue() before changing the base...
 621     double val;
 622     const bool hasValidVal = DoTextToValue(m_textCtrl->GetValue(), &val);
 623
 624     m_base = base;
 625
 626     // ... but DoValueToText() after doing it.
 627     if ( hasValidVal )
 628         m_textCtrl->SetValue(DoValueToText(val));
 629
 630     return true;
 631 }
 632
 633 void wxSpinCtrl::DoSendEvent()
 634 {
 635     wxSpinEvent event( wxEVT_COMMAND_SPINCTRL_UPDATED, GetId());
 636     event.SetEventObject( this );
 637     event.SetPosition((int)(m_value + 0.5)); // FIXME should be SetValue
 638     event.SetString(m_textCtrl->GetValue());
 639     GetEventHandler()->ProcessEvent( event );
 640 }
 641
 642 bool wxSpinCtrl::DoTextToValue(const wxString& text, double *val)
 643 {
 644     long lval;
 645     if ( !text.ToLong(&lval, GetBase()) )
 646         return false;
 647
 648     *val = static_cast<double>(lval);
 649
 650     return true;
 651 }
 652
 653 wxString wxSpinCtrl::DoValueToText(double val)
 654 {
 655     switch ( GetBase() )
 656     {
 657         case 16:
 658             return wxPrivate::wxSpinCtrlFormatAsHex(static_cast<long>(val),
 659                                                     GetMax());
 660
 661         default:
 662             wxFAIL_MSG( wxS("Unsupported spin control base") );
 663             // Fall through
 664
 665         case 10:
 666             return wxString::Format("%ld", static_cast<long>(val));
 667     }
 668 }
 669
 670 #endif // !wxHAS_NATIVE_SPINCTRL
 671
 672 //-----------------------------------------------------------------------------
 673 // wxSpinCtrlDouble
 674 //-----------------------------------------------------------------------------
 675
 676 IMPLEMENT_DYNAMIC_CLASS(wxSpinCtrlDouble, wxSpinCtrlGenericBase)
 677
 678 void wxSpinCtrlDouble::DoSendEvent()
 679 {
 680     wxSpinDoubleEvent event( wxEVT_COMMAND_SPINCTRLDOUBLE_UPDATED, GetId());
 681     event.SetEventObject( this );
 682     event.SetValue(m_value);
 683     event.SetString(m_textCtrl->GetValue());
 684     GetEventHandler()->ProcessEvent( event );
 685 }
 686
 687 bool wxSpinCtrlDouble::DoTextToValue(const wxString& text, double *val)
 688 {
 689     return text.ToDouble(val);
 690 }
 691
 692 wxString wxSpinCtrlDouble::DoValueToText(double val)
 693 {
 694     return wxString::Format(m_format, val);
 695 }
 696
 697 void wxSpinCtrlDouble::SetDigits(unsigned digits)
 698 {
 699     wxCHECK_RET( digits <= 20, "too many digits for wxSpinCtrlDouble" );
 700
 701     if ( digits == m_digits )
 702         return;
 703
 704     m_digits = digits;
 705
 706     m_format.Printf(wxT("%%0.%ulf"), digits);
 707
 708     DoSetValue(m_value);
 709 }
 710
 711 #endif // wxUSE_SPINBTN
 712
 713 #endif // !wxPort-with-native-spinctrl
 714
 715 #endif // wxUSE_SPINCTRL