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