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