]>
Commit | Line | Data |
---|---|---|
21709999 JS |
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> | |
65571936 | 9 | // License: wxWindows licence |
21709999 JS |
10 | /////////////////////////////////////////////////////////////////////////////// |
11 | ||
12 | // ============================================================================ | |
13 | // declarations | |
14 | // ============================================================================ | |
15 | ||
16 | // ---------------------------------------------------------------------------- | |
17 | // headers | |
18 | // ---------------------------------------------------------------------------- | |
19 | ||
21709999 JS |
20 | // For compilers that support precompilation, includes "wx.h". |
21 | #include "wx/wxprec.h" | |
22 | ||
23 | #ifdef __BORLANDC__ | |
24 | #pragma hdrstop | |
25 | #endif | |
26 | ||
21709999 JS |
27 | #ifndef WX_PRECOMP |
28 | #include "wx/textctrl.h" | |
29 | #endif //WX_PRECOMP | |
30 | ||
8cd6a9ad VZ |
31 | #include "wx/spinctrl.h" |
32 | ||
c67d6888 JS |
33 | #if wxUSE_SPINCTRL |
34 | ||
8cd6a9ad VZ |
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 | ||
21709999 | 41 | #include "wx/spinbutt.h" |
8cd6a9ad VZ |
42 | |
43 | #if wxUSE_SPINBTN | |
21709999 JS |
44 | |
45 | // ---------------------------------------------------------------------------- | |
46 | // constants | |
47 | // ---------------------------------------------------------------------------- | |
48 | ||
49 | // the margin between the text control and the spin | |
50 | static const wxCoord MARGIN = 2; | |
51 | ||
8cd6a9ad VZ |
52 | #define SPINCTRLBUT_MAX 32000 // large to avoid wrap around trouble |
53 | ||
21709999 | 54 | // ---------------------------------------------------------------------------- |
405f0fef | 55 | // wxSpinCtrlTextGeneric: text control used by spin control |
21709999 JS |
56 | // ---------------------------------------------------------------------------- |
57 | ||
405f0fef | 58 | class wxSpinCtrlTextGeneric : public wxTextCtrl |
21709999 JS |
59 | { |
60 | public: | |
405f0fef | 61 | wxSpinCtrlTextGeneric(wxSpinCtrlGenericBase *spin, const wxString& value) |
8cd6a9ad VZ |
62 | : wxTextCtrl(spin->GetParent(), wxID_ANY, value, wxDefaultPosition, |
63 | wxDefaultSize, wxTE_NOHIDESEL|wxTE_PROCESS_ENTER) | |
21709999 JS |
64 | { |
65 | m_spin = spin; | |
ca65c044 | 66 | |
e459a794 | 67 | // remove the default minsize, the spinctrl will have one instead |
8cd6a9ad | 68 | SetSizeHints(wxDefaultCoord, wxDefaultCoord); |
21709999 JS |
69 | } |
70 | ||
405f0fef | 71 | virtual ~wxSpinCtrlTextGeneric() |
21709999 | 72 | { |
8cd6a9ad VZ |
73 | // MSW sends extra kill focus event on destroy |
74 | if (m_spin) | |
75 | m_spin->m_textCtrl = NULL; | |
21709999 | 76 | |
8cd6a9ad | 77 | m_spin = NULL; |
21709999 | 78 | } |
71e03035 | 79 | |
8cd6a9ad | 80 | void OnTextEnter(wxCommandEvent& event) |
23d416bf | 81 | { |
8cd6a9ad VZ |
82 | if (m_spin) |
83 | m_spin->OnTextEnter(event); | |
84 | } | |
71e03035 | 85 | |
8cd6a9ad VZ |
86 | void OnChar( wxKeyEvent &event ) |
87 | { | |
88 | if (m_spin) | |
89 | m_spin->OnTextChar(event); | |
23d416bf | 90 | } |
21709999 | 91 | |
8cd6a9ad VZ |
92 | void OnKillFocus(wxFocusEvent& event) |
93 | { | |
94 | if (m_spin) | |
95 | { | |
96 | m_spin->SyncSpinToText(); | |
97 | m_spin->DoSendEvent(); | |
98 | } | |
99 | ||
100 | event.Skip(); | |
101 | } | |
21709999 | 102 | |
8cd6a9ad VZ |
103 | wxSpinCtrlGenericBase *m_spin; |
104 | ||
105 | private: | |
21709999 JS |
106 | DECLARE_EVENT_TABLE() |
107 | }; | |
108 | ||
405f0fef VZ |
109 | BEGIN_EVENT_TABLE(wxSpinCtrlTextGeneric, wxTextCtrl) |
110 | EVT_TEXT_ENTER(wxID_ANY, wxSpinCtrlTextGeneric::OnTextEnter) | |
8cd6a9ad | 111 | |
405f0fef | 112 | EVT_CHAR(wxSpinCtrlTextGeneric::OnChar) |
8cd6a9ad | 113 | |
405f0fef | 114 | EVT_KILL_FOCUS(wxSpinCtrlTextGeneric::OnKillFocus) |
21709999 JS |
115 | END_EVENT_TABLE() |
116 | ||
117 | // ---------------------------------------------------------------------------- | |
405f0fef | 118 | // wxSpinCtrlButtonGeneric: spin button used by spin control |
21709999 JS |
119 | // ---------------------------------------------------------------------------- |
120 | ||
405f0fef | 121 | class wxSpinCtrlButtonGeneric : public wxSpinButton |
21709999 JS |
122 | { |
123 | public: | |
405f0fef | 124 | wxSpinCtrlButtonGeneric(wxSpinCtrlGenericBase *spin, int style) |
8cd6a9ad VZ |
125 | : wxSpinButton(spin->GetParent(), wxID_ANY, wxDefaultPosition, |
126 | wxDefaultSize, style | wxSP_VERTICAL) | |
21709999 JS |
127 | { |
128 | m_spin = spin; | |
129 | ||
8cd6a9ad | 130 | SetRange(-SPINCTRLBUT_MAX, SPINCTRLBUT_MAX); |
e459a794 RD |
131 | |
132 | // remove the default minsize, the spinctrl will have one instead | |
8cd6a9ad | 133 | SetSizeHints(wxDefaultCoord, wxDefaultCoord); |
21709999 JS |
134 | } |
135 | ||
8cd6a9ad | 136 | void OnSpinButton(wxSpinEvent& event) |
21709999 | 137 | { |
8cd6a9ad VZ |
138 | if (m_spin) |
139 | m_spin->OnSpinButton(event); | |
21709999 JS |
140 | } |
141 | ||
8cd6a9ad | 142 | wxSpinCtrlGenericBase *m_spin; |
21709999 | 143 | |
8cd6a9ad | 144 | private: |
21709999 JS |
145 | DECLARE_EVENT_TABLE() |
146 | }; | |
147 | ||
405f0fef VZ |
148 | BEGIN_EVENT_TABLE(wxSpinCtrlButtonGeneric, wxSpinButton) |
149 | EVT_SPIN_UP( wxID_ANY, wxSpinCtrlButtonGeneric::OnSpinButton) | |
150 | EVT_SPIN_DOWN(wxID_ANY, wxSpinCtrlButtonGeneric::OnSpinButton) | |
21709999 JS |
151 | END_EVENT_TABLE() |
152 | ||
21709999 | 153 | // ============================================================================ |
8cd6a9ad | 154 | // wxSpinCtrlGenericBase |
21709999 JS |
155 | // ============================================================================ |
156 | ||
157 | // ---------------------------------------------------------------------------- | |
8cd6a9ad | 158 | // wxSpinCtrlGenericBase creation |
21709999 JS |
159 | // ---------------------------------------------------------------------------- |
160 | ||
8cd6a9ad | 161 | void wxSpinCtrlGenericBase::Init() |
21709999 | 162 | { |
8cd6a9ad VZ |
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; | |
21709999 JS |
174 | } |
175 | ||
8cd6a9ad VZ |
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) | |
21709999 | 184 | { |
8cd6a9ad VZ |
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, | |
18e45a88 VZ |
189 | (style & ~wxBORDER_MASK) | wxBORDER_NONE, |
190 | wxDefaultValidator, name) ) | |
21709999 | 191 | { |
3fb79396 | 192 | return false; |
21709999 JS |
193 | } |
194 | ||
8cd6a9ad VZ |
195 | m_value = initial; |
196 | m_min = min; | |
197 | m_max = max; | |
198 | m_increment = increment; | |
199 | ||
405f0fef VZ |
200 | m_textCtrl = new wxSpinCtrlTextGeneric(this, value); |
201 | m_spinButton = new wxSpinCtrlButtonGeneric(this, style); | |
8cd6a9ad VZ |
202 | |
203 | m_spin_value = m_spinButton->GetValue(); | |
204 | ||
71e03035 VZ |
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 | { | |
8cd6a9ad VZ |
211 | double d; |
212 | if ( value.ToDouble(&d) ) | |
213 | { | |
214 | m_value = d; | |
215 | m_textCtrl->SetValue(wxString::Format(m_format, m_value)); | |
216 | } | |
71e03035 VZ |
217 | } |
218 | ||
170acdc9 | 219 | SetInitialSize(size); |
9cb6c9a0 | 220 | Move(pos); |
ca65c044 | 221 | |
21709999 JS |
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 | |
3fb79396 WS |
224 | // make IsEnabled() return true |
225 | wxControl::Enable(false); // don't use non virtual Disable() here! | |
226 | m_isEnabled = true; | |
21709999 JS |
227 | |
228 | // we don't even need to show this window itself - and not doing it avoids | |
229 | // that it overwrites the text control | |
3fb79396 WS |
230 | wxControl::Show(false); |
231 | m_isShown = true; | |
232 | return true; | |
21709999 JS |
233 | } |
234 | ||
8cd6a9ad | 235 | wxSpinCtrlGenericBase::~wxSpinCtrlGenericBase() |
21709999 | 236 | { |
e459a794 | 237 | // delete the controls now, don't leave them alive even though they would |
21709999 JS |
238 | // still be eventually deleted by our parent - but it will be too late, the |
239 | // user code expects them to be gone now | |
8cd6a9ad VZ |
240 | |
241 | if (m_textCtrl) | |
242 | { | |
405f0fef VZ |
243 | // null this since MSW sends KILL_FOCUS on deletion, see ~wxSpinCtrlTextGeneric |
244 | wxDynamicCast(m_textCtrl, wxSpinCtrlTextGeneric)->m_spin = NULL; | |
8cd6a9ad | 245 | |
405f0fef | 246 | wxSpinCtrlTextGeneric *text = (wxSpinCtrlTextGeneric*)m_textCtrl; |
8cd6a9ad VZ |
247 | m_textCtrl = NULL; |
248 | delete text; | |
249 | } | |
250 | ||
251 | delete m_spinButton; | |
252 | m_spinButton = NULL; | |
21709999 JS |
253 | } |
254 | ||
255 | // ---------------------------------------------------------------------------- | |
256 | // geometry | |
257 | // ---------------------------------------------------------------------------- | |
258 | ||
8cd6a9ad | 259 | wxSize wxSpinCtrlGenericBase::DoGetBestSize() const |
21709999 | 260 | { |
8cd6a9ad VZ |
261 | wxSize sizeBtn = m_spinButton->GetBestSize(), |
262 | sizeText = m_textCtrl->GetBestSize(); | |
21709999 JS |
263 | |
264 | return wxSize(sizeBtn.x + sizeText.x + MARGIN, sizeText.y); | |
265 | } | |
266 | ||
8cd6a9ad | 267 | void wxSpinCtrlGenericBase::DoMoveWindow(int x, int y, int width, int height) |
21709999 JS |
268 | { |
269 | wxControl::DoMoveWindow(x, y, width, height); | |
270 | ||
271 | // position the subcontrols inside the client area | |
8cd6a9ad | 272 | wxSize sizeBtn = m_spinButton->GetSize(); |
21709999 JS |
273 | |
274 | wxCoord wText = width - sizeBtn.x; | |
8cd6a9ad VZ |
275 | m_textCtrl->SetSize(x, y, wText, height); |
276 | m_spinButton->SetSize(x + wText + MARGIN, y, wxDefaultCoord, height); | |
21709999 JS |
277 | } |
278 | ||
279 | // ---------------------------------------------------------------------------- | |
280 | // operations forwarded to the subcontrols | |
281 | // ---------------------------------------------------------------------------- | |
282 | ||
8cd6a9ad | 283 | bool wxSpinCtrlGenericBase::Enable(bool enable) |
21709999 JS |
284 | { |
285 | if ( !wxControl::Enable(enable) ) | |
3fb79396 | 286 | return false; |
21709999 | 287 | |
8cd6a9ad VZ |
288 | m_spinButton->Enable(enable); |
289 | m_textCtrl->Enable(enable); | |
21709999 | 290 | |
3fb79396 | 291 | return true; |
21709999 JS |
292 | } |
293 | ||
8cd6a9ad | 294 | bool wxSpinCtrlGenericBase::Show(bool show) |
21709999 JS |
295 | { |
296 | if ( !wxControl::Show(show) ) | |
3fb79396 | 297 | return false; |
21709999 | 298 | |
3379ed37 VZ |
299 | // under GTK Show() is called the first time before we are fully |
300 | // constructed | |
8cd6a9ad | 301 | if ( m_spinButton ) |
3379ed37 | 302 | { |
8cd6a9ad VZ |
303 | m_spinButton->Show(show); |
304 | m_textCtrl->Show(show); | |
3379ed37 | 305 | } |
21709999 | 306 | |
3fb79396 | 307 | return true; |
21709999 JS |
308 | } |
309 | ||
7f0cbaaa | 310 | bool wxSpinCtrlGenericBase::Reparent(wxWindowBase *newParent) |
03d4194d | 311 | { |
8cd6a9ad | 312 | if ( m_spinButton ) |
03d4194d | 313 | { |
8cd6a9ad VZ |
314 | m_spinButton->Reparent(newParent); |
315 | m_textCtrl->Reparent(newParent); | |
03d4194d VZ |
316 | } |
317 | ||
318 | return true; | |
319 | } | |
320 | ||
21709999 | 321 | // ---------------------------------------------------------------------------- |
8cd6a9ad | 322 | // Handle sub controls events |
21709999 JS |
323 | // ---------------------------------------------------------------------------- |
324 | ||
8cd6a9ad | 325 | void wxSpinCtrlGenericBase::OnSpinButton(wxSpinEvent& event) |
21709999 | 326 | { |
8cd6a9ad VZ |
327 | event.Skip(); |
328 | ||
329 | // Sync the textctrl since the user expects that the button will modify | |
330 | // what they see in the textctrl. | |
331 | if ( m_textCtrl && m_textCtrl->IsModified() ) | |
332 | SyncSpinToText(); | |
333 | ||
334 | int spin_value = event.GetPosition(); | |
335 | double step = (event.GetEventType() == wxEVT_SCROLL_LINEUP) ? 1 : -1; | |
336 | ||
337 | // Use the spinbutton's acceleration, if any, but not if wrapping around | |
338 | if (((spin_value >= 0) && (m_spin_value >= 0)) || ((spin_value <= 0) && (m_spin_value <= 0))) | |
339 | step *= abs(spin_value - m_spin_value); | |
21709999 | 340 | |
70c14728 | 341 | double value = AdjustToFitInRange(m_value + step*m_increment); |
8cd6a9ad VZ |
342 | |
343 | // Ignore the edges when it wraps since the up/down event may be opposite | |
344 | // They are in GTK and Mac | |
345 | if (abs(spin_value - m_spin_value) > SPINCTRLBUT_MAX) | |
21709999 | 346 | { |
8cd6a9ad VZ |
347 | m_spin_value = spin_value; |
348 | return; | |
21709999 JS |
349 | } |
350 | ||
8cd6a9ad | 351 | m_spin_value = spin_value; |
21709999 | 352 | |
70c14728 | 353 | if ( DoSetValue(value) ) |
8cd6a9ad | 354 | DoSendEvent(); |
21709999 JS |
355 | } |
356 | ||
8cd6a9ad | 357 | void wxSpinCtrlGenericBase::OnTextEnter(wxCommandEvent& event) |
21709999 | 358 | { |
8cd6a9ad VZ |
359 | SyncSpinToText(); |
360 | DoSendEvent(); | |
361 | event.Skip(); | |
21709999 JS |
362 | } |
363 | ||
8cd6a9ad | 364 | void wxSpinCtrlGenericBase::OnTextChar(wxKeyEvent& event) |
21709999 | 365 | { |
fd07e185 VZ |
366 | if ( !HasFlag(wxSP_ARROW_KEYS) ) |
367 | { | |
368 | event.Skip(); | |
369 | return; | |
370 | } | |
371 | ||
8cd6a9ad VZ |
372 | double value = m_value; |
373 | switch ( event.GetKeyCode() ) | |
374 | { | |
375 | case WXK_UP : | |
376 | value += m_increment; | |
377 | break; | |
378 | ||
379 | case WXK_DOWN : | |
380 | value -= m_increment; | |
381 | break; | |
382 | ||
383 | case WXK_PAGEUP : | |
384 | value += m_increment * 10.0; | |
385 | break; | |
386 | ||
387 | case WXK_PAGEDOWN : | |
388 | value -= m_increment * 10.0; | |
389 | break; | |
390 | ||
391 | default: | |
392 | event.Skip(); | |
393 | return; | |
394 | } | |
395 | ||
70c14728 VZ |
396 | value = AdjustToFitInRange(value); |
397 | ||
8cd6a9ad VZ |
398 | if ( m_textCtrl && m_textCtrl->IsModified() ) |
399 | SyncSpinToText(); | |
400 | ||
401 | if ( DoSetValue(value) ) | |
402 | DoSendEvent(); | |
21709999 JS |
403 | } |
404 | ||
8cd6a9ad VZ |
405 | // ---------------------------------------------------------------------------- |
406 | // Textctrl functions | |
407 | // ---------------------------------------------------------------------------- | |
408 | ||
409 | void wxSpinCtrlGenericBase::SyncSpinToText() | |
21709999 | 410 | { |
8cd6a9ad VZ |
411 | if (!m_textCtrl) |
412 | return; | |
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 | if (m_value != textValue) | |
423 | { | |
424 | DoSetValue(textValue); | |
425 | } | |
426 | } | |
427 | else | |
428 | { | |
429 | // textctrl is out of sync, discard and reset | |
430 | DoSetValue(m_value); | |
431 | } | |
21709999 JS |
432 | } |
433 | ||
434 | // ---------------------------------------------------------------------------- | |
435 | // changing value and range | |
436 | // ---------------------------------------------------------------------------- | |
437 | ||
8cd6a9ad VZ |
438 | void wxSpinCtrlGenericBase::SetValue(const wxString& text) |
439 | { | |
440 | wxCHECK_RET( m_textCtrl, _T("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 | } | |
452 | } | |
453 | ||
454 | bool wxSpinCtrlGenericBase::DoSetValue(double val) | |
21709999 | 455 | { |
8cd6a9ad | 456 | wxCHECK_MSG( m_textCtrl, false, _T("invalid call to wxSpinCtrl::SetValue") ); |
21709999 | 457 | |
8cd6a9ad VZ |
458 | if (!InRange(val)) |
459 | return false; | |
21709999 | 460 | |
8cd6a9ad VZ |
461 | if ( m_snap_to_ticks && (m_increment != 0) ) |
462 | { | |
463 | double snap_value = val / m_increment; | |
21709999 | 464 | |
8cd6a9ad VZ |
465 | if (wxFinite(snap_value)) // FIXME what to do about a failure? |
466 | { | |
467 | if ((snap_value - floor(snap_value)) < (ceil(snap_value) - snap_value)) | |
468 | val = floor(snap_value) * m_increment; | |
469 | else | |
470 | val = ceil(snap_value) * m_increment; | |
471 | } | |
472 | } | |
473 | ||
474 | wxString str(wxString::Format(m_format.c_str(), val)); | |
475 | ||
476 | if ((val != m_value) || (str != m_textCtrl->GetValue())) | |
477 | { | |
478 | m_value = val; | |
479 | str.ToDouble( &m_value ); // wysiwyg for textctrl | |
480 | m_textCtrl->SetValue( str ); | |
481 | m_textCtrl->DiscardEdits(); | |
482 | return true; | |
483 | } | |
484 | ||
485 | return false; | |
21709999 JS |
486 | } |
487 | ||
70c14728 VZ |
488 | double wxSpinCtrlGenericBase::AdjustToFitInRange(double value) const |
489 | { | |
490 | if (value < m_min) | |
491 | value = HasFlag(wxSP_WRAP) ? m_max : m_min; | |
492 | if (value > m_max) | |
493 | value = HasFlag(wxSP_WRAP) ? m_min : m_max; | |
494 | ||
495 | return value; | |
496 | } | |
497 | ||
8cd6a9ad | 498 | void wxSpinCtrlGenericBase::DoSetRange(double min, double max) |
21709999 | 499 | { |
8cd6a9ad VZ |
500 | m_min = min; |
501 | m_max = max; | |
502 | } | |
21709999 | 503 | |
8cd6a9ad VZ |
504 | void wxSpinCtrlGenericBase::DoSetIncrement(double inc) |
505 | { | |
506 | m_increment = inc; | |
507 | } | |
21709999 | 508 | |
8cd6a9ad VZ |
509 | void wxSpinCtrlGenericBase::SetSnapToTicks(bool snap_to_ticks) |
510 | { | |
511 | m_snap_to_ticks = snap_to_ticks; | |
512 | DoSetValue(m_value); | |
21709999 JS |
513 | } |
514 | ||
8cd6a9ad | 515 | void wxSpinCtrlGenericBase::SetSelection(long from, long to) |
21709999 | 516 | { |
8cd6a9ad | 517 | wxCHECK_RET( m_textCtrl, _T("invalid call to wxSpinCtrl::SetSelection") ); |
21709999 | 518 | |
8cd6a9ad | 519 | m_textCtrl->SetSelection(from, to); |
21709999 JS |
520 | } |
521 | ||
8cd6a9ad VZ |
522 | #ifndef wxHAS_NATIVE_SPINCTRL |
523 | ||
524 | //----------------------------------------------------------------------------- | |
525 | // wxSpinCtrl | |
526 | //----------------------------------------------------------------------------- | |
527 | ||
528 | IMPLEMENT_DYNAMIC_CLASS(wxSpinCtrl, wxSpinCtrlGenericBase) | |
529 | ||
530 | void wxSpinCtrl::DoSendEvent() | |
21709999 | 531 | { |
8cd6a9ad VZ |
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 | //----------------------------------------------------------------------------- | |
21709999 | 544 | |
8cd6a9ad VZ |
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 ); | |
21709999 JS |
554 | } |
555 | ||
8cd6a9ad | 556 | void wxSpinCtrlDouble::SetDigits(unsigned digits) |
739555e3 | 557 | { |
8cd6a9ad | 558 | wxCHECK_RET( digits <= 20, "too many digits for wxSpinCtrlDouble" ); |
739555e3 | 559 | |
8cd6a9ad VZ |
560 | m_format.Printf(wxT("%%0.%ulf"), digits); |
561 | ||
562 | DoSetValue(m_value); | |
739555e3 VZ |
563 | } |
564 | ||
8cd6a9ad VZ |
565 | #endif // wxUSE_SPINBTN |
566 | ||
3379ed37 | 567 | #endif // !wxPort-with-native-spinctrl |
8cd6a9ad VZ |
568 | |
569 | #endif // wxUSE_SPINCTRL |