No real changes, just make some wxSlider members local variables.
[wxWidgets.git] / src / msw / slider.cpp
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((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_COMMAND_SLIDER_UPDATED, 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 if ( HasFlag(wxSL_MIN_MAX_LABELS) )
373 {
374 *widthMin = GetTextExtent(Format(m_rangeMin)).x;
375 *widthMax = GetTextExtent(Format(m_rangeMax)).x;
376 }
377 else
378 {
379 *widthMin =
380 *widthMax = 0;
381 }
382 }
383
384 return HasFlag(wxSL_LABELS) ? GetCharHeight() : 0;
385 }
386
387 void wxSlider::DoMoveWindow(int x, int y, int width, int height)
388 {
389 // all complications below are because we need to position the labels,
390 // without them everything is easy
391 if ( !m_labels )
392 {
393 wxSliderBase::DoMoveWindow(x, y, width, height);
394 return;
395 }
396
397 int minLabelWidth,
398 maxLabelWidth;
399 const int labelHeight = GetLabelsSize(&minLabelWidth, &maxLabelWidth);
400 const int longestLabelWidth = wxMax(minLabelWidth, maxLabelWidth);
401
402 int labelOffset = 0;
403 int tickOffset = 0;
404 if ( HasFlag(wxSL_TICKS))
405 tickOffset = TICK;
406 if ( HasFlag(wxSL_BOTH))
407 tickOffset *= 2;
408
409 // be careful to position the slider itself after moving the labels as
410 // otherwise our GetBoundingBox(), which is called from WM_SIZE handler,
411 // would return a wrong result and wrong size would be cached internally
412 if ( HasFlag(wxSL_VERTICAL) )
413 {
414 int holdTopWidth;
415 int holdTopX;
416 int holdBottomWidth;
417 int holdBottomX;
418 int xLabel = (wxMax((THUMB + (BORDERPAD * 2)), longestLabelWidth) / 2) -
419 (longestLabelWidth / 2) + x;
420 if ( HasFlag(wxSL_LEFT) )
421 {
422 if ( HasFlag(wxSL_MIN_MAX_LABELS) )
423 {
424 holdTopX = xLabel;
425 holdTopWidth = minLabelWidth;
426 holdBottomX = xLabel - ((maxLabelWidth - minLabelWidth) / 2);
427 holdBottomWidth = maxLabelWidth;
428 if ( HasFlag(wxSL_INVERSE) )
429 {
430 wxSwap(holdTopWidth, holdBottomWidth);
431 wxSwap(holdTopX, holdBottomX);
432 }
433 DoMoveSibling((HWND)(*m_labels)[SliderLabel_Min],
434 holdTopX,
435 y,
436 holdTopWidth, labelHeight);
437 DoMoveSibling((HWND)(*m_labels)[SliderLabel_Max],
438 holdBottomX,
439 y + height - labelHeight,
440 holdBottomWidth, labelHeight);
441 }
442 if ( HasFlag(wxSL_VALUE_LABEL) )
443 DoMoveSibling((HWND)(*m_labels)[SliderLabel_Value],
444 x + THUMB + tickOffset + HGAP,
445 y + (height - labelHeight)/2,
446 longestLabelWidth, labelHeight);
447 }
448 else // wxSL_RIGHT
449 {
450 if ( HasFlag(wxSL_MIN_MAX_LABELS) )
451 {
452 holdTopX = xLabel + longestLabelWidth + ((maxLabelWidth - minLabelWidth) / 2);
453 holdTopWidth = minLabelWidth;
454 holdBottomX = xLabel + longestLabelWidth;
455 holdBottomWidth = maxLabelWidth;
456 if ( HasFlag(wxSL_INVERSE) )
457 {
458 wxSwap(holdTopWidth, holdBottomWidth);
459 wxSwap(holdTopX, holdBottomX);
460 }
461 DoMoveSibling((HWND)(*m_labels)[SliderLabel_Min],
462 holdTopX,
463 y,
464 holdTopWidth, labelHeight);
465 DoMoveSibling((HWND)(*m_labels)[SliderLabel_Max],
466 holdBottomX,
467 y + height - labelHeight,
468 holdBottomWidth, labelHeight);
469 }
470 if ( HasFlag(wxSL_VALUE_LABEL) )
471 labelOffset = longestLabelWidth + HGAP;
472 DoMoveSibling((HWND)(*m_labels)[SliderLabel_Value],
473 x,
474 y + (height - labelHeight)/2,
475 longestLabelWidth, labelHeight);
476 }
477
478 // position the slider itself along the left/right edge
479 wxSliderBase::DoMoveWindow(
480 x + labelOffset,
481 y + labelHeight,
482 THUMB + tickOffset + HGAP,
483 height - (labelHeight * 2));
484 }
485 else // horizontal
486 {
487 int holdLeftWidth;
488 int holdLeftX;
489 int holdRightWidth;
490 int holdRightX;
491 int yLabelMinMax =
492 (y + ((THUMB + tickOffset) / 2)) - (labelHeight / 2);
493 int xLabelValue =
494 x + minLabelWidth +
495 ((width - (minLabelWidth + maxLabelWidth)) / 2) -
496 (maxLabelWidth / 2);
497
498 int ySlider = y;
499
500 if ( HasFlag(wxSL_BOTTOM) )
501 {
502 if ( HasFlag(wxSL_VALUE_LABEL) )
503 {
504 DoMoveSibling((HWND)(*m_labels)[SliderLabel_Value],
505 xLabelValue,
506 y,
507 longestLabelWidth, labelHeight);
508
509 ySlider += labelHeight;
510 yLabelMinMax += labelHeight;
511 }
512
513 if ( HasFlag(wxSL_MIN_MAX_LABELS) )
514 {
515 holdLeftX = x;
516 holdLeftWidth = minLabelWidth;
517 holdRightX = x + width - maxLabelWidth;
518 holdRightWidth = maxLabelWidth;
519 if ( HasFlag(wxSL_INVERSE) )
520 {
521 wxSwap(holdLeftWidth, holdRightWidth);
522 wxSwap(holdLeftX, holdRightX);
523 }
524 DoMoveSibling((HWND)(*m_labels)[SliderLabel_Min],
525 holdLeftX,
526 yLabelMinMax,
527 holdLeftWidth, labelHeight);
528 DoMoveSibling((HWND)(*m_labels)[SliderLabel_Max],
529 holdRightX,
530 yLabelMinMax,
531 holdRightWidth, labelHeight);
532 }
533 }
534 else // wxSL_TOP
535 {
536 if ( HasFlag(wxSL_VALUE_LABEL) )
537 {
538 DoMoveSibling((HWND)(*m_labels)[SliderLabel_Value],
539 xLabelValue,
540 y + THUMB + tickOffset,
541 longestLabelWidth, labelHeight);
542 }
543
544 if ( HasFlag(wxSL_MIN_MAX_LABELS) )
545 {
546 holdLeftX = x;
547 holdLeftWidth = minLabelWidth;
548 holdRightX = x + width - maxLabelWidth;
549 holdRightWidth = maxLabelWidth;
550 if ( HasFlag(wxSL_INVERSE) )
551 {
552 wxSwap(holdLeftWidth, holdRightWidth);
553 wxSwap(holdLeftX, holdRightX);
554 }
555 DoMoveSibling((HWND)(*m_labels)[SliderLabel_Min],
556 holdLeftX,
557 yLabelMinMax,
558 holdLeftWidth, labelHeight);
559 DoMoveSibling((HWND)(*m_labels)[SliderLabel_Max],
560 holdRightX,
561 yLabelMinMax,
562 holdRightWidth, labelHeight);
563 }
564 }
565
566 // position the slider itself along the top/bottom edge
567 if ( HasFlag(wxSL_MIN_MAX_LABELS) || HasFlag(wxSL_VALUE_LABEL) )
568 labelOffset = labelHeight;
569 wxSliderBase::DoMoveWindow(
570 x + minLabelWidth + VGAP,
571 ySlider,
572 width - (minLabelWidth + maxLabelWidth + (VGAP*2)),
573 THUMB + tickOffset);
574 }
575 }
576
577 wxSize wxSlider::DoGetBestSize() const
578 {
579 // this value is arbitrary:
580 static const int length = 100;
581
582 int *width;
583 wxSize size;
584 if ( HasFlag(wxSL_VERTICAL) )
585 {
586 size.x = THUMB;
587 size.y = length;
588 width = &size.x;
589
590 if ( m_labels )
591 {
592 int widthMin,
593 widthMax;
594 int hLabel = GetLabelsSize(&widthMin, &widthMax);
595
596 // account for the labels
597 size.x += HGAP + wxMax(widthMin, widthMax);
598
599 // labels are indented relative to the slider itself
600 size.y += hLabel;
601 }
602 }
603 else // horizontal
604 {
605 size.x = length;
606 size.y = THUMB;
607 width = &size.y;
608
609 if ( m_labels )
610 {
611 int labelSize = GetLabelsSize();
612
613 // Min/max labels are compensated by the ticks so we don't need
614 // extra space for them if we're also showing ticks.
615 if ( HasFlag(wxSL_MIN_MAX_LABELS) && !HasFlag(wxSL_TICKS) )
616 size.y += labelSize;
617
618 // The value label is always on top of the control and so does need
619 // extra space in any case.
620 if ( HasFlag(wxSL_VALUE_LABEL) )
621 size.y += labelSize;
622 }
623 }
624
625 // need extra space to show ticks
626 if ( HasFlag(wxSL_TICKS) )
627 {
628 *width += TICK;
629 // and maybe twice as much if we show them on both sides
630 if ( HasFlag(wxSL_BOTH) )
631 *width += TICK;
632 }
633 return size;
634 }
635
636 // ----------------------------------------------------------------------------
637 // slider-specific methods
638 // ----------------------------------------------------------------------------
639
640 int wxSlider::GetValue() const
641 {
642 return ValueInvertOrNot(::SendMessage(GetHwnd(), TBM_GETPOS, 0, 0));
643 }
644
645 void wxSlider::SetValue(int value)
646 {
647 ::SendMessage(GetHwnd(), TBM_SETPOS, (WPARAM)TRUE, (LPARAM)ValueInvertOrNot(value));
648
649 if ( m_labels )
650 {
651 ::SetWindowText((*m_labels)[SliderLabel_Value], Format(value).wx_str());
652 }
653 }
654
655 void wxSlider::SetRange(int minValue, int maxValue)
656 {
657 // Remember the old logical value if we need to update the physical control
658 // value after changing its range in wxSL_INVERSE case (and avoid an
659 // unnecessary call to GetValue() otherwise as it's just not needed).
660 const int valueOld = HasFlag(wxSL_INVERSE) ? GetValue() : 0;
661
662 m_rangeMin = minValue;
663 m_rangeMax = maxValue;
664
665 ::SendMessage(GetHwnd(), TBM_SETRANGEMIN, TRUE, m_rangeMin);
666 ::SendMessage(GetHwnd(), TBM_SETRANGEMAX, TRUE, m_rangeMax);
667
668 if ( m_labels )
669 {
670 ::SetWindowText((*m_labels)[SliderLabel_Min],
671 Format(ValueInvertOrNot(m_rangeMin)).wx_str());
672 ::SetWindowText((*m_labels)[SliderLabel_Max],
673 Format(ValueInvertOrNot(m_rangeMax)).wx_str());
674 }
675
676 // When emulating wxSL_INVERSE style in wxWidgets, we need to update the
677 // value after changing the range to ensure that the value seen by the user
678 // code, i.e. the one returned by GetValue(), does not change.
679 if ( HasFlag(wxSL_INVERSE) )
680 {
681 ::SendMessage(GetHwnd(), TBM_SETPOS, TRUE, ValueInvertOrNot(valueOld));
682 }
683 }
684
685 void wxSlider::DoSetTickFreq(int n)
686 {
687 m_tickFreq = n;
688 ::SendMessage( GetHwnd(), TBM_SETTICFREQ, (WPARAM) n, (LPARAM) 0 );
689 }
690
691 void wxSlider::SetPageSize(int pageSize)
692 {
693 ::SendMessage( GetHwnd(), TBM_SETPAGESIZE, (WPARAM) 0, (LPARAM) pageSize );
694 m_pageSize = pageSize;
695 }
696
697 int wxSlider::GetPageSize() const
698 {
699 return m_pageSize;
700 }
701
702 void wxSlider::ClearSel()
703 {
704 ::SendMessage(GetHwnd(), TBM_CLEARSEL, (WPARAM) TRUE, (LPARAM) 0);
705 }
706
707 void wxSlider::ClearTicks()
708 {
709 ::SendMessage(GetHwnd(), TBM_CLEARTICS, (WPARAM) TRUE, (LPARAM) 0);
710 }
711
712 void wxSlider::SetLineSize(int lineSize)
713 {
714 m_lineSize = lineSize;
715 ::SendMessage(GetHwnd(), TBM_SETLINESIZE, (WPARAM) 0, (LPARAM) lineSize);
716 }
717
718 int wxSlider::GetLineSize() const
719 {
720 return (int)::SendMessage(GetHwnd(), TBM_GETLINESIZE, 0, 0);
721 }
722
723 int wxSlider::GetSelEnd() const
724 {
725 return (int)::SendMessage(GetHwnd(), TBM_GETSELEND, 0, 0);
726 }
727
728 int wxSlider::GetSelStart() const
729 {
730 return (int)::SendMessage(GetHwnd(), TBM_GETSELSTART, 0, 0);
731 }
732
733 void wxSlider::SetSelection(int minPos, int maxPos)
734 {
735 ::SendMessage(GetHwnd(), TBM_SETSEL,
736 (WPARAM) TRUE /* redraw */,
737 (LPARAM) MAKELONG( minPos, maxPos) );
738 }
739
740 void wxSlider::SetThumbLength(int len)
741 {
742 ::SendMessage(GetHwnd(), TBM_SETTHUMBLENGTH, (WPARAM) len, (LPARAM) 0);
743 }
744
745 int wxSlider::GetThumbLength() const
746 {
747 return (int)::SendMessage( GetHwnd(), TBM_GETTHUMBLENGTH, 0, 0);
748 }
749
750 void wxSlider::SetTick(int tickPos)
751 {
752 ::SendMessage( GetHwnd(), TBM_SETTIC, (WPARAM) 0, (LPARAM) tickPos );
753 }
754
755 // ----------------------------------------------------------------------------
756 // composite control methods
757 // ----------------------------------------------------------------------------
758
759 WXHWND wxSlider::GetStaticMin() const
760 {
761 return m_labels ? (WXHWND)(*m_labels)[SliderLabel_Min] : NULL;
762 }
763
764 WXHWND wxSlider::GetStaticMax() const
765 {
766 return m_labels ? (WXHWND)(*m_labels)[SliderLabel_Max] : NULL;
767 }
768
769 WXHWND wxSlider::GetEditValue() const
770 {
771 return m_labels ? (WXHWND)(*m_labels)[SliderLabel_Value] : NULL;
772 }
773
774 WX_FORWARD_STD_METHODS_TO_SUBWINDOWS(wxSlider, wxSliderBase, m_labels)
775
776 #endif // wxUSE_SLIDER