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