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