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