]>
Commit | Line | Data |
---|---|---|
1 | ///////////////////////////////////////////////////////////////////////////// | |
2 | // Name: src/msw/slider.cpp | |
3 | // Purpose: wxSlider, using the Win95 (and later) trackbar control | |
4 | // Author: Julian Smart | |
5 | // Modified by: | |
6 | // Created: 04/01/98 | |
7 | // RCS-ID: $Id$ | |
8 | // Copyright: (c) Julian Smart 1998 | |
9 | // Vadim Zeitlin 2004 | |
10 | // Licence: wxWindows licence | |
11 | ///////////////////////////////////////////////////////////////////////////// | |
12 | ||
13 | // ============================================================================ | |
14 | // declarations | |
15 | // ============================================================================ | |
16 | ||
17 | // ---------------------------------------------------------------------------- | |
18 | // headers | |
19 | // ---------------------------------------------------------------------------- | |
20 | ||
21 | // For compilers that support precompilation, includes "wx.h". | |
22 | #include "wx/wxprec.h" | |
23 | ||
24 | #ifdef __BORLANDC__ | |
25 | #pragma hdrstop | |
26 | #endif | |
27 | ||
28 | #if wxUSE_SLIDER | |
29 | ||
30 | #include "wx/slider.h" | |
31 | ||
32 | #ifndef WX_PRECOMP | |
33 | #include "wx/msw/wrapcctl.h" // include <commctrl.h> "properly" | |
34 | #include "wx/brush.h" | |
35 | #endif | |
36 | ||
37 | #include "wx/msw/subwin.h" | |
38 | ||
39 | // ---------------------------------------------------------------------------- | |
40 | // constants | |
41 | // ---------------------------------------------------------------------------- | |
42 | ||
43 | namespace | |
44 | { | |
45 | ||
46 | // indices of labels in wxSlider::m_labels | |
47 | enum | |
48 | { | |
49 | SliderLabel_Min, | |
50 | SliderLabel_Max, | |
51 | SliderLabel_Value, | |
52 | SliderLabel_Last | |
53 | }; | |
54 | ||
55 | // the gaps between the slider and the labels, in pixels | |
56 | const int HGAP = 5; | |
57 | const int VGAP = 4; | |
58 | // the width of the borders including white space | |
59 | const int BORDERPAD = 8; | |
60 | // these 2 values are arbitrary: | |
61 | const int THUMB = 24; | |
62 | const int TICK = 8; | |
63 | ||
64 | } // anonymous namespace | |
65 | ||
66 | // ============================================================================ | |
67 | // wxSlider implementation | |
68 | // ============================================================================ | |
69 | ||
70 | // ---------------------------------------------------------------------------- | |
71 | // construction | |
72 | // ---------------------------------------------------------------------------- | |
73 | ||
74 | void wxSlider::Init() | |
75 | { | |
76 | m_labels = NULL; | |
77 | ||
78 | m_pageSize = 1; | |
79 | m_lineSize = 1; | |
80 | m_rangeMax = 0; | |
81 | m_rangeMin = 0; | |
82 | m_tickFreq = 0; | |
83 | ||
84 | m_isDragging = false; | |
85 | } | |
86 | ||
87 | bool wxSlider::Create(wxWindow *parent, | |
88 | wxWindowID id, | |
89 | int value, | |
90 | int minValue, | |
91 | int maxValue, | |
92 | const wxPoint& pos, | |
93 | const wxSize& size, | |
94 | long style, | |
95 | const wxValidator& validator, | |
96 | const wxString& name) | |
97 | { | |
98 | wxCHECK_MSG( minValue < maxValue, false, | |
99 | wxT("Slider minimum must be strictly less than the maximum.") ); | |
100 | ||
101 | // our styles are redundant: wxSL_LEFT/RIGHT imply wxSL_VERTICAL and | |
102 | // wxSL_TOP/BOTTOM imply wxSL_HORIZONTAL, but for backwards compatibility | |
103 | // reasons we can't really change it, instead try to infer the orientation | |
104 | // from the flags given to us here | |
105 | switch ( style & (wxSL_LEFT | wxSL_RIGHT | wxSL_TOP | wxSL_BOTTOM) ) | |
106 | { | |
107 | case wxSL_LEFT: | |
108 | case wxSL_RIGHT: | |
109 | style |= wxSL_VERTICAL; | |
110 | break; | |
111 | ||
112 | case wxSL_TOP: | |
113 | case wxSL_BOTTOM: | |
114 | style |= wxSL_HORIZONTAL; | |
115 | break; | |
116 | ||
117 | case 0: | |
118 | // no specific direction, do we have at least the orientation? | |
119 | if ( !(style & (wxSL_HORIZONTAL | wxSL_VERTICAL)) ) | |
120 | { | |
121 | // no, choose default | |
122 | style |= wxSL_BOTTOM | wxSL_HORIZONTAL; | |
123 | } | |
124 | }; | |
125 | ||
126 | wxASSERT_MSG( !(style & wxSL_VERTICAL) || !(style & wxSL_HORIZONTAL), | |
127 | wxT("incompatible slider direction and orientation") ); | |
128 | ||
129 | ||
130 | // initialize everything | |
131 | if ( !CreateControl(parent, id, pos, size, style, validator, name) ) | |
132 | return false; | |
133 | ||
134 | // ensure that we have correct values for GetLabelsSize() | |
135 | m_rangeMin = minValue; | |
136 | m_rangeMax = maxValue; | |
137 | ||
138 | // create the labels first, so that our DoGetBestSize() could take them | |
139 | // into account | |
140 | // | |
141 | // note that we could simply create 3 wxStaticTexts here but it could | |
142 | // result in some observable side effects at wx level (e.g. the parent of | |
143 | // wxSlider would have 3 more children than expected) and so we prefer not | |
144 | // to do it like this | |
145 | if ( m_windowStyle & wxSL_LABELS ) | |
146 | { | |
147 | m_labels = new wxSubwindows(SliderLabel_Last); | |
148 | ||
149 | HWND hwndParent = GetHwndOf(parent); | |
150 | for ( size_t n = 0; n < SliderLabel_Last; n++ ) | |
151 | { | |
152 | wxWindowIDRef lblid = NewControlId(); | |
153 | ||
154 | HWND wnd = ::CreateWindow | |
155 | ( | |
156 | wxT("STATIC"), | |
157 | NULL, | |
158 | WS_CHILD | WS_VISIBLE | SS_CENTER, | |
159 | 0, 0, 0, 0, | |
160 | hwndParent, | |
161 | (HMENU)wxUIntToPtr(lblid.GetValue()), | |
162 | wxGetInstance(), | |
163 | NULL | |
164 | ); | |
165 | ||
166 | m_labels->Set(n, wnd, lblid); | |
167 | } | |
168 | m_labels->SetFont(GetFont()); | |
169 | } | |
170 | ||
171 | // now create the main control too | |
172 | if ( !MSWCreateControl(TRACKBAR_CLASS, wxEmptyString, pos, size) ) | |
173 | return false; | |
174 | ||
175 | // and initialize everything | |
176 | SetRange(minValue, maxValue); | |
177 | SetValue(value); | |
178 | SetPageSize( wxMax(1, (maxValue - minValue)/10) ); | |
179 | ||
180 | // we need to position the labels correctly if we have them and if | |
181 | // SetSize() hadn't been called before (when best size was determined by | |
182 | // MSWCreateControl()) as in this case they haven't been put in place yet | |
183 | if ( m_labels && size.x != wxDefaultCoord && size.y != wxDefaultCoord ) | |
184 | { | |
185 | SetSize(size); | |
186 | } | |
187 | ||
188 | return true; | |
189 | } | |
190 | ||
191 | WXDWORD wxSlider::MSWGetStyle(long style, WXDWORD *exstyle) const | |
192 | { | |
193 | WXDWORD msStyle = wxControl::MSWGetStyle(style, exstyle); | |
194 | ||
195 | // TBS_HORZ, TBS_RIGHT and TBS_BOTTOM are 0 but do include them for clarity | |
196 | msStyle |= style & wxSL_VERTICAL ? TBS_VERT : TBS_HORZ; | |
197 | ||
198 | if ( style & wxSL_BOTH ) | |
199 | { | |
200 | // this fully specifies the style combined with TBS_VERT/HORZ above | |
201 | msStyle |= TBS_BOTH; | |
202 | } | |
203 | else // choose one direction | |
204 | { | |
205 | if ( style & wxSL_LEFT ) | |
206 | msStyle |= TBS_LEFT; | |
207 | else if ( style & wxSL_RIGHT ) | |
208 | msStyle |= TBS_RIGHT; | |
209 | else if ( style & wxSL_TOP ) | |
210 | msStyle |= TBS_TOP; | |
211 | else if ( style & wxSL_BOTTOM ) | |
212 | msStyle |= TBS_BOTTOM; | |
213 | } | |
214 | ||
215 | if ( style & wxSL_AUTOTICKS ) | |
216 | msStyle |= TBS_AUTOTICKS; | |
217 | else | |
218 | msStyle |= TBS_NOTICKS; | |
219 | ||
220 | if ( style & wxSL_SELRANGE ) | |
221 | msStyle |= TBS_ENABLESELRANGE; | |
222 | ||
223 | return msStyle; | |
224 | } | |
225 | ||
226 | wxSlider::~wxSlider() | |
227 | { | |
228 | delete m_labels; | |
229 | } | |
230 | ||
231 | // ---------------------------------------------------------------------------- | |
232 | // event handling | |
233 | // ---------------------------------------------------------------------------- | |
234 | ||
235 | bool wxSlider::MSWOnScroll(int WXUNUSED(orientation), | |
236 | WXWORD wParam, | |
237 | WXWORD WXUNUSED(pos), | |
238 | WXHWND control) | |
239 | { | |
240 | wxEventType scrollEvent; | |
241 | switch ( wParam ) | |
242 | { | |
243 | case SB_TOP: | |
244 | scrollEvent = wxEVT_SCROLL_TOP; | |
245 | break; | |
246 | ||
247 | case SB_BOTTOM: | |
248 | scrollEvent = wxEVT_SCROLL_BOTTOM; | |
249 | break; | |
250 | ||
251 | case SB_LINEUP: | |
252 | scrollEvent = wxEVT_SCROLL_LINEUP; | |
253 | break; | |
254 | ||
255 | case SB_LINEDOWN: | |
256 | scrollEvent = wxEVT_SCROLL_LINEDOWN; | |
257 | break; | |
258 | ||
259 | case SB_PAGEUP: | |
260 | scrollEvent = wxEVT_SCROLL_PAGEUP; | |
261 | break; | |
262 | ||
263 | case SB_PAGEDOWN: | |
264 | scrollEvent = wxEVT_SCROLL_PAGEDOWN; | |
265 | break; | |
266 | ||
267 | case SB_THUMBTRACK: | |
268 | scrollEvent = wxEVT_SCROLL_THUMBTRACK; | |
269 | m_isDragging = true; | |
270 | break; | |
271 | ||
272 | case SB_THUMBPOSITION: | |
273 | if ( m_isDragging ) | |
274 | { | |
275 | scrollEvent = wxEVT_SCROLL_THUMBRELEASE; | |
276 | m_isDragging = false; | |
277 | } | |
278 | else | |
279 | { | |
280 | // this seems to only happen when the mouse wheel is used: in | |
281 | // this case, as it might be unexpected to get THUMBRELEASE | |
282 | // without preceding THUMBTRACKs, we don't generate it at all | |
283 | // but generate CHANGED event because the control itself does | |
284 | // not send us SB_ENDSCROLL for whatever reason when mouse | |
285 | // wheel is used | |
286 | scrollEvent = wxEVT_SCROLL_CHANGED; | |
287 | } | |
288 | break; | |
289 | ||
290 | case SB_ENDSCROLL: | |
291 | scrollEvent = wxEVT_SCROLL_CHANGED; | |
292 | break; | |
293 | ||
294 | default: | |
295 | // unknown scroll event? | |
296 | return false; | |
297 | } | |
298 | ||
299 | int newPos = ValueInvertOrNot((int) ::SendMessage((HWND) control, TBM_GETPOS, 0, 0)); | |
300 | if ( (newPos < GetMin()) || (newPos > GetMax()) ) | |
301 | { | |
302 | // out of range - but we did process it | |
303 | return true; | |
304 | } | |
305 | ||
306 | SetValue(newPos); | |
307 | ||
308 | wxScrollEvent event(scrollEvent, m_windowId); | |
309 | event.SetPosition(newPos); | |
310 | event.SetEventObject( this ); | |
311 | HandleWindowEvent(event); | |
312 | ||
313 | wxCommandEvent cevent( wxEVT_SLIDER, GetId() ); | |
314 | cevent.SetInt( newPos ); | |
315 | cevent.SetEventObject( this ); | |
316 | ||
317 | return HandleWindowEvent( cevent ); | |
318 | } | |
319 | ||
320 | void wxSlider::Command (wxCommandEvent & event) | |
321 | { | |
322 | SetValue (event.GetInt()); | |
323 | ProcessCommand (event); | |
324 | } | |
325 | ||
326 | // ---------------------------------------------------------------------------- | |
327 | // geometry stuff | |
328 | // ---------------------------------------------------------------------------- | |
329 | ||
330 | wxRect wxSlider::GetBoundingBox() const | |
331 | { | |
332 | // take care not to call our own functions which would call us recursively | |
333 | int x, y, w, h; | |
334 | wxSliderBase::DoGetPosition(&x, &y); | |
335 | wxSliderBase::DoGetSize(&w, &h); | |
336 | ||
337 | wxRect rect(x, y, w, h); | |
338 | if ( m_labels ) | |
339 | { | |
340 | wxRect lrect = m_labels->GetBoundingBox(); | |
341 | GetParent()->ScreenToClient(&lrect.x, &lrect.y); | |
342 | rect.Union(lrect); | |
343 | } | |
344 | ||
345 | return rect; | |
346 | } | |
347 | ||
348 | void wxSlider::DoGetSize(int *width, int *height) const | |
349 | { | |
350 | wxRect rect = GetBoundingBox(); | |
351 | ||
352 | if ( width ) | |
353 | *width = rect.width; | |
354 | if ( height ) | |
355 | *height = rect.height; | |
356 | } | |
357 | ||
358 | void wxSlider::DoGetPosition(int *x, int *y) const | |
359 | { | |
360 | wxRect rect = GetBoundingBox(); | |
361 | ||
362 | if ( x ) | |
363 | *x = rect.x; | |
364 | if ( y ) | |
365 | *y = rect.y; | |
366 | } | |
367 | ||
368 | int wxSlider::GetLabelsSize(int *widthMin, int *widthMax) const | |
369 | { | |
370 | if ( widthMin && widthMax ) | |
371 | { | |
372 | *widthMin = GetTextExtent(Format(m_rangeMin)).x; | |
373 | *widthMax = GetTextExtent(Format(m_rangeMax)).x; | |
374 | ||
375 | if ( HasFlag(wxSL_INVERSE) ) | |
376 | { | |
377 | wxSwap(*widthMin, *widthMax); | |
378 | } | |
379 | } | |
380 | ||
381 | return HasFlag(wxSL_LABELS) ? GetCharHeight() : 0; | |
382 | } | |
383 | ||
384 | void wxSlider::DoMoveWindow(int x, int y, int width, int height) | |
385 | { | |
386 | // all complications below are because we need to position the labels, | |
387 | // without them everything is easy | |
388 | if ( !m_labels ) | |
389 | { | |
390 | wxSliderBase::DoMoveWindow(x, y, width, height); | |
391 | return; | |
392 | } | |
393 | ||
394 | int minLabelWidth, | |
395 | maxLabelWidth; | |
396 | const int labelHeight = GetLabelsSize(&minLabelWidth, &maxLabelWidth); | |
397 | const int longestLabelWidth = wxMax(minLabelWidth, maxLabelWidth); | |
398 | if ( !HasFlag(wxSL_MIN_MAX_LABELS) ) | |
399 | { | |
400 | minLabelWidth = | |
401 | maxLabelWidth = 0; | |
402 | } | |
403 | ||
404 | int tickOffset = 0; | |
405 | if ( HasFlag(wxSL_TICKS)) | |
406 | tickOffset = TICK; | |
407 | if ( HasFlag(wxSL_BOTH)) | |
408 | tickOffset *= 2; | |
409 | ||
410 | // be careful to position the slider itself after moving the labels as | |
411 | // otherwise our GetBoundingBox(), which is called from WM_SIZE handler, | |
412 | // would return a wrong result and wrong size would be cached internally | |
413 | if ( HasFlag(wxSL_VERTICAL) ) | |
414 | { | |
415 | int labelOffset = 0; | |
416 | int holdTopX; | |
417 | int holdBottomX; | |
418 | int xLabel = (wxMax((THUMB + (BORDERPAD * 2)), longestLabelWidth) / 2) - | |
419 | (longestLabelWidth / 2) + x; | |
420 | if ( HasFlag(wxSL_LEFT) ) | |
421 | { | |
422 | holdTopX = xLabel; | |
423 | holdBottomX = xLabel - (abs(maxLabelWidth - minLabelWidth) / 2); | |
424 | } | |
425 | else // wxSL_RIGHT | |
426 | { | |
427 | holdTopX = xLabel + longestLabelWidth + (abs(maxLabelWidth - minLabelWidth) / 2); | |
428 | holdBottomX = xLabel + longestLabelWidth; | |
429 | ||
430 | labelOffset = longestLabelWidth + HGAP; | |
431 | } | |
432 | ||
433 | if ( HasFlag(wxSL_MIN_MAX_LABELS) ) | |
434 | { | |
435 | if ( HasFlag(wxSL_INVERSE) ) | |
436 | { | |
437 | wxSwap(holdTopX, holdBottomX); | |
438 | } | |
439 | ||
440 | DoMoveSibling((HWND)(*m_labels)[SliderLabel_Min], | |
441 | holdTopX, | |
442 | y, | |
443 | minLabelWidth, labelHeight); | |
444 | DoMoveSibling((HWND)(*m_labels)[SliderLabel_Max], | |
445 | holdBottomX, | |
446 | y + height - labelHeight, | |
447 | maxLabelWidth, labelHeight); | |
448 | } | |
449 | ||
450 | if ( HasFlag(wxSL_VALUE_LABEL) ) | |
451 | { | |
452 | DoMoveSibling((HWND)(*m_labels)[SliderLabel_Value], | |
453 | x + ( HasFlag(wxSL_LEFT) ? THUMB + tickOffset + HGAP : 0 ), | |
454 | y + (height - labelHeight)/2, | |
455 | longestLabelWidth, labelHeight); | |
456 | } | |
457 | ||
458 | // position the slider itself along the left/right edge | |
459 | wxSliderBase::DoMoveWindow( | |
460 | x + labelOffset, | |
461 | y + labelHeight, | |
462 | THUMB + tickOffset + HGAP, | |
463 | height - (labelHeight * 2)); | |
464 | } | |
465 | else // horizontal | |
466 | { | |
467 | int yLabelMinMax = | |
468 | (y + ((THUMB + tickOffset) / 2)) - (labelHeight / 2); | |
469 | int xLabelValue = | |
470 | x + minLabelWidth + | |
471 | ((width - (minLabelWidth + maxLabelWidth)) / 2) - | |
472 | (longestLabelWidth / 2); | |
473 | ||
474 | int ySlider = y; | |
475 | ||
476 | if ( HasFlag(wxSL_VALUE_LABEL) ) | |
477 | { | |
478 | DoMoveSibling((HWND)(*m_labels)[SliderLabel_Value], | |
479 | xLabelValue, | |
480 | y + (HasFlag(wxSL_BOTTOM) ? 0 : THUMB + tickOffset), | |
481 | longestLabelWidth, labelHeight); | |
482 | ||
483 | if ( HasFlag(wxSL_BOTTOM) ) | |
484 | { | |
485 | ySlider += labelHeight; | |
486 | yLabelMinMax += labelHeight; | |
487 | } | |
488 | } | |
489 | ||
490 | if ( HasFlag(wxSL_MIN_MAX_LABELS) ) | |
491 | { | |
492 | DoMoveSibling((HWND)(*m_labels)[SliderLabel_Min], | |
493 | x, | |
494 | yLabelMinMax, | |
495 | minLabelWidth, labelHeight); | |
496 | DoMoveSibling((HWND)(*m_labels)[SliderLabel_Max], | |
497 | x + width - maxLabelWidth, | |
498 | yLabelMinMax, | |
499 | maxLabelWidth, labelHeight); | |
500 | } | |
501 | ||
502 | // position the slider itself along the top/bottom edge | |
503 | wxSliderBase::DoMoveWindow( | |
504 | x + minLabelWidth + VGAP, | |
505 | ySlider, | |
506 | width - (minLabelWidth + maxLabelWidth + (VGAP*2)), | |
507 | THUMB + tickOffset); | |
508 | } | |
509 | } | |
510 | ||
511 | wxSize wxSlider::DoGetBestSize() const | |
512 | { | |
513 | // this value is arbitrary: | |
514 | static const int length = 100; | |
515 | ||
516 | int *width; | |
517 | wxSize size; | |
518 | if ( HasFlag(wxSL_VERTICAL) ) | |
519 | { | |
520 | size.x = THUMB; | |
521 | size.y = length; | |
522 | width = &size.x; | |
523 | ||
524 | if ( m_labels ) | |
525 | { | |
526 | int widthMin, | |
527 | widthMax; | |
528 | int hLabel = GetLabelsSize(&widthMin, &widthMax); | |
529 | ||
530 | // account for the labels | |
531 | if ( HasFlag(wxSL_MIN_MAX_LABELS) ) | |
532 | size.x += HGAP + wxMax(widthMin, widthMax); | |
533 | ||
534 | // labels are indented relative to the slider itself | |
535 | size.y += hLabel; | |
536 | } | |
537 | } | |
538 | else // horizontal | |
539 | { | |
540 | size.x = length; | |
541 | size.y = THUMB; | |
542 | width = &size.y; | |
543 | ||
544 | if ( m_labels ) | |
545 | { | |
546 | int labelSize = GetLabelsSize(); | |
547 | ||
548 | // Min/max labels are compensated by the ticks so we don't need | |
549 | // extra space for them if we're also showing ticks. | |
550 | if ( HasFlag(wxSL_MIN_MAX_LABELS) && !HasFlag(wxSL_TICKS) ) | |
551 | size.y += labelSize; | |
552 | ||
553 | // The value label is always on top of the control and so does need | |
554 | // extra space in any case. | |
555 | if ( HasFlag(wxSL_VALUE_LABEL) ) | |
556 | size.y += labelSize; | |
557 | } | |
558 | } | |
559 | ||
560 | // need extra space to show ticks | |
561 | if ( HasFlag(wxSL_TICKS) ) | |
562 | { | |
563 | *width += TICK; | |
564 | // and maybe twice as much if we show them on both sides | |
565 | if ( HasFlag(wxSL_BOTH) ) | |
566 | *width += TICK; | |
567 | } | |
568 | return size; | |
569 | } | |
570 | ||
571 | // ---------------------------------------------------------------------------- | |
572 | // slider-specific methods | |
573 | // ---------------------------------------------------------------------------- | |
574 | ||
575 | int wxSlider::GetValue() const | |
576 | { | |
577 | return ValueInvertOrNot(::SendMessage(GetHwnd(), TBM_GETPOS, 0, 0)); | |
578 | } | |
579 | ||
580 | void wxSlider::SetValue(int value) | |
581 | { | |
582 | ::SendMessage(GetHwnd(), TBM_SETPOS, (WPARAM)TRUE, (LPARAM)ValueInvertOrNot(value)); | |
583 | ||
584 | if ( m_labels ) | |
585 | { | |
586 | ::SetWindowText((*m_labels)[SliderLabel_Value], Format(value).t_str()); | |
587 | } | |
588 | } | |
589 | ||
590 | void wxSlider::SetRange(int minValue, int maxValue) | |
591 | { | |
592 | // Remember the old logical value if we need to update the physical control | |
593 | // value after changing its range in wxSL_INVERSE case (and avoid an | |
594 | // unnecessary call to GetValue() otherwise as it's just not needed). | |
595 | const int valueOld = HasFlag(wxSL_INVERSE) ? GetValue() : 0; | |
596 | ||
597 | m_rangeMin = minValue; | |
598 | m_rangeMax = maxValue; | |
599 | ||
600 | ::SendMessage(GetHwnd(), TBM_SETRANGEMIN, TRUE, m_rangeMin); | |
601 | ::SendMessage(GetHwnd(), TBM_SETRANGEMAX, TRUE, m_rangeMax); | |
602 | ||
603 | if ( m_labels ) | |
604 | { | |
605 | ::SetWindowText((*m_labels)[SliderLabel_Min], | |
606 | Format(ValueInvertOrNot(m_rangeMin)).t_str()); | |
607 | ::SetWindowText((*m_labels)[SliderLabel_Max], | |
608 | Format(ValueInvertOrNot(m_rangeMax)).t_str()); | |
609 | } | |
610 | ||
611 | // When emulating wxSL_INVERSE style in wxWidgets, we need to update the | |
612 | // value after changing the range to ensure that the value seen by the user | |
613 | // code, i.e. the one returned by GetValue(), does not change. | |
614 | if ( HasFlag(wxSL_INVERSE) ) | |
615 | { | |
616 | ::SendMessage(GetHwnd(), TBM_SETPOS, TRUE, ValueInvertOrNot(valueOld)); | |
617 | } | |
618 | } | |
619 | ||
620 | void wxSlider::DoSetTickFreq(int n) | |
621 | { | |
622 | m_tickFreq = n; | |
623 | ::SendMessage( GetHwnd(), TBM_SETTICFREQ, (WPARAM) n, (LPARAM) 0 ); | |
624 | } | |
625 | ||
626 | void wxSlider::SetPageSize(int pageSize) | |
627 | { | |
628 | ::SendMessage( GetHwnd(), TBM_SETPAGESIZE, (WPARAM) 0, (LPARAM) pageSize ); | |
629 | m_pageSize = pageSize; | |
630 | } | |
631 | ||
632 | int wxSlider::GetPageSize() const | |
633 | { | |
634 | return m_pageSize; | |
635 | } | |
636 | ||
637 | void wxSlider::ClearSel() | |
638 | { | |
639 | ::SendMessage(GetHwnd(), TBM_CLEARSEL, (WPARAM) TRUE, (LPARAM) 0); | |
640 | } | |
641 | ||
642 | void wxSlider::ClearTicks() | |
643 | { | |
644 | ::SendMessage(GetHwnd(), TBM_CLEARTICS, (WPARAM) TRUE, (LPARAM) 0); | |
645 | } | |
646 | ||
647 | void wxSlider::SetLineSize(int lineSize) | |
648 | { | |
649 | m_lineSize = lineSize; | |
650 | ::SendMessage(GetHwnd(), TBM_SETLINESIZE, (WPARAM) 0, (LPARAM) lineSize); | |
651 | } | |
652 | ||
653 | int wxSlider::GetLineSize() const | |
654 | { | |
655 | return (int)::SendMessage(GetHwnd(), TBM_GETLINESIZE, 0, 0); | |
656 | } | |
657 | ||
658 | int wxSlider::GetSelEnd() const | |
659 | { | |
660 | return (int)::SendMessage(GetHwnd(), TBM_GETSELEND, 0, 0); | |
661 | } | |
662 | ||
663 | int wxSlider::GetSelStart() const | |
664 | { | |
665 | return (int)::SendMessage(GetHwnd(), TBM_GETSELSTART, 0, 0); | |
666 | } | |
667 | ||
668 | void wxSlider::SetSelection(int minPos, int maxPos) | |
669 | { | |
670 | ::SendMessage(GetHwnd(), TBM_SETSEL, | |
671 | (WPARAM) TRUE /* redraw */, | |
672 | (LPARAM) MAKELONG( minPos, maxPos) ); | |
673 | } | |
674 | ||
675 | void wxSlider::SetThumbLength(int len) | |
676 | { | |
677 | ::SendMessage(GetHwnd(), TBM_SETTHUMBLENGTH, (WPARAM) len, (LPARAM) 0); | |
678 | } | |
679 | ||
680 | int wxSlider::GetThumbLength() const | |
681 | { | |
682 | return (int)::SendMessage( GetHwnd(), TBM_GETTHUMBLENGTH, 0, 0); | |
683 | } | |
684 | ||
685 | void wxSlider::SetTick(int tickPos) | |
686 | { | |
687 | ::SendMessage( GetHwnd(), TBM_SETTIC, (WPARAM) 0, (LPARAM) tickPos ); | |
688 | } | |
689 | ||
690 | // ---------------------------------------------------------------------------- | |
691 | // composite control methods | |
692 | // ---------------------------------------------------------------------------- | |
693 | ||
694 | WXHWND wxSlider::GetStaticMin() const | |
695 | { | |
696 | return m_labels ? (WXHWND)(*m_labels)[SliderLabel_Min] : NULL; | |
697 | } | |
698 | ||
699 | WXHWND wxSlider::GetStaticMax() const | |
700 | { | |
701 | return m_labels ? (WXHWND)(*m_labels)[SliderLabel_Max] : NULL; | |
702 | } | |
703 | ||
704 | WXHWND wxSlider::GetEditValue() const | |
705 | { | |
706 | return m_labels ? (WXHWND)(*m_labels)[SliderLabel_Value] : NULL; | |
707 | } | |
708 | ||
709 | WX_FORWARD_STD_METHODS_TO_SUBWINDOWS(wxSlider, wxSliderBase, m_labels) | |
710 | ||
711 | #endif // wxUSE_SLIDER |