src/univ/slider.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/univ/slider.cpp
   3 // Purpose:     implementation of the universal version of wxSlider
   4 // Author:      Vadim Zeitlin
   5 // Modified by:
   6 // Created:     09.02.01
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 2001 SciTech Software, Inc. (www.scitechsoft.com)
   9 // Licence:     wxWindows licence
  10 ///////////////////////////////////////////////////////////////////////////////
  11
  12 /*
  13    There is some discrepancy in wxSL_LABELS style handling between wxMSW and
  14    wxGTK: the latter handles it natively and shows only the current value of
  15    the slider on the side corresponding to wxSL_TOP/BOTTOM/LEFT/RIGHT style
  16    given (which can be combined with wxSL_HORIZONTAL/VERTICAL) while wxMSW
  17    emulates this somehow and shows the min and max values near the ends of the
  18    slider and the current value in a separate static box nearby.
  19
  20    We currently follow wxGTK except that wxSL_HORIZONTAL slider can only have
  21    the label displayed on top or bottom of it and wxSL_VERTICAL - to the left
  22    or right.
  23
  24    What we really need is probably a more fine grain control on labels, i.e. we
  25    should be able to select if we show nothing at all, the current value only
  26    or the value and the limits - the current approach is just that of the
  27    lowest common denominator.
  28
  29    TODO:
  30
  31   +0. add ticks support
  32    1. support for all orientations
  33    2. draw the slider thumb highlighted when it is dragged
  34   ?3. manual ticks support?
  35  */
  36
  37 // ============================================================================
  38 // declarations
  39 // ============================================================================
  40
  41 // ----------------------------------------------------------------------------
  42 // headers
  43 // ----------------------------------------------------------------------------
  44
  45 #include "wx/wxprec.h"
  46
  47 #ifdef __BORLANDC__
  48     #pragma hdrstop
  49 #endif
  50
  51 #if wxUSE_SLIDER
  52
  53 #include "wx/slider.h"
  54
  55 #ifndef WX_PRECOMP
  56     #include "wx/dc.h"
  57 #endif
  58
  59 #include "wx/univ/renderer.h"
  60 #include "wx/univ/inphand.h"
  61 #include "wx/univ/theme.h"
  62
  63 // ----------------------------------------------------------------------------
  64 // wxStdSliderInputHandler: default slider input handling
  65 // ----------------------------------------------------------------------------
  66
  67 class WXDLLEXPORT wxStdSliderInputHandler : public wxStdInputHandler
  68 {
  69 public:
  70     // default ctor
  71     wxStdSliderInputHandler(wxInputHandler *inphand)
  72         : wxStdInputHandler(inphand)
  73     {
  74     }
  75
  76     // base class methods
  77     virtual bool HandleKey(wxInputConsumer *consumer,
  78                            const wxKeyEvent& event,
  79                            bool pressed);
  80     virtual bool HandleMouse(wxInputConsumer *consumer,
  81                              const wxMouseEvent& event);
  82     virtual bool HandleMouseMove(wxInputConsumer *consumer,
  83                                  const wxMouseEvent& event);
  84
  85     virtual bool HandleFocus(wxInputConsumer *consumer, const wxFocusEvent& event);
  86 };
  87
  88 // ----------------------------------------------------------------------------
  89 // constants
  90 // ----------------------------------------------------------------------------
  91
  92 // the margin between the slider and the label (FIXME: hardcoded)
  93 static const wxCoord SLIDER_LABEL_MARGIN = 2;
  94
  95 // ============================================================================
  96 // implementation of wxSlider
  97 // ============================================================================
  98
  99 BEGIN_EVENT_TABLE(wxSlider, wxControl)
 100     EVT_SIZE(wxSlider::OnSize)
 101 END_EVENT_TABLE()
 102
 103 // ----------------------------------------------------------------------------
 104 // wxSlider creation
 105 // ----------------------------------------------------------------------------
 106
 107 #ifdef __VISUALC__
 108     // warning C4355: 'this' : used in base member initializer list
 109     #pragma warning(disable:4355)
 110 #endif
 111
 112 wxSlider::wxSlider()
 113         : m_thumb(this)
 114 {
 115     Init();
 116 }
 117
 118 wxSlider::wxSlider(wxWindow *parent,
 119                    wxWindowID id,
 120                    int value, int minValue, int maxValue,
 121                    const wxPoint& pos,
 122                    const wxSize& size,
 123                    long style,
 124                    const wxValidator& validator,
 125                    const wxString& name)
 126         : m_thumb(this)
 127 {
 128     Init();
 129
 130     (void)Create(parent, id, value, minValue, maxValue,
 131                  pos, size, style, validator, name);
 132 }
 133
 134 #ifdef __VISUALC__
 135     // warning C4355: 'this' : used in base member initializer list
 136     #pragma warning(default:4355)
 137 #endif
 138
 139 void wxSlider::Init()
 140 {
 141     m_min =
 142     m_max =
 143     m_value = 0;
 144
 145     m_tickFreq = 1;
 146
 147     m_lineSize =
 148     m_pageSize = 0;
 149
 150     m_thumbSize = 0;
 151     m_thumbFlags = 0;
 152 }
 153
 154 bool wxSlider::Create(wxWindow *parent,
 155                       wxWindowID id,
 156                       int value, int minValue, int maxValue,
 157                       const wxPoint& pos,
 158                       const wxSize& size,
 159                       long style,
 160                       const wxValidator& validator,
 161                       const wxString& name)
 162 {
 163     if ( !wxSliderBase::Create(parent, id, pos, size, style,
 164                                validator, name) )
 165         return false;
 166
 167     SetRange(minValue, maxValue);
 168     SetValue(value);
 169
 170     // call this after setting the range as the best size depends (at least if
 171     // we have wxSL_LABELS style) on the range
 172     SetInitialSize(size);
 173
 174     CreateInputHandler(wxINP_HANDLER_SLIDER);
 175
 176     return true;
 177 }
 178
 179 // ----------------------------------------------------------------------------
 180 // wxSlider range and value
 181 // ----------------------------------------------------------------------------
 182
 183 int wxSlider::GetValue() const
 184 {
 185     return m_value;
 186 }
 187
 188 int wxSlider::NormalizeValue(int value) const
 189 {
 190     if ( value < m_min )
 191         return m_min;
 192     else if ( value > m_max )
 193         return m_max;
 194     else
 195         return value;
 196 }
 197
 198 bool wxSlider::ChangeValueBy(int inc)
 199 {
 200     return ChangeValueTo(NormalizeValue(m_value + inc));
 201 }
 202
 203 bool wxSlider::ChangeValueTo(int value)
 204 {
 205     // check if the value is going to change at all
 206     if (value == m_value)
 207         return false;
 208
 209     // this method is protected and we should only call it with normalized
 210     // value!
 211     wxCHECK_MSG( IsInRange(value), false, wxT("invalid slider value") );
 212
 213     m_value = value;
 214
 215     Refresh();
 216
 217     // generate the events: both a specific scroll event and a command event
 218     wxScrollEvent eventScroll(wxEVT_SCROLL_CHANGED, GetId());
 219     eventScroll.SetPosition(m_value);
 220     eventScroll.SetEventObject( this );
 221     (void)GetEventHandler()->ProcessEvent(eventScroll);
 222
 223     wxCommandEvent event(wxEVT_SLIDER, GetId());
 224     event.SetInt(m_value);
 225     event.SetEventObject(this);
 226     (void)GetEventHandler()->ProcessEvent(event);
 227
 228     return true;
 229 }
 230
 231 void wxSlider::SetValue(int value)
 232 {
 233     value = NormalizeValue(value);
 234
 235     if ( m_value != value )
 236     {
 237         m_value = value;
 238
 239         Refresh();
 240     }
 241 }
 242
 243 void wxSlider::SetRange(int minValue, int maxValue)
 244 {
 245     if ( minValue > maxValue )
 246     {
 247         // swap them, we always want min to be less than max
 248         int tmp = minValue;
 249         minValue = maxValue;
 250         maxValue = tmp;
 251     }
 252
 253     if ( m_min != minValue || m_max != maxValue )
 254     {
 255         m_min = minValue;
 256         m_max = maxValue;
 257
 258         // reset the value to make sure it is in the new range
 259         SetValue(m_value);
 260
 261         // the size of the label rect might have changed
 262         if ( HasLabels() )
 263         {
 264             CalcGeometry();
 265         }
 266
 267         Refresh();
 268     }
 269     //else: nothing changed
 270 }
 271
 272 int wxSlider::GetMin() const
 273 {
 274     return m_min;
 275 }
 276
 277 int wxSlider::GetMax() const
 278 {
 279     return m_max;
 280 }
 281
 282 // ----------------------------------------------------------------------------
 283 // wxSlider line/page/thumb size
 284 // ----------------------------------------------------------------------------
 285
 286 void wxSlider::SetLineSize(int lineSize)
 287 {
 288     wxCHECK_RET( lineSize >= 0, wxT("invalid slider line size") );
 289
 290     m_lineSize = lineSize;
 291 }
 292
 293 void wxSlider::SetPageSize(int pageSize)
 294 {
 295     wxCHECK_RET( pageSize >= 0, wxT("invalid slider page size") );
 296
 297     m_pageSize = pageSize;
 298 }
 299
 300 int wxSlider::GetLineSize() const
 301 {
 302     if ( !m_lineSize )
 303     {
 304         // the default line increment is 1
 305         wxConstCast(this, wxSlider)->m_lineSize = 1;
 306     }
 307
 308     return m_lineSize;
 309 }
 310
 311 int wxSlider::GetPageSize() const
 312 {
 313     if ( !m_pageSize )
 314     {
 315         // the default page increment is m_tickFreq
 316         wxConstCast(this, wxSlider)->m_pageSize = m_tickFreq;
 317     }
 318
 319     return m_pageSize;
 320 }
 321
 322 void wxSlider::SetThumbLength(int lenPixels)
 323 {
 324     wxCHECK_RET( lenPixels >= 0, wxT("invalid slider thumb size") );
 325
 326     // use m_thumbSize here directly and not GetThumbLength() to avoid setting
 327     // it to the default value as we don't need it
 328     if ( lenPixels != m_thumbSize )
 329     {
 330         m_thumbSize = lenPixels;
 331
 332         Refresh();
 333     }
 334 }
 335
 336 int wxSlider::GetThumbLength() const
 337 {
 338     wxSize sz = GetDefaultThumbSize();
 339     int len = (IsVert() ? sz.x : sz.y);
 340     if (m_thumbSize > len)
 341     {
 342         return m_thumbSize;
 343     }
 344     else
 345     {
 346         return len;
 347     }
 348
 349 }
 350
 351 // ----------------------------------------------------------------------------
 352 // wxSlider ticks
 353 // ----------------------------------------------------------------------------
 354
 355 void wxSlider::DoSetTickFreq(int n)
 356 {
 357     wxCHECK_RET (n > 0, wxT("invalid slider tick frequency"));
 358
 359     if ( n != m_tickFreq )
 360     {
 361         m_tickFreq = n;
 362
 363         Refresh();
 364     }
 365 }
 366
 367 // ----------------------------------------------------------------------------
 368 // wxSlider geometry
 369 // ----------------------------------------------------------------------------
 370
 371 wxSize wxSlider::CalcLabelSize() const
 372 {
 373     wxSize size;
 374
 375     // there is no sense in trying to calc the labels size if we haven't got
 376     // any, the caller must check for it
 377     wxCHECK_MSG( HasLabels(), size, wxT("shouldn't be called") );
 378
 379     wxCoord w1, h1, w2, h2;
 380     GetTextExtent(FormatValue(m_min), &w1, &h1);
 381     GetTextExtent(FormatValue(m_max), &w2, &h2);
 382
 383     size.x = wxMax(w1, w2);
 384     size.y = wxMax(h1, h2);
 385
 386     return size;
 387 }
 388
 389 wxSize wxSlider::DoGetBestClientSize() const
 390 {
 391     // this dimension is completely arbitrary
 392     static const wxCoord SLIDER_WIDTH = 40;
 393
 394     long style = GetWindowStyle();
 395
 396     // first calculate the size of the slider itself: i.e. the shaft and the
 397     // thumb
 398     wxCoord height = GetRenderer()->GetSliderDim();
 399
 400     wxSize size;
 401     if ( IsVert() )
 402     {
 403         size.x = height;
 404         size.y = SLIDER_WIDTH;
 405     }
 406     else // horizontal
 407     {
 408         size.x = SLIDER_WIDTH;
 409         size.y = height;
 410     }
 411
 412     // add space for ticks
 413     if ( HasTicks() )
 414     {
 415         wxCoord lenTick = GetRenderer()->GetSliderTickLen();
 416         if (style & wxSL_BOTH)
 417         {
 418             lenTick = 2 * lenTick;
 419         }
 420
 421         if ( IsVert() )
 422             size.x += lenTick;
 423         else
 424             size.y += lenTick;
 425     }
 426
 427     // if we have the label, reserve enough space for it
 428     if ( HasLabels() )
 429     {
 430         wxSize sizeLabels = CalcLabelSize();
 431
 432         if (style & (wxSL_LEFT|wxSL_RIGHT))
 433         {
 434             size.x += sizeLabels.x + SLIDER_LABEL_MARGIN;
 435         }
 436         else if (style & (wxSL_TOP|wxSL_BOTTOM))
 437         {
 438             size.y += sizeLabels.y + SLIDER_LABEL_MARGIN;
 439         }
 440     }
 441
 442     return size;
 443 }
 444
 445 void wxSlider::OnSize(wxSizeEvent& event)
 446 {
 447     CalcGeometry();
 448
 449     event.Skip();
 450 }
 451
 452 const wxRect& wxSlider::GetSliderRect() const
 453 {
 454     if ( m_rectSlider.width < 0 )
 455     {
 456         wxConstCast(this, wxSlider)->CalcGeometry();
 457     }
 458
 459     return m_rectSlider;
 460 }
 461
 462 void wxSlider::CalcGeometry()
 463 {
 464     /*
 465        recalc the label and slider positions, this looks like this for
 466        wxSL_HORIZONTAL | wxSL_TOP slider:
 467
 468        LLL             lll
 469        -------------------------
 470        |                T      |  <-- this is the slider rect
 471        | HHHHHHHHHHHHHHHTHHHHH |
 472        |                T      |
 473        | *  *  *  *  *  *  *  *|
 474        -------------------------
 475
 476        LLL is m_rectLabel as calculated here and lll is the real rect used for
 477        label drawing in OnDraw() (TTT indicated the thumb position and *s are
 478        the ticks)
 479
 480        in the wxSL_VERTICAL | wxSL_RIGHT case the picture is like this:
 481
 482        ------ LLL
 483        | H  |
 484        | H *|
 485        | H  |
 486        | H *|
 487        | H  |
 488        | H *|
 489        | H  |
 490        |TTT*| lll
 491        | H  |
 492        | H *|
 493        ------
 494     */
 495     long style = GetWindowStyle();
 496
 497     // initialize to the full client rect
 498     wxRect rectTotal = GetClientRect();
 499     m_rectSlider = rectTotal;
 500     wxSize sizeThumb = GetThumbSize();
 501
 502     // Labels reduce the size of the slider rect
 503     if ( HasLabels() )
 504     {
 505        wxSize sizeLabels = CalcLabelSize();
 506
 507         m_rectLabel = wxRect(rectTotal.GetPosition(), sizeLabels);
 508
 509         if (style & wxSL_TOP)
 510         {
 511             // shrink and offset the slider to the bottom
 512             m_rectSlider.y += sizeLabels.y + SLIDER_LABEL_MARGIN;
 513             m_rectSlider.height -= sizeLabels.y + SLIDER_LABEL_MARGIN;
 514         }
 515         else if (style & wxSL_BOTTOM)
 516         {
 517             // shrink the slider and move the label to the bottom
 518             m_rectSlider.height -= sizeLabels.y + SLIDER_LABEL_MARGIN;
 519             m_rectLabel.y += m_rectSlider.height + SLIDER_LABEL_MARGIN;
 520         }
 521         else if (style & wxSL_LEFT)
 522         {
 523             // shrink and offset the slider to the right
 524             m_rectSlider.x += sizeLabels.x + SLIDER_LABEL_MARGIN;
 525             m_rectSlider.width -= sizeLabels.x + SLIDER_LABEL_MARGIN;
 526         }
 527         else if (style & wxSL_RIGHT)
 528         {
 529             // shrink the slider and move the label to the right
 530             m_rectSlider.width -= sizeLabels.x + SLIDER_LABEL_MARGIN;
 531             m_rectLabel.x += m_rectSlider.width + SLIDER_LABEL_MARGIN;
 532         }
 533     }
 534
 535     // calculate ticks too
 536     if ( HasTicks() )
 537     {
 538         wxCoord lenTick = GetRenderer()->GetSliderTickLen();
 539
 540         // it
 541         m_rectTicks = GetShaftRect();
 542
 543         if ( IsVert() )
 544         {
 545             if (style & (wxSL_LEFT|wxSL_BOTH))
 546             {
 547                 m_rectTicks.x = m_rectSlider.x;
 548             }
 549             else
 550             { // wxSL_RIGHT
 551                 m_rectTicks.x = m_rectSlider.x + m_rectSlider.width - lenTick;
 552             }
 553             m_rectTicks.width = lenTick;
 554         }
 555         else // horizontal
 556         {
 557             if (style & (wxSL_TOP|wxSL_BOTH))
 558             {
 559                 m_rectTicks.y = m_rectSlider.y;
 560             }
 561             else
 562             { // wxSL_BOTTOM
 563                 m_rectTicks.y = m_rectSlider.y + m_rectSlider.height - lenTick;
 564             }
 565             m_rectTicks.height = lenTick;
 566         }
 567     }
 568
 569     // slider is never smaller than thumb size unless rectTotal
 570     if ( IsVert() )
 571     {
 572         wxCoord width = wxMin ( rectTotal.width, sizeThumb.x );
 573         m_rectSlider.width = wxMax ( m_rectSlider.width, width );
 574     }
 575     else
 576     {
 577         wxCoord height = wxMin ( rectTotal.height, sizeThumb.y );
 578         m_rectSlider.height = wxMax ( m_rectSlider.height, height );
 579     }
 580 }
 581
 582 wxSize wxSlider::GetDefaultThumbSize() const
 583 {
 584     // Default size has no styles (arrows)
 585     return GetRenderer()->GetSliderThumbSize(GetSliderRect(), 0, GetOrientation());
 586 }
 587
 588 wxSize wxSlider::GetThumbSize() const
 589 {
 590     return GetRenderer()->GetSliderThumbSize(GetSliderRect(), m_thumbSize, GetOrientation());
 591 }
 592
 593 // ----------------------------------------------------------------------------
 594 // wxSlider thumb geometry
 595 // ----------------------------------------------------------------------------
 596
 597 wxRect wxSlider::GetShaftRect() const
 598 {
 599     return GetRenderer()->GetSliderShaftRect(m_rectSlider, m_thumbSize, GetOrientation(), GetWindowStyle());
 600 }
 601
 602 void wxSlider::CalcThumbRect(const wxRect *rectShaftIn,
 603                              wxRect *rectThumbOut,
 604                              wxRect *rectLabelOut,
 605                              int value) const
 606 {
 607     if ( value == INVALID_THUMB_VALUE )
 608     {
 609         // use the current if not specified
 610         value = m_value;
 611     }
 612
 613     bool isVertical = IsVert();
 614
 615     wxRect rectShaft;
 616     if ( rectShaftIn )
 617     {
 618         rectShaft = *rectShaftIn;
 619     }
 620     else // no shaft rect provided, calc it
 621     {
 622         rectShaft = GetShaftRect();
 623     }
 624
 625     wxCoord lenShaft,
 626             lenThumb;
 627     wxCoord *p;
 628
 629     wxRect rectThumb(rectShaft.GetPosition(), GetThumbSize());
 630     if ( isVertical )
 631     {
 632         rectThumb.x += (rectShaft.width - rectThumb.width) / 2;
 633
 634         lenThumb = rectThumb.height;
 635         lenShaft = rectShaft.height;
 636         p = &rectThumb.y;
 637     }
 638     else // horz
 639     {
 640         rectThumb.y += (rectShaft.height - rectThumb.height) / 2;
 641
 642         lenThumb = rectThumb.width;
 643         lenShaft = rectShaft.width;
 644         p = &rectThumb.x;
 645     }
 646
 647     // the thumb must always be entirely inside the shaft limits, so the max
 648     // position is not at lenShaft but at lenShaft - thumbSize
 649     if ( m_max != m_min )
 650     {
 651         if ( isVertical )
 652         {
 653             *p += ((lenShaft - lenThumb)*(m_max - value))/(m_max - m_min);
 654         }
 655         else
 656         { // horz
 657             *p += ((lenShaft - lenThumb)*(value - m_min))/(m_max - m_min);
 658         }
 659     }
 660
 661     // calc the label rect
 662     if ( HasLabels() && rectLabelOut )
 663     {
 664         long style = GetWindowStyle();
 665         wxRect rectLabel = m_rectLabel;
 666
 667         // centre the label relatively to the thumb position
 668         if (style & (wxSL_TOP|wxSL_BOTTOM))
 669         {
 670             rectLabel.x = rectThumb.x + (rectThumb.width - m_rectLabel.width)/2;
 671         }
 672         else if (style & (wxSL_LEFT|wxSL_RIGHT))
 673         {
 674             rectLabel.y = rectThumb.y + (rectThumb.height - m_rectLabel.height)/2;
 675         }
 676
 677         *rectLabelOut = rectLabel;
 678     }
 679
 680     if ( rectThumbOut )
 681
 682         *rectThumbOut = rectThumb;
 683 }
 684
 685 // ----------------------------------------------------------------------------
 686 // wxSlider drawing
 687 // ----------------------------------------------------------------------------
 688
 689 wxString wxSlider::FormatValue(int value) const
 690 {
 691     return wxString::Format(wxT("%d"), value);
 692 }
 693
 694 void wxSlider::DoDraw(wxControlRenderer *renderer)
 695 {
 696     wxRenderer *rend = GetRenderer();
 697     wxDC& dc = renderer->GetDC();
 698     wxRect rectUpdate = GetUpdateClientRect();
 699
 700     wxOrientation orient = GetOrientation();
 701     int flags = GetStateFlags();
 702     long style = GetWindowStyle();
 703
 704     wxSize sz = GetThumbSize();
 705     int len = IsVert() ? sz.x : sz.y;
 706
 707     // first draw the shaft
 708     wxRect rectShaft = rend->GetSliderShaftRect(m_rectSlider, len, orient, style);
 709     if ( rectUpdate.Intersects(rectShaft) )
 710     {
 711         rend->DrawSliderShaft(dc, m_rectSlider, len, orient, flags, style);
 712     }
 713
 714     // calculate the thumb position in pixels and draw it
 715     wxRect rectThumb, rectLabel;
 716     CalcThumbRect(&rectShaft, &rectThumb, &rectLabel);
 717
 718     // then draw the ticks
 719     if ( HasTicks() && rectUpdate.Intersects(m_rectTicks) )
 720     {
 721         rend->DrawSliderTicks(dc, m_rectSlider, len, orient,
 722                               m_min, m_max, m_tickFreq, flags, style);
 723     }
 724
 725     // then draw the thumb
 726     if ( rectUpdate.Intersects(rectThumb) )
 727     {
 728         rend->DrawSliderThumb(dc, rectThumb, orient, flags | m_thumbFlags, style);
 729     }
 730
 731     // finally, draw the label near the thumb
 732     if ( HasLabels() && rectUpdate.Intersects(rectLabel) )
 733     {
 734         // align it to be close to the shaft
 735         int align = 0;
 736         if (style & wxSL_TOP)
 737         {
 738             align = wxALIGN_CENTRE_HORIZONTAL|wxALIGN_TOP;
 739         }
 740         else if (style & wxSL_BOTTOM)
 741         {
 742             align = wxALIGN_CENTRE_HORIZONTAL|wxALIGN_BOTTOM;
 743         }
 744         else if (style & wxSL_LEFT)
 745         {
 746             align = wxALIGN_CENTRE_VERTICAL|wxALIGN_LEFT;
 747         }
 748         else if (style & wxSL_RIGHT)
 749         {
 750             align = wxALIGN_CENTRE_VERTICAL|wxALIGN_RIGHT;
 751         }
 752
 753         dc.SetFont(GetFont());
 754         dc.SetTextForeground(GetForegroundColour());
 755
 756         // the slider label is never drawn focused
 757         rend->DrawLabel(dc, FormatValue(m_value), rectLabel,
 758                         flags & ~wxCONTROL_FOCUSED, align);
 759     }
 760 }
 761
 762 // ----------------------------------------------------------------------------
 763 // wxSlider input processing
 764 // ----------------------------------------------------------------------------
 765
 766 bool wxSlider::PerformAction(const wxControlAction& action,
 767                              long numArg,
 768                              const wxString& strArg)
 769 {
 770     wxEventType scrollEvent = wxEVT_NULL;
 771     int value;
 772     bool valueChanged = true;
 773
 774     if ( action == wxACTION_SLIDER_START )
 775     {
 776         scrollEvent = wxEVT_SCROLL_TOP;
 777         value = m_min;
 778     }
 779     else if ( action == wxACTION_SLIDER_END )
 780     {
 781         scrollEvent = wxEVT_SCROLL_BOTTOM;
 782         value = m_max;
 783     }
 784     else if ( action == wxACTION_SLIDER_PAGE_CHANGE )
 785     {
 786         value = NormalizeValue(m_value + numArg * GetPageSize());
 787     }
 788     else if ( action == wxACTION_SLIDER_LINE_UP )
 789     {
 790         scrollEvent = wxEVT_SCROLL_LINEUP;
 791         value = NormalizeValue(m_value + +GetLineSize());
 792     }
 793     else if ( action == wxACTION_SLIDER_LINE_DOWN )
 794     {
 795         scrollEvent = wxEVT_SCROLL_LINEDOWN;
 796         value = NormalizeValue(m_value + -GetLineSize());
 797     }
 798     else if ( action == wxACTION_SLIDER_PAGE_UP )
 799     {
 800         scrollEvent = wxEVT_SCROLL_PAGEUP;
 801         value = NormalizeValue(m_value + +GetPageSize());
 802     }
 803     else if ( action == wxACTION_SLIDER_PAGE_DOWN )
 804     {
 805         scrollEvent = wxEVT_SCROLL_PAGEDOWN;
 806         value = NormalizeValue(m_value + -GetPageSize());
 807     }
 808     else if ( action == wxACTION_SLIDER_THUMB_DRAG ||
 809                 action == wxACTION_SLIDER_THUMB_MOVE )
 810     {
 811         scrollEvent = wxEVT_SCROLL_THUMBTRACK;
 812
 813         // we shouldn't generate a command event about this change but we still
 814         // should update our value and the slider appearance
 815         valueChanged = false;
 816         m_value =
 817         value = (int)numArg;
 818         Refresh();
 819     }
 820     else if ( action == wxACTION_SLIDER_THUMB_RELEASE )
 821     {
 822         scrollEvent = wxEVT_SCROLL_THUMBRELEASE;
 823         value = (int)numArg;
 824     }
 825     else
 826     {
 827         return wxControl::PerformAction(action, numArg, strArg);
 828     }
 829
 830     // update wxSlider current value and generate wxCommandEvent, except while
 831     // dragging the thumb
 832     if ( valueChanged )
 833         ChangeValueTo(value);
 834
 835     // also generate more precise wxScrollEvent if applicable
 836     if ( scrollEvent != wxEVT_NULL )
 837     {
 838         wxScrollEvent event(scrollEvent, GetId());
 839         event.SetPosition(value);
 840         event.SetEventObject( this );
 841         GetEventHandler()->ProcessEvent(event);
 842     }
 843
 844     return true;
 845 }
 846
 847 /* static */
 848 wxInputHandler *wxSlider::GetStdInputHandler(wxInputHandler *handlerDef)
 849 {
 850     static wxStdSliderInputHandler s_handler(handlerDef);
 851
 852     return &s_handler;
 853 }
 854
 855 // ----------------------------------------------------------------------------
 856 // wxSlider implementation of wxControlWithThumb interface
 857 // ----------------------------------------------------------------------------
 858
 859 wxScrollThumb::Shaft wxSlider::HitTest(const wxPoint& pt) const
 860 {
 861     wxRect rectShaft = GetShaftRect();
 862     wxRect rectThumb;
 863     CalcThumbRect(&rectShaft, &rectThumb, NULL);
 864
 865     // check for possible shaft or thumb hit
 866     if (!rectShaft.Contains(pt) && !rectThumb.Contains(pt))
 867     {
 868         return wxScrollThumb::Shaft_None;
 869     }
 870
 871     // the position to test and the start and end of the thumb
 872     wxCoord x, x1, x2, x3, x4;
 873     if (IsVert())
 874     {
 875         x = pt.y;
 876         x1 = rectThumb.GetBottom();
 877         x2 = rectShaft.GetBottom();
 878         x3 = rectShaft.GetTop();
 879         x4 = rectThumb.GetTop();
 880     }
 881     else
 882     { // horz
 883         x = pt.x;
 884         x1 = rectShaft.GetLeft();
 885         x2 = rectThumb.GetLeft();
 886         x3 = rectThumb.GetRight();
 887         x4 = rectShaft.GetRight();
 888     }
 889     if ((x1 <= x) && (x < x2))
 890     {
 891         // or to the left
 892         return wxScrollThumb::Shaft_Above;
 893     }
 894
 895     if ((x3 < x) && (x <= x4)) {
 896         // or to the right
 897         return wxScrollThumb::Shaft_Below;
 898     }
 899
 900     // where else can it be?
 901     return wxScrollThumb::Shaft_Thumb;
 902 }
 903
 904 wxCoord wxSlider::ThumbPosToPixel() const
 905 {
 906     wxRect rectThumb;
 907     CalcThumbRect(NULL, &rectThumb, NULL);
 908
 909     return IsVert() ? rectThumb.y : rectThumb.x;
 910 }
 911
 912 int wxSlider::PixelToThumbPos(wxCoord x) const
 913 {
 914     wxRect rectShaft = GetShaftRect();
 915     wxSize sizeThumb = GetThumbSize();
 916
 917     wxCoord x0, len;
 918     if ( IsVert() )
 919     {
 920         x0 = rectShaft.y;
 921         len = rectShaft.height - sizeThumb.y;
 922     }
 923     else // horz
 924     {
 925         x0 = rectShaft.x;
 926         len = rectShaft.width - sizeThumb.x;
 927     }
 928
 929     int pos = m_min;
 930     if ( len > 0 )
 931     {
 932         if ( x > x0 )
 933         {
 934             pos += ((x - x0) * (m_max - m_min)) / len;
 935             if ( pos > m_max )
 936                 pos = m_max;
 937         }
 938         //else: x <= x0, leave pos = min
 939     }
 940
 941     return pos;
 942 }
 943
 944 void wxSlider::SetShaftPartState(wxScrollThumb::Shaft shaftPart,
 945                                  int flag,
 946                                  bool set)
 947 {
 948     // for now we ignore the flags for the shaft as no renderer uses them
 949     // anyhow
 950     if ( shaftPart == wxScrollThumb::Shaft_Thumb )
 951     {
 952         if ( set )
 953             m_thumbFlags |= flag;
 954         else
 955             m_thumbFlags &= ~flag;
 956
 957         Refresh();
 958     }
 959 }
 960
 961 void wxSlider::OnThumbDragStart(int pos)
 962 {
 963     if (IsVert())
 964     {
 965         PerformAction(wxACTION_SLIDER_THUMB_DRAG, m_max - pos);
 966     }
 967     else
 968     {
 969         PerformAction(wxACTION_SLIDER_THUMB_DRAG, pos);
 970     }
 971 }
 972
 973 void wxSlider::OnThumbDrag(int pos)
 974 {
 975     if (IsVert())
 976     {
 977         PerformAction(wxACTION_SLIDER_THUMB_MOVE, m_max - pos);
 978     }
 979     else
 980     {
 981         PerformAction(wxACTION_SLIDER_THUMB_MOVE, pos);
 982     }
 983 }
 984
 985 void wxSlider::OnThumbDragEnd(int pos)
 986 {
 987     if (IsVert())
 988     {
 989         PerformAction(wxACTION_SLIDER_THUMB_RELEASE, m_max - pos);
 990     }
 991     else
 992     {
 993         PerformAction(wxACTION_SLIDER_THUMB_RELEASE, pos);
 994     }
 995 }
 996
 997 void wxSlider::OnPageScrollStart()
 998 {
 999     // we do nothing here
1000 }
1001
1002 bool wxSlider::OnPageScroll(int pageInc)
1003 {
1004     int value = GetValue();
1005     PerformAction(wxACTION_SLIDER_PAGE_CHANGE, pageInc);
1006
1007     return GetValue() != value;
1008 }
1009
1010 // ----------------------------------------------------------------------------
1011 // wxStdSliderInputHandler
1012 // ----------------------------------------------------------------------------
1013
1014 bool wxStdSliderInputHandler::HandleKey(wxInputConsumer *consumer,
1015                                               const wxKeyEvent& event,
1016                                               bool pressed)
1017 {
1018     if ( pressed )
1019     {
1020         int keycode = event.GetKeyCode();
1021
1022         wxControlAction action;
1023         switch ( keycode )
1024         {
1025             case WXK_HOME:
1026                 action = wxACTION_SLIDER_END;
1027                 break;
1028
1029             case WXK_END:
1030                 action = wxACTION_SLIDER_START;
1031                 break;
1032
1033             case WXK_RIGHT:
1034             case WXK_UP:
1035                 action = wxACTION_SLIDER_LINE_UP;
1036                 break;
1037
1038             case WXK_LEFT:
1039             case WXK_DOWN:
1040                 action = wxACTION_SLIDER_LINE_DOWN;
1041                 break;
1042
1043             case WXK_PAGEUP:
1044                 action = wxACTION_SLIDER_PAGE_UP;
1045                 break;
1046
1047             case WXK_PAGEDOWN:
1048                 action = wxACTION_SLIDER_PAGE_DOWN;
1049                 break;
1050         }
1051
1052         if ( !action.IsEmpty() )
1053         {
1054             consumer->PerformAction(action);
1055
1056             return true;
1057         }
1058     }
1059
1060     return wxStdInputHandler::HandleKey(consumer, event, pressed);
1061 }
1062
1063 bool wxStdSliderInputHandler::HandleMouse(wxInputConsumer *consumer,
1064                                                 const wxMouseEvent& event)
1065 {
1066     wxSlider *slider = wxStaticCast(consumer->GetInputWindow(), wxSlider);
1067
1068     if ( slider->GetThumb().HandleMouse(event) )
1069     {
1070         // processed by the thumb
1071         return false;
1072     }
1073
1074     return wxStdInputHandler::HandleMouse(consumer, event);
1075 }
1076
1077 bool wxStdSliderInputHandler::HandleMouseMove(wxInputConsumer *consumer,
1078                                                     const wxMouseEvent& event)
1079 {
1080     wxSlider *slider = wxStaticCast(consumer->GetInputWindow(), wxSlider);
1081
1082     if ( slider->GetThumb().HandleMouseMove(event) )
1083     {
1084         // processed by the thumb
1085         return false;
1086     }
1087
1088     return wxStdInputHandler::HandleMouseMove(consumer, event);
1089 }
1090
1091 bool
1092 wxStdSliderInputHandler::HandleFocus(wxInputConsumer * WXUNUSED(consumer),
1093                                            const wxFocusEvent& WXUNUSED(event))
1094 {
1095     // slider appearance changes when it gets/loses focus
1096     return true;
1097 }
1098
1099 #endif // wxUSE_SLIDER