]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/msw/slider.cpp
Test using wxString::ToCDouble() in wxAny.
[wxWidgets.git] / src / msw / slider.cpp
... / ...
CommitLineData
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
43namespace
44{
45
46// indices of labels in wxSlider::m_labels
47enum
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
56const int HGAP = 5;
57const int VGAP = 4;
58// the width of the borders including white space
59const int BORDERPAD = 8;
60// these 2 values are arbitrary:
61const int THUMB = 24;
62const int TICK = 8;
63
64} // anonymous namespace
65
66// ============================================================================
67// wxSlider implementation
68// ============================================================================
69
70// ----------------------------------------------------------------------------
71// construction
72// ----------------------------------------------------------------------------
73
74void 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
87bool 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
191WXDWORD 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
226wxSlider::~wxSlider()
227{
228 delete m_labels;
229}
230
231// ----------------------------------------------------------------------------
232// event handling
233// ----------------------------------------------------------------------------
234
235bool 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
320void wxSlider::Command (wxCommandEvent & event)
321{
322 SetValue (event.GetInt());
323 ProcessCommand (event);
324}
325
326// ----------------------------------------------------------------------------
327// geometry stuff
328// ----------------------------------------------------------------------------
329
330wxRect 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
348void 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
358void 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
368int 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
384void 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
511wxSize 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
575int wxSlider::GetValue() const
576{
577 return ValueInvertOrNot(::SendMessage(GetHwnd(), TBM_GETPOS, 0, 0));
578}
579
580void 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
590void 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
620void wxSlider::DoSetTickFreq(int n)
621{
622 m_tickFreq = n;
623 ::SendMessage( GetHwnd(), TBM_SETTICFREQ, (WPARAM) n, (LPARAM) 0 );
624}
625
626void wxSlider::SetPageSize(int pageSize)
627{
628 ::SendMessage( GetHwnd(), TBM_SETPAGESIZE, (WPARAM) 0, (LPARAM) pageSize );
629 m_pageSize = pageSize;
630}
631
632int wxSlider::GetPageSize() const
633{
634 return m_pageSize;
635}
636
637void wxSlider::ClearSel()
638{
639 ::SendMessage(GetHwnd(), TBM_CLEARSEL, (WPARAM) TRUE, (LPARAM) 0);
640}
641
642void wxSlider::ClearTicks()
643{
644 ::SendMessage(GetHwnd(), TBM_CLEARTICS, (WPARAM) TRUE, (LPARAM) 0);
645}
646
647void wxSlider::SetLineSize(int lineSize)
648{
649 m_lineSize = lineSize;
650 ::SendMessage(GetHwnd(), TBM_SETLINESIZE, (WPARAM) 0, (LPARAM) lineSize);
651}
652
653int wxSlider::GetLineSize() const
654{
655 return (int)::SendMessage(GetHwnd(), TBM_GETLINESIZE, 0, 0);
656}
657
658int wxSlider::GetSelEnd() const
659{
660 return (int)::SendMessage(GetHwnd(), TBM_GETSELEND, 0, 0);
661}
662
663int wxSlider::GetSelStart() const
664{
665 return (int)::SendMessage(GetHwnd(), TBM_GETSELSTART, 0, 0);
666}
667
668void wxSlider::SetSelection(int minPos, int maxPos)
669{
670 ::SendMessage(GetHwnd(), TBM_SETSEL,
671 (WPARAM) TRUE /* redraw */,
672 (LPARAM) MAKELONG( minPos, maxPos) );
673}
674
675void wxSlider::SetThumbLength(int len)
676{
677 ::SendMessage(GetHwnd(), TBM_SETTHUMBLENGTH, (WPARAM) len, (LPARAM) 0);
678}
679
680int wxSlider::GetThumbLength() const
681{
682 return (int)::SendMessage( GetHwnd(), TBM_GETTHUMBLENGTH, 0, 0);
683}
684
685void wxSlider::SetTick(int tickPos)
686{
687 ::SendMessage( GetHwnd(), TBM_SETTIC, (WPARAM) 0, (LPARAM) tickPos );
688}
689
690// ----------------------------------------------------------------------------
691// composite control methods
692// ----------------------------------------------------------------------------
693
694WXHWND wxSlider::GetStaticMin() const
695{
696 return m_labels ? (WXHWND)(*m_labels)[SliderLabel_Min] : NULL;
697}
698
699WXHWND wxSlider::GetStaticMax() const
700{
701 return m_labels ? (WXHWND)(*m_labels)[SliderLabel_Max] : NULL;
702}
703
704WXHWND wxSlider::GetEditValue() const
705{
706 return m_labels ? (WXHWND)(*m_labels)[SliderLabel_Value] : NULL;
707}
708
709WX_FORWARD_STD_METHODS_TO_SUBWINDOWS(wxSlider, wxSliderBase, m_labels)
710
711#endif // wxUSE_SLIDER