]>
Commit | Line | Data |
---|---|---|
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 | // License: 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) | |
62 | : wxTextCtrl(spin->GetParent(), wxID_ANY, value, wxDefaultPosition, | |
63 | wxDefaultSize, 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 | 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); | |
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 | delete m_spinButton; | |
252 | m_spinButton = NULL; | |
253 | } | |
254 | ||
255 | // ---------------------------------------------------------------------------- | |
256 | // geometry | |
257 | // ---------------------------------------------------------------------------- | |
258 | ||
259 | wxSize wxSpinCtrlGenericBase::DoGetBestSize() const | |
260 | { | |
261 | wxSize sizeBtn = m_spinButton->GetBestSize(), | |
262 | sizeText = m_textCtrl->GetBestSize(); | |
263 | ||
264 | return wxSize(sizeBtn.x + sizeText.x + MARGIN, sizeText.y); | |
265 | } | |
266 | ||
267 | void wxSpinCtrlGenericBase::DoMoveWindow(int x, int y, int width, int height) | |
268 | { | |
269 | wxControl::DoMoveWindow(x, y, width, height); | |
270 | ||
271 | // position the subcontrols inside the client area | |
272 | wxSize sizeBtn = m_spinButton->GetSize(); | |
273 | ||
274 | wxCoord wText = width - sizeBtn.x; | |
275 | m_textCtrl->SetSize(x, y, wText, height); | |
276 | m_spinButton->SetSize(x + wText + MARGIN, y, wxDefaultCoord, height); | |
277 | } | |
278 | ||
279 | // ---------------------------------------------------------------------------- | |
280 | // operations forwarded to the subcontrols | |
281 | // ---------------------------------------------------------------------------- | |
282 | ||
283 | bool wxSpinCtrlGenericBase::Enable(bool enable) | |
284 | { | |
285 | if ( !wxControl::Enable(enable) ) | |
286 | return false; | |
287 | ||
288 | m_spinButton->Enable(enable); | |
289 | m_textCtrl->Enable(enable); | |
290 | ||
291 | return true; | |
292 | } | |
293 | ||
294 | bool wxSpinCtrlGenericBase::Show(bool show) | |
295 | { | |
296 | if ( !wxControl::Show(show) ) | |
297 | return false; | |
298 | ||
299 | // under GTK Show() is called the first time before we are fully | |
300 | // constructed | |
301 | if ( m_spinButton ) | |
302 | { | |
303 | m_spinButton->Show(show); | |
304 | m_textCtrl->Show(show); | |
305 | } | |
306 | ||
307 | return true; | |
308 | } | |
309 | ||
310 | bool wxSpinCtrlGenericBase::Reparent(wxWindowBase *newParent) | |
311 | { | |
312 | if ( m_spinButton ) | |
313 | { | |
314 | m_spinButton->Reparent(newParent); | |
315 | m_textCtrl->Reparent(newParent); | |
316 | } | |
317 | ||
318 | return true; | |
319 | } | |
320 | ||
321 | // ---------------------------------------------------------------------------- | |
322 | // Handle sub controls events | |
323 | // ---------------------------------------------------------------------------- | |
324 | ||
325 | void wxSpinCtrlGenericBase::OnSpinButton(wxSpinEvent& event) | |
326 | { | |
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); | |
340 | ||
341 | double value = AdjustToFitInRange(m_value + step*m_increment); | |
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) | |
346 | { | |
347 | m_spin_value = spin_value; | |
348 | return; | |
349 | } | |
350 | ||
351 | m_spin_value = spin_value; | |
352 | ||
353 | if ( DoSetValue(value) ) | |
354 | DoSendEvent(); | |
355 | } | |
356 | ||
357 | void wxSpinCtrlGenericBase::OnTextEnter(wxCommandEvent& event) | |
358 | { | |
359 | SyncSpinToText(); | |
360 | DoSendEvent(); | |
361 | event.Skip(); | |
362 | } | |
363 | ||
364 | void wxSpinCtrlGenericBase::OnTextChar(wxKeyEvent& event) | |
365 | { | |
366 | if ( !HasFlag(wxSP_ARROW_KEYS) ) | |
367 | { | |
368 | event.Skip(); | |
369 | return; | |
370 | } | |
371 | ||
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 | ||
396 | value = AdjustToFitInRange(value); | |
397 | ||
398 | if ( m_textCtrl && m_textCtrl->IsModified() ) | |
399 | SyncSpinToText(); | |
400 | ||
401 | if ( DoSetValue(value) ) | |
402 | DoSendEvent(); | |
403 | } | |
404 | ||
405 | // ---------------------------------------------------------------------------- | |
406 | // Textctrl functions | |
407 | // ---------------------------------------------------------------------------- | |
408 | ||
409 | void wxSpinCtrlGenericBase::SyncSpinToText() | |
410 | { | |
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 | } | |
432 | } | |
433 | ||
434 | // ---------------------------------------------------------------------------- | |
435 | // changing value and range | |
436 | // ---------------------------------------------------------------------------- | |
437 | ||
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) | |
455 | { | |
456 | wxCHECK_MSG( m_textCtrl, false, _T("invalid call to wxSpinCtrl::SetValue") ); | |
457 | ||
458 | if (!InRange(val)) | |
459 | return false; | |
460 | ||
461 | if ( m_snap_to_ticks && (m_increment != 0) ) | |
462 | { | |
463 | double snap_value = val / m_increment; | |
464 | ||
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; | |
486 | } | |
487 | ||
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 | ||
498 | void wxSpinCtrlGenericBase::DoSetRange(double min, double max) | |
499 | { | |
500 | m_min = min; | |
501 | m_max = max; | |
502 | } | |
503 | ||
504 | void wxSpinCtrlGenericBase::DoSetIncrement(double inc) | |
505 | { | |
506 | m_increment = inc; | |
507 | } | |
508 | ||
509 | void wxSpinCtrlGenericBase::SetSnapToTicks(bool snap_to_ticks) | |
510 | { | |
511 | m_snap_to_ticks = snap_to_ticks; | |
512 | DoSetValue(m_value); | |
513 | } | |
514 | ||
515 | void wxSpinCtrlGenericBase::SetSelection(long from, long to) | |
516 | { | |
517 | wxCHECK_RET( m_textCtrl, _T("invalid call to wxSpinCtrl::SetSelection") ); | |
518 | ||
519 | m_textCtrl->SetSelection(from, to); | |
520 | } | |
521 | ||
522 | #ifndef wxHAS_NATIVE_SPINCTRL | |
523 | ||
524 | //----------------------------------------------------------------------------- | |
525 | // wxSpinCtrl | |
526 | //----------------------------------------------------------------------------- | |
527 | ||
528 | IMPLEMENT_DYNAMIC_CLASS(wxSpinCtrl, wxSpinCtrlGenericBase) | |
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 | m_format.Printf(wxT("%%0.%ulf"), digits); | |
561 | ||
562 | DoSetValue(m_value); | |
563 | } | |
564 | ||
565 | #endif // wxUSE_SPINBTN | |
566 | ||
567 | #endif // !wxPort-with-native-spinctrl | |
568 | ||
569 | #endif // wxUSE_SPINCTRL |