src/msw/slider95.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        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 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
  18 #pragma implementation "slider95.h"
  19 #endif
  20
  21 // ----------------------------------------------------------------------------
  22 // headers
  23 // ----------------------------------------------------------------------------
  24
  25 // For compilers that support precompilation, includes "wx.h".
  26 #include "wx/wxprec.h"
  27
  28 #ifdef __BORLANDC__
  29     #pragma hdrstop
  30 #endif
  31
  32 #if wxUSE_SLIDER
  33
  34 #ifndef WX_PRECOMP
  35     #include "wx/brush.h"
  36 #endif
  37
  38 #include "wx/slider.h"
  39 #include "wx/msw/subwin.h"
  40
  41 #if !(defined(__GNUWIN32_OLD__) && !defined(__CYGWIN10__))
  42     #include <commctrl.h>
  43 #endif
  44
  45 // ----------------------------------------------------------------------------
  46 // constants
  47 // ----------------------------------------------------------------------------
  48
  49 // indices of labels in wxSlider::m_labels
  50 enum
  51 {
  52     SliderLabel_Min,
  53     SliderLabel_Max,
  54     SliderLabel_Value,
  55     SliderLabel_Last
  56 };
  57
  58 // the gap between the slider and the labels, in pixels
  59 static const int HGAP = 5;
  60
  61 // ----------------------------------------------------------------------------
  62 // XTI
  63 // ----------------------------------------------------------------------------
  64
  65 #if wxUSE_EXTENDED_RTTI
  66 WX_DEFINE_FLAGS( wxSliderStyle )
  67
  68 wxBEGIN_FLAGS( wxSliderStyle )
  69     // new style border flags, we put them first to
  70     // use them for streaming out
  71     wxFLAGS_MEMBER(wxBORDER_SIMPLE)
  72     wxFLAGS_MEMBER(wxBORDER_SUNKEN)
  73     wxFLAGS_MEMBER(wxBORDER_DOUBLE)
  74     wxFLAGS_MEMBER(wxBORDER_RAISED)
  75     wxFLAGS_MEMBER(wxBORDER_STATIC)
  76     wxFLAGS_MEMBER(wxBORDER_NONE)
  77
  78     // old style border flags
  79     wxFLAGS_MEMBER(wxSIMPLE_BORDER)
  80     wxFLAGS_MEMBER(wxSUNKEN_BORDER)
  81     wxFLAGS_MEMBER(wxDOUBLE_BORDER)
  82     wxFLAGS_MEMBER(wxRAISED_BORDER)
  83     wxFLAGS_MEMBER(wxSTATIC_BORDER)
  84     wxFLAGS_MEMBER(wxBORDER)
  85
  86     // standard window styles
  87     wxFLAGS_MEMBER(wxTAB_TRAVERSAL)
  88     wxFLAGS_MEMBER(wxCLIP_CHILDREN)
  89     wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW)
  90     wxFLAGS_MEMBER(wxWANTS_CHARS)
  91     wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE)
  92     wxFLAGS_MEMBER(wxALWAYS_SHOW_SB )
  93     wxFLAGS_MEMBER(wxVSCROLL)
  94     wxFLAGS_MEMBER(wxHSCROLL)
  95
  96     wxFLAGS_MEMBER(wxSL_HORIZONTAL)
  97     wxFLAGS_MEMBER(wxSL_VERTICAL)
  98     wxFLAGS_MEMBER(wxSL_AUTOTICKS)
  99     wxFLAGS_MEMBER(wxSL_LABELS)
 100     wxFLAGS_MEMBER(wxSL_LEFT)
 101     wxFLAGS_MEMBER(wxSL_TOP)
 102     wxFLAGS_MEMBER(wxSL_RIGHT)
 103     wxFLAGS_MEMBER(wxSL_BOTTOM)
 104     wxFLAGS_MEMBER(wxSL_BOTH)
 105     wxFLAGS_MEMBER(wxSL_SELRANGE)
 106     wxFLAGS_MEMBER(wxSL_INVERSE)
 107
 108 wxEND_FLAGS( wxSliderStyle )
 109
 110 IMPLEMENT_DYNAMIC_CLASS_XTI(wxSlider, wxControl,"wx/scrolbar.h")
 111
 112 wxBEGIN_PROPERTIES_TABLE(wxSlider)
 113     wxEVENT_RANGE_PROPERTY( Scroll , wxEVT_SCROLL_TOP , wxEVT_SCROLL_ENDSCROLL , wxScrollEvent )
 114     wxEVENT_PROPERTY( Updated , wxEVT_COMMAND_SLIDER_UPDATED , wxCommandEvent )
 115
 116     wxPROPERTY( Value , int , SetValue, GetValue , 0, 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
 117     wxPROPERTY( Minimum , int , SetMin, GetMin, 0 , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
 118     wxPROPERTY( Maximum , int , SetMax, GetMax, 0 , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
 119     wxPROPERTY( PageSize , int , SetPageSize, GetLineSize, 1 , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
 120     wxPROPERTY( LineSize , int , SetLineSize, GetLineSize, 1 , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
 121     wxPROPERTY( ThumbLength , int , SetThumbLength, GetThumbLength, 1 , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
 122     wxPROPERTY_FLAGS( WindowStyle , wxSliderStyle , long , SetWindowStyleFlag , GetWindowStyleFlag , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
 123 wxEND_PROPERTIES_TABLE()
 124
 125 wxBEGIN_HANDLERS_TABLE(wxSlider)
 126 wxEND_HANDLERS_TABLE()
 127
 128 wxCONSTRUCTOR_8( wxSlider , wxWindow* , Parent , wxWindowID , Id , int , Value , int , Minimum , int , Maximum , wxPoint , Position , wxSize , Size , long , WindowStyle )
 129 #else
 130 IMPLEMENT_DYNAMIC_CLASS(wxSlider, wxControl)
 131 #endif
 132
 133 // ============================================================================
 134 // wxSlider implementation
 135 // ============================================================================
 136
 137 // ----------------------------------------------------------------------------
 138 // construction
 139 // ----------------------------------------------------------------------------
 140
 141 void wxSlider::Init()
 142 {
 143     m_labels = NULL;
 144
 145     m_pageSize = 1;
 146     m_lineSize = 1;
 147     m_rangeMax = 0;
 148     m_rangeMin = 0;
 149     m_tickFreq = 0;
 150 }
 151
 152 bool
 153 wxSlider::Create(wxWindow *parent,
 154                  wxWindowID id,
 155                  int value,
 156                  int minValue,
 157                  int maxValue,
 158                  const wxPoint& pos,
 159                  const wxSize& size,
 160                  long style,
 161                  const wxValidator& validator,
 162                  const wxString& name)
 163 {
 164     // our styles are redundant: wxSL_LEFT/RIGHT imply wxSL_VERTICAL and
 165     // wxSL_TOP/BOTTOM imply wxSL_HORIZONTAL, but for backwards compatibility
 166     // reasons we can't really change it, instead try to infer the orientation
 167     // from the flags given to us here
 168     switch ( style & (wxSL_LEFT | wxSL_RIGHT | wxSL_TOP | wxSL_BOTTOM) )
 169     {
 170         case wxSL_LEFT:
 171         case wxSL_RIGHT:
 172             style |= wxSL_VERTICAL;
 173             break;
 174
 175         case wxSL_TOP:
 176         case wxSL_BOTTOM:
 177             style |= wxSL_HORIZONTAL;
 178             break;
 179
 180         case 0:
 181             // no specific direction, do we have at least the orientation?
 182             if ( !(style & (wxSL_HORIZONTAL | wxSL_VERTICAL)) )
 183             {
 184                 // no, choose default
 185                 style |= wxSL_BOTTOM | wxSL_HORIZONTAL;
 186             }
 187     };
 188
 189     wxASSERT_MSG( !(style & wxSL_VERTICAL) | !(style & wxSL_HORIZONTAL),
 190                     _T("incompatible slider direction and orientation") );
 191
 192
 193     // initialize everything
 194     if ( !CreateControl(parent, id, pos, size, style, validator, name) )
 195         return false;
 196
 197     // ensure that we have correct values for GetLabelsSize()
 198     m_rangeMin = minValue;
 199     m_rangeMax = maxValue;
 200
 201     // create the labels first, so that our DoGetBestSize() could take them
 202     // into account
 203     //
 204     // note that we could simply create 3 wxStaticTexts here but it could
 205     // result in some observable side effects at wx level (e.g. the parent of
 206     // wxSlider would have 3 more children than expected) and so we prefer not
 207     // to do it like this
 208     if ( m_windowStyle & wxSL_LABELS )
 209     {
 210         m_labels = new wxSubwindows(SliderLabel_Last);
 211
 212         HWND hwndParent = GetHwndOf(parent);
 213         for ( size_t n = 0; n < SliderLabel_Last; n++ )
 214         {
 215             (*m_labels)[n] = ::CreateWindow
 216                                (
 217                                     wxT("STATIC"),
 218                                     NULL,
 219                                     WS_CHILD | WS_VISIBLE | SS_CENTER,
 220                                     0, 0, 0, 0,
 221                                     hwndParent,
 222                                     (HMENU)NewControlId(),
 223                                     wxGetInstance(),
 224                                     NULL
 225                                );
 226         }
 227
 228         m_labels->SetFont(GetFont());
 229     }
 230
 231     // now create the main control too
 232     if ( !MSWCreateControl(TRACKBAR_CLASS, wxEmptyString, pos, size) )
 233         return false;
 234
 235     // and initialize everything
 236     SetRange(minValue, maxValue);
 237     SetValue(value);
 238     SetPageSize((maxValue - minValue)/10);
 239
 240     // we need to position the labels correctly if we have them and if
 241     // SetSize() hadn't been called before (when best size was determined by
 242     // MSWCreateControl()) as in this case they haven't been put in place yet
 243     if ( m_labels && size.x != wxDefaultCoord && size.y != wxDefaultCoord )
 244     {
 245         SetSize(size);
 246     }
 247
 248     return true;
 249 }
 250
 251 WXDWORD wxSlider::MSWGetStyle(long style, WXDWORD *exstyle) const
 252 {
 253     WXDWORD msStyle = wxControl::MSWGetStyle(style, exstyle);
 254
 255     // TBS_HORZ, TBS_RIGHT and TBS_BOTTOM are 0 but do include them for clarity
 256     msStyle |= style & wxSL_VERTICAL ? TBS_VERT : TBS_HORZ;
 257
 258     if ( style & wxSL_BOTH )
 259     {
 260         // this fully specifies the style combined with TBS_VERT/HORZ above
 261         msStyle |= TBS_BOTH;
 262     }
 263     else // choose one direction
 264     {
 265         if ( style & wxSL_LEFT )
 266             msStyle |= TBS_LEFT;
 267         else if ( style & wxSL_RIGHT )
 268             msStyle |= TBS_RIGHT;
 269         else if ( style & wxSL_TOP )
 270             msStyle |= TBS_TOP;
 271         else if ( style & wxSL_BOTTOM )
 272             msStyle |= TBS_BOTTOM;
 273     }
 274
 275     if ( style & wxSL_AUTOTICKS )
 276         msStyle |= TBS_AUTOTICKS;
 277     else
 278         msStyle |= TBS_NOTICKS;
 279
 280     if ( style & wxSL_SELRANGE )
 281         msStyle |= TBS_ENABLESELRANGE;
 282
 283     return msStyle;
 284 }
 285
 286 wxSlider::~wxSlider()
 287 {
 288     delete m_labels;
 289 }
 290
 291 // ----------------------------------------------------------------------------
 292 // event handling
 293 // ----------------------------------------------------------------------------
 294
 295 bool wxSlider::MSWOnScroll(int WXUNUSED(orientation),
 296                            WXWORD wParam,
 297                            WXWORD WXUNUSED(pos),
 298                            WXHWND control)
 299 {
 300     wxEventType scrollEvent;
 301     switch ( wParam )
 302     {
 303         case SB_TOP:
 304             scrollEvent = wxEVT_SCROLL_TOP;
 305             break;
 306
 307         case SB_BOTTOM:
 308             scrollEvent = wxEVT_SCROLL_BOTTOM;
 309             break;
 310
 311         case SB_LINEUP:
 312             scrollEvent = wxEVT_SCROLL_LINEUP;
 313             break;
 314
 315         case SB_LINEDOWN:
 316             scrollEvent = wxEVT_SCROLL_LINEDOWN;
 317             break;
 318
 319         case SB_PAGEUP:
 320             scrollEvent = wxEVT_SCROLL_PAGEUP;
 321             break;
 322
 323         case SB_PAGEDOWN:
 324             scrollEvent = wxEVT_SCROLL_PAGEDOWN;
 325             break;
 326
 327         case SB_THUMBTRACK:
 328             scrollEvent = wxEVT_SCROLL_THUMBTRACK;
 329             break;
 330
 331         case SB_THUMBPOSITION:
 332             scrollEvent = wxEVT_SCROLL_THUMBRELEASE;
 333             break;
 334
 335         case SB_ENDSCROLL:
 336             scrollEvent = wxEVT_SCROLL_ENDSCROLL;
 337             break;
 338
 339         default:
 340             // unknown scroll event?
 341             return false;
 342     }
 343
 344     int newPos = ValueInvertOrNot((int) ::SendMessage((HWND) control, TBM_GETPOS, 0, 0));
 345     if ( (newPos < GetMin()) || (newPos > GetMax()) )
 346     {
 347         // out of range - but we did process it
 348         return true;
 349     }
 350
 351     SetValue(newPos);
 352
 353     wxScrollEvent event(scrollEvent, m_windowId);
 354     event.SetPosition(newPos);
 355     event.SetEventObject( this );
 356     GetEventHandler()->ProcessEvent(event);
 357
 358     wxCommandEvent cevent( wxEVT_COMMAND_SLIDER_UPDATED, GetId() );
 359     cevent.SetInt( newPos );
 360     cevent.SetEventObject( this );
 361
 362     return GetEventHandler()->ProcessEvent( cevent );
 363 }
 364
 365 void wxSlider::Command (wxCommandEvent & event)
 366 {
 367     SetValue (event.GetInt());
 368     ProcessCommand (event);
 369 }
 370
 371 // ----------------------------------------------------------------------------
 372 // geometry stuff
 373 // ----------------------------------------------------------------------------
 374
 375 wxRect wxSlider::GetBoundingBox() const
 376 {
 377     // take care not to call our own functions which would call us recursively
 378     int x, y, w, h;
 379     wxSliderBase::DoGetPosition(&x, &y);
 380     wxSliderBase::DoGetSize(&w, &h);
 381
 382     wxRect rect(x, y, w, h);
 383     if ( m_labels )
 384     {
 385         wxRect lrect = m_labels->GetBoundingBox();
 386         GetParent()->ScreenToClient(&lrect.x, &lrect.y);
 387         rect.Union(lrect);
 388     }
 389
 390     return rect;
 391 }
 392
 393 void wxSlider::DoGetSize(int *width, int *height) const
 394 {
 395     wxRect rect = GetBoundingBox();
 396
 397     if ( width )
 398         *width = rect.width;
 399     if ( height )
 400         *height = rect.height;
 401 }
 402
 403 void wxSlider::DoGetPosition(int *x, int *y) const
 404 {
 405     wxRect rect = GetBoundingBox();
 406
 407     if ( x )
 408         *x = rect.x;
 409     if ( y )
 410         *y = rect.y;
 411 }
 412
 413 int wxSlider::GetLabelsSize(int *width) const
 414 {
 415     int cy;
 416
 417     if ( width )
 418     {
 419         // find the max label width
 420         int wLabelMin, wLabelMax;
 421         GetTextExtent(Format(m_rangeMin), &wLabelMin, &cy);
 422         GetTextExtent(Format(m_rangeMax), &wLabelMax, &cy);
 423
 424         *width = wxMax(wLabelMin, wLabelMax);
 425     }
 426     else
 427     {
 428         cy = GetCharHeight();
 429     }
 430
 431     return EDIT_HEIGHT_FROM_CHAR_HEIGHT(cy);
 432 }
 433
 434 void wxSlider::DoMoveWindow(int x, int y, int width, int height)
 435 {
 436     // all complications below are because we need to position the labels,
 437     // without them everything is easy
 438     if ( !m_labels )
 439     {
 440         wxSliderBase::DoMoveWindow(x, y, width, height);
 441         return;
 442     }
 443
 444     // be careful to position the slider itself after moving the labels as
 445     // otherwise our GetBoundingBox(), which is called from WM_SIZE handler,
 446     // would return a wrong result and wrong size would be cached internally
 447     if ( HasFlag(wxSL_VERTICAL) )
 448     {
 449         int wLabel;
 450         int hLabel = GetLabelsSize(&wLabel);
 451
 452         int xLabel = HasFlag(wxSL_LEFT) ? x + width - wLabel : x;
 453
 454         // position all labels: min at the top, value in the middle and max at
 455         // the bottom
 456         ::MoveWindow((*m_labels)[SliderLabel_Min],
 457                      xLabel, y, wLabel, hLabel, TRUE);
 458
 459         ::MoveWindow((*m_labels)[SliderLabel_Value],
 460                      xLabel, y + (height - hLabel)/2, wLabel, hLabel, TRUE);
 461
 462         ::MoveWindow((*m_labels)[SliderLabel_Max],
 463                      xLabel, y + height - hLabel, wLabel, hLabel, TRUE);
 464
 465         // position the slider itself along the left/right edge
 466         ::MoveWindow(GetHwnd(),
 467                      HasFlag(wxSL_LEFT) ? x : x + wLabel + HGAP,
 468                      y + hLabel/2,
 469                      width - wLabel - HGAP,
 470                      height - hLabel,
 471                      TRUE);
 472     }
 473     else // horizontal
 474     {
 475         int wLabel;
 476         int hLabel = GetLabelsSize(&wLabel);
 477
 478         int yLabel = HasFlag(wxSL_TOP) ? y + height - hLabel : y;
 479
 480         // position all labels: min on the left, value in the middle and max to
 481         // the right
 482         ::MoveWindow((*m_labels)[SliderLabel_Min],
 483                      x, yLabel, wLabel, hLabel, TRUE);
 484
 485         ::MoveWindow((*m_labels)[SliderLabel_Value],
 486                      x + (width - wLabel)/2, yLabel, wLabel, hLabel, TRUE);
 487
 488         ::MoveWindow((*m_labels)[SliderLabel_Max],
 489                      x + width - wLabel, yLabel, wLabel, hLabel, TRUE);
 490
 491         // position the slider itself along the top/bottom edge
 492         ::MoveWindow(GetHwnd(),
 493                      x,
 494                      HasFlag(wxSL_TOP) ? y : y + hLabel,
 495                      width,
 496                      height - hLabel,
 497                      TRUE);
 498     }
 499 }
 500
 501 wxSize wxSlider::DoGetBestSize() const
 502 {
 503     // these values are arbitrary
 504     static const int length = 100;
 505     static const int thumb = 24;
 506     static const int ticks = 8;
 507
 508     int *width;
 509     wxSize size;
 510     if ( HasFlag(wxSL_VERTICAL) )
 511     {
 512         size.x = thumb;
 513         size.y = length;
 514         width = &size.x;
 515
 516         if ( m_labels )
 517         {
 518             int wLabel;
 519             int hLabel = GetLabelsSize(&wLabel);
 520
 521             // account for the labels
 522             size.x += HGAP + wLabel;
 523
 524             // labels are indented relative to the slider itself
 525             size.y += hLabel;
 526         }
 527     }
 528     else // horizontal
 529     {
 530         size.x = length;
 531         size.y = thumb;
 532         width = &size.y;
 533
 534         if ( m_labels )
 535         {
 536             // labels add extra height
 537             size.y += GetLabelsSize();
 538         }
 539     }
 540
 541     // need extra space to show ticks
 542     if ( HasFlag(wxSL_TICKS) )
 543     {
 544         *width += ticks;
 545
 546         // and maybe twice as much if we show them on both sides
 547         if ( HasFlag(wxSL_BOTH) )
 548             *width += ticks;
 549     }
 550
 551     return size;
 552 }
 553
 554 // ----------------------------------------------------------------------------
 555 // slider-specific methods
 556 // ----------------------------------------------------------------------------
 557
 558 int wxSlider::GetValue() const
 559 {
 560     return ValueInvertOrNot(::SendMessage(GetHwnd(), TBM_GETPOS, 0, 0));
 561 }
 562
 563 void wxSlider::SetValue(int value)
 564 {
 565     ::SendMessage(GetHwnd(), TBM_SETPOS, (WPARAM)TRUE, (LPARAM)ValueInvertOrNot(value));
 566
 567     if ( m_labels )
 568     {
 569         ::SetWindowText((*m_labels)[SliderLabel_Value], Format(value));
 570     }
 571 }
 572
 573 void wxSlider::SetRange(int minValue, int maxValue)
 574 {
 575     m_rangeMin = minValue;
 576     m_rangeMax = maxValue;
 577
 578     ::SendMessage(GetHwnd(), TBM_SETRANGEMIN, TRUE, m_rangeMin);
 579     ::SendMessage(GetHwnd(), TBM_SETRANGEMAX, TRUE, m_rangeMax);
 580
 581     if ( m_labels )
 582     {
 583         ::SetWindowText((*m_labels)[SliderLabel_Min], Format(ValueInvertOrNot(m_rangeMin)));
 584         ::SetWindowText((*m_labels)[SliderLabel_Max], Format(ValueInvertOrNot(m_rangeMax)));
 585     }
 586 }
 587
 588 void wxSlider::SetTickFreq(int n, int pos)
 589 {
 590     m_tickFreq = n;
 591     ::SendMessage( GetHwnd(), TBM_SETTICFREQ, (WPARAM) n, (LPARAM) pos );
 592 }
 593
 594 void wxSlider::SetPageSize(int pageSize)
 595 {
 596     ::SendMessage( GetHwnd(), TBM_SETPAGESIZE, (WPARAM) 0, (LPARAM) pageSize );
 597     m_pageSize = pageSize;
 598 }
 599
 600 int wxSlider::GetPageSize() const
 601 {
 602     return m_pageSize;
 603 }
 604
 605 void wxSlider::ClearSel()
 606 {
 607     ::SendMessage(GetHwnd(), TBM_CLEARSEL, (WPARAM) TRUE, (LPARAM) 0);
 608 }
 609
 610 void wxSlider::ClearTicks()
 611 {
 612     ::SendMessage(GetHwnd(), TBM_CLEARTICS, (WPARAM) TRUE, (LPARAM) 0);
 613 }
 614
 615 void wxSlider::SetLineSize(int lineSize)
 616 {
 617     m_lineSize = lineSize;
 618     ::SendMessage(GetHwnd(), TBM_SETLINESIZE, (WPARAM) 0, (LPARAM) lineSize);
 619 }
 620
 621 int wxSlider::GetLineSize() const
 622 {
 623     return (int)::SendMessage(GetHwnd(), TBM_GETLINESIZE, 0, 0);
 624 }
 625
 626 int wxSlider::GetSelEnd() const
 627 {
 628     return (int)::SendMessage(GetHwnd(), TBM_SETSELEND, 0, 0);
 629 }
 630
 631 int wxSlider::GetSelStart() const
 632 {
 633     return (int)::SendMessage(GetHwnd(), TBM_GETSELSTART, 0, 0);
 634 }
 635
 636 void wxSlider::SetSelection(int minPos, int maxPos)
 637 {
 638     ::SendMessage(GetHwnd(), TBM_SETSEL,
 639                   (WPARAM) TRUE /* redraw */,
 640                   (LPARAM) MAKELONG( minPos, maxPos) );
 641 }
 642
 643 void wxSlider::SetThumbLength(int len)
 644 {
 645     ::SendMessage(GetHwnd(), TBM_SETTHUMBLENGTH, (WPARAM) len, (LPARAM) 0);
 646 }
 647
 648 int wxSlider::GetThumbLength() const
 649 {
 650     return (int)::SendMessage( GetHwnd(), TBM_GETTHUMBLENGTH, 0, 0);
 651 }
 652
 653 void wxSlider::SetTick(int tickPos)
 654 {
 655     ::SendMessage( GetHwnd(), TBM_SETTIC, (WPARAM) 0, (LPARAM) tickPos );
 656 }
 657
 658 // ----------------------------------------------------------------------------
 659 // composite control methods
 660 // ----------------------------------------------------------------------------
 661
 662 WXHWND wxSlider::GetStaticMin() const
 663 {
 664     return m_labels ? (WXHWND)(*m_labels)[SliderLabel_Min] : NULL;
 665 }
 666
 667 WXHWND wxSlider::GetStaticMax() const
 668 {
 669     return m_labels ? (WXHWND)(*m_labels)[SliderLabel_Max] : NULL;
 670 }
 671
 672 WXHWND wxSlider::GetEditValue() const
 673 {
 674     return m_labels ? (WXHWND)(*m_labels)[SliderLabel_Value] : NULL;
 675 }
 676
 677 WX_FORWARD_STD_METHODS_TO_SUBWINDOWS(wxSlider, wxSliderBase, m_labels)
 678
 679 #endif // wxUSE_SLIDER