samples/widgets/slider.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Program:     wxWidgets Widgets Sample
   3 // Name:        slider.cpp
   4 // Purpose:     Part of the widgets sample showing wxSlider
   5 // Author:      Vadim Zeitlin
   6 // Created:     16.04.01
   7 // Id:          $Id$
   8 // Copyright:   (c) 2001 Vadim Zeitlin
   9 // License:     wxWindows license
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 // for compilers that support precompilation, includes "wx/wx.h".
  21 #include "wx/wxprec.h"
  22
  23 #ifdef __BORLANDC__
  24     #pragma hdrstop
  25 #endif
  26
  27 #if wxUSE_SLIDER
  28
  29 // for all others, include the necessary headers
  30 #ifndef WX_PRECOMP
  31     #include "wx/log.h"
  32
  33     #include "wx/bitmap.h"
  34     #include "wx/button.h"
  35     #include "wx/checkbox.h"
  36     #include "wx/radiobox.h"
  37     #include "wx/slider.h"
  38     #include "wx/statbox.h"
  39     #include "wx/textctrl.h"
  40 #endif
  41
  42 #if wxUSE_TOOLTIPS
  43     #include "wx/tooltip.h"
  44 #endif
  45
  46 #include "wx/sizer.h"
  47
  48 #include "widgets.h"
  49
  50 #include "icons/slider.xpm"
  51
  52 // ----------------------------------------------------------------------------
  53 // constants
  54 // ----------------------------------------------------------------------------
  55
  56 // control ids
  57 enum
  58 {
  59     SliderPage_Reset = wxID_HIGHEST,
  60     SliderPage_Clear,
  61     SliderPage_SetValue,
  62     SliderPage_SetMinAndMax,
  63     SliderPage_SetLineSize,
  64     SliderPage_SetPageSize,
  65     SliderPage_SetTickFreq,
  66     SliderPage_SetThumbLen,
  67     SliderPage_CurValueText,
  68     SliderPage_ValueText,
  69     SliderPage_MinText,
  70     SliderPage_MaxText,
  71     SliderPage_LineSizeText,
  72     SliderPage_PageSizeText,
  73     SliderPage_TickFreqText,
  74     SliderPage_ThumbLenText,
  75     SliderPage_RadioSides,
  76     SliderPage_BothSides,
  77     SliderPage_Slider
  78 };
  79
  80 // sides radiobox values
  81 enum
  82 {
  83     SliderTicks_Top,
  84     SliderTicks_Bottom,
  85     SliderTicks_Left,
  86     SliderTicks_Right
  87 };
  88
  89 // ----------------------------------------------------------------------------
  90 // SliderWidgetsPage
  91 // ----------------------------------------------------------------------------
  92
  93 class SliderWidgetsPage : public WidgetsPage
  94 {
  95 public:
  96     SliderWidgetsPage(WidgetsBookCtrl *book, wxImageList *imaglist);
  97     virtual ~SliderWidgetsPage(){};
  98
  99     virtual wxControl *GetWidget() const { return m_slider; }
 100     virtual void RecreateWidget() { CreateSlider(); }
 101
 102     // lazy creation of the content
 103     virtual void CreateContent();
 104
 105 protected:
 106     // event handlers
 107     void OnButtonReset(wxCommandEvent& event);
 108     void OnButtonClear(wxCommandEvent& event);
 109     void OnButtonSetValue(wxCommandEvent& event);
 110     void OnButtonSetMinAndMax(wxCommandEvent& event);
 111     void OnButtonSetLineSize(wxCommandEvent& event);
 112     void OnButtonSetPageSize(wxCommandEvent& event);
 113     void OnButtonSetTickFreq(wxCommandEvent& event);
 114     void OnButtonSetThumbLen(wxCommandEvent& event);
 115
 116     void OnCheckOrRadioBox(wxCommandEvent& event);
 117
 118     void OnSlider(wxScrollEvent& event);
 119
 120     void OnUpdateUIValueButton(wxUpdateUIEvent& event);
 121     void OnUpdateUIMinMaxButton(wxUpdateUIEvent& event);
 122     void OnUpdateUILineSize(wxUpdateUIEvent& event);
 123     void OnUpdateUIPageSize(wxUpdateUIEvent& event);
 124     void OnUpdateUITickFreq(wxUpdateUIEvent& event);
 125     void OnUpdateUIThumbLen(wxUpdateUIEvent& event);
 126     void OnUpdateUIRadioSides(wxUpdateUIEvent& event);
 127     void OnUpdateUIBothSides(wxUpdateUIEvent& event);
 128
 129     void OnUpdateUIResetButton(wxUpdateUIEvent& event);
 130
 131     void OnUpdateUICurValueText(wxUpdateUIEvent& event);
 132
 133     // reset the slider parameters
 134     void Reset();
 135
 136     // (re)create the slider
 137     void CreateSlider();
 138
 139     // set the line size from the text field value
 140     void DoSetLineSize();
 141
 142     // set the page size from the text field value
 143     void DoSetPageSize();
 144
 145     // set the tick frequency from the text field value
 146     void DoSetTickFreq();
 147
 148     // set the thumb len from the text field value
 149     void DoSetThumbLen();
 150
 151     // is this slider value in range?
 152     bool IsValidValue(int val) const
 153         { return (val >= m_min) && (val <= m_max); }
 154
 155     // the slider range
 156     int m_min, m_max;
 157
 158     // the controls
 159     // ------------
 160
 161     // the check/radio boxes for styles
 162     wxCheckBox *m_chkLabels,
 163                *m_chkInverse,
 164                *m_chkTicks,
 165                *m_chkBothSides;
 166
 167     wxRadioBox *m_radioSides;
 168
 169     // the slider itself and the sizer it is in
 170     wxSlider *m_slider;
 171     wxSizer *m_sizerSlider;
 172
 173     // the text entries for set value/range
 174     wxTextCtrl *m_textValue,
 175                *m_textMin,
 176                *m_textMax,
 177                *m_textLineSize,
 178                *m_textPageSize,
 179                *m_textTickFreq,
 180                *m_textThumbLen;
 181
 182 private:
 183     DECLARE_EVENT_TABLE()
 184     DECLARE_WIDGETS_PAGE(SliderWidgetsPage)
 185 };
 186
 187 // ----------------------------------------------------------------------------
 188 // event tables
 189 // ----------------------------------------------------------------------------
 190
 191 BEGIN_EVENT_TABLE(SliderWidgetsPage, WidgetsPage)
 192     EVT_BUTTON(SliderPage_Reset, SliderWidgetsPage::OnButtonReset)
 193     EVT_BUTTON(SliderPage_SetValue, SliderWidgetsPage::OnButtonSetValue)
 194     EVT_BUTTON(SliderPage_SetMinAndMax, SliderWidgetsPage::OnButtonSetMinAndMax)
 195     EVT_BUTTON(SliderPage_SetLineSize, SliderWidgetsPage::OnButtonSetLineSize)
 196     EVT_BUTTON(SliderPage_SetPageSize, SliderWidgetsPage::OnButtonSetPageSize)
 197     EVT_BUTTON(SliderPage_SetTickFreq, SliderWidgetsPage::OnButtonSetTickFreq)
 198     EVT_BUTTON(SliderPage_SetThumbLen, SliderWidgetsPage::OnButtonSetThumbLen)
 199
 200     EVT_UPDATE_UI(SliderPage_SetValue, SliderWidgetsPage::OnUpdateUIValueButton)
 201     EVT_UPDATE_UI(SliderPage_SetMinAndMax, SliderWidgetsPage::OnUpdateUIMinMaxButton)
 202     EVT_UPDATE_UI(SliderPage_SetLineSize, SliderWidgetsPage::OnUpdateUILineSize)
 203     EVT_UPDATE_UI(SliderPage_SetPageSize, SliderWidgetsPage::OnUpdateUIPageSize)
 204     EVT_UPDATE_UI(SliderPage_SetTickFreq, SliderWidgetsPage::OnUpdateUITickFreq)
 205     EVT_UPDATE_UI(SliderPage_SetThumbLen, SliderWidgetsPage::OnUpdateUIThumbLen)
 206     EVT_UPDATE_UI(SliderPage_RadioSides, SliderWidgetsPage::OnUpdateUIRadioSides)
 207     EVT_UPDATE_UI(SliderPage_BothSides, SliderWidgetsPage::OnUpdateUIBothSides)
 208
 209     EVT_UPDATE_UI(SliderPage_Reset, SliderWidgetsPage::OnUpdateUIResetButton)
 210
 211     EVT_UPDATE_UI(SliderPage_CurValueText, SliderWidgetsPage::OnUpdateUICurValueText)
 212
 213     EVT_COMMAND_SCROLL(SliderPage_Slider, SliderWidgetsPage::OnSlider)
 214
 215     EVT_CHECKBOX(wxID_ANY, SliderWidgetsPage::OnCheckOrRadioBox)
 216     EVT_RADIOBOX(wxID_ANY, SliderWidgetsPage::OnCheckOrRadioBox)
 217 END_EVENT_TABLE()
 218
 219 // ============================================================================
 220 // implementation
 221 // ============================================================================
 222
 223 #if defined(__WXUNIVERSAL__)
 224     #define FAMILY_CTRLS UNIVERSAL_CTRLS
 225 #else
 226     #define FAMILY_CTRLS NATIVE_CTRLS
 227 #endif
 228
 229 IMPLEMENT_WIDGETS_PAGE(SliderWidgetsPage, _T("Slider"), FAMILY_CTRLS );
 230
 231 SliderWidgetsPage::SliderWidgetsPage(WidgetsBookCtrl *book,
 232                                      wxImageList *imaglist)
 233                   : WidgetsPage(book, imaglist, slider_xpm)
 234 {
 235     // init everything
 236     m_min = 0;
 237     m_max = 100;
 238
 239     m_chkInverse =
 240     m_chkTicks =
 241     m_chkLabels =
 242     m_chkBothSides = (wxCheckBox *)NULL;
 243
 244     m_radioSides = (wxRadioBox *)NULL;
 245
 246     m_slider = (wxSlider *)NULL;
 247     m_sizerSlider = (wxSizer *)NULL;
 248 }
 249
 250 void SliderWidgetsPage::CreateContent()
 251 {
 252     wxSizer *sizerTop = new wxBoxSizer(wxHORIZONTAL);
 253
 254     // left pane
 255     wxStaticBox *box = new wxStaticBox(this, wxID_ANY, _T("&Set style"));
 256     wxSizer *sizerLeft = new wxStaticBoxSizer(box, wxVERTICAL);
 257
 258     m_chkInverse = CreateCheckBoxAndAddToSizer(sizerLeft, _T("&Inverse"));
 259     m_chkTicks = CreateCheckBoxAndAddToSizer(sizerLeft, _T("Show &ticks"));
 260     m_chkLabels = CreateCheckBoxAndAddToSizer(sizerLeft, _T("Show &labels"));
 261     static const wxString sides[] =
 262     {
 263         _T("top"),
 264         _T("bottom"),
 265         _T("left"),
 266         _T("right"),
 267     };
 268     m_radioSides = new wxRadioBox(this, SliderPage_RadioSides, _T("&Ticks/Labels"),
 269                                  wxDefaultPosition, wxDefaultSize,
 270                                  WXSIZEOF(sides), sides,
 271                                  1, wxRA_SPECIFY_COLS);
 272     sizerLeft->Add(m_radioSides, 0, wxGROW | wxALL, 5);
 273     m_chkBothSides = CreateCheckBoxAndAddToSizer
 274                      (sizerLeft, _T("&Both sides"), SliderPage_BothSides);
 275 #if wxUSE_TOOLTIPS
 276     m_chkBothSides->SetToolTip( _T("\"Both sides\" is only supported \nin Win95 and Universal") );
 277 #endif // wxUSE_TOOLTIPS
 278
 279     sizerLeft->Add(5, 5, 0, wxGROW | wxALL, 5); // spacer
 280
 281     wxButton *btn = new wxButton(this, SliderPage_Reset, _T("&Reset"));
 282     sizerLeft->Add(btn, 0, wxALIGN_CENTRE_HORIZONTAL | wxALL, 15);
 283
 284     // middle pane
 285     wxStaticBox *box2 = new wxStaticBox(this, wxID_ANY, _T("&Change slider value"));
 286     wxSizer *sizerMiddle = new wxStaticBoxSizer(box2, wxVERTICAL);
 287
 288     wxTextCtrl *text;
 289     wxSizer *sizerRow = CreateSizerWithTextAndLabel(_T("Current value"),
 290                                                     SliderPage_CurValueText,
 291                                                     &text);
 292     text->SetEditable(false);
 293
 294     sizerMiddle->Add(sizerRow, 0, wxALL | wxGROW, 5);
 295
 296     sizerRow = CreateSizerWithTextAndButton(SliderPage_SetValue,
 297                                             _T("Set &value"),
 298                                             SliderPage_ValueText,
 299                                             &m_textValue);
 300     sizerMiddle->Add(sizerRow, 0, wxALL | wxGROW, 5);
 301
 302     sizerRow = CreateSizerWithTextAndButton(SliderPage_SetMinAndMax,
 303                                             _T("&Min and max"),
 304                                             SliderPage_MinText,
 305                                             &m_textMin);
 306
 307     m_textMax = new wxTextCtrl(this, SliderPage_MaxText, wxEmptyString);
 308     sizerRow->Add(m_textMax, 1, wxLEFT | wxALIGN_CENTRE_VERTICAL, 5);
 309
 310     m_textMin->SetValue( wxString::Format(_T("%d"), m_min) );
 311     m_textMax->SetValue( wxString::Format(_T("%d"), m_max) );
 312
 313     sizerMiddle->Add(sizerRow, 0, wxALL | wxGROW, 5);
 314
 315     sizerRow = CreateSizerWithTextAndButton(SliderPage_SetLineSize,
 316                                             _T("Li&ne size"),
 317                                             SliderPage_LineSizeText,
 318                                             &m_textLineSize);
 319
 320     sizerMiddle->Add(sizerRow, 0, wxALL | wxGROW, 5);
 321
 322     sizerRow = CreateSizerWithTextAndButton(SliderPage_SetPageSize,
 323                                             _T("P&age size"),
 324                                             SliderPage_PageSizeText,
 325                                             &m_textPageSize);
 326
 327     sizerMiddle->Add(sizerRow, 0, wxALL | wxGROW, 5);
 328
 329     sizerRow = CreateSizerWithTextAndButton(SliderPage_SetTickFreq,
 330                                             _T("Tick &frequency"),
 331                                             SliderPage_TickFreqText,
 332                                             &m_textTickFreq);
 333
 334     m_textTickFreq->SetValue(_T("10"));
 335
 336     sizerMiddle->Add(sizerRow, 0, wxALL | wxGROW, 5);
 337
 338     sizerRow = CreateSizerWithTextAndButton(SliderPage_SetThumbLen,
 339                                             _T("Thumb &length"),
 340                                             SliderPage_ThumbLenText,
 341                                             &m_textThumbLen);
 342
 343     sizerMiddle->Add(sizerRow, 0, wxALL | wxGROW, 5);
 344
 345     // right pane
 346     wxSizer *sizerRight = new wxBoxSizer(wxHORIZONTAL);
 347     sizerRight->SetMinSize(150, 40);
 348     m_sizerSlider = sizerRight; // save it to modify it later
 349
 350     Reset();
 351     CreateSlider();
 352
 353     m_textLineSize->SetValue(wxString::Format(_T("%d"), m_slider->GetLineSize()));
 354     m_textPageSize->SetValue(wxString::Format(_T("%d"), m_slider->GetPageSize()));
 355
 356     // the 3 panes panes compose the window
 357     sizerTop->Add(sizerLeft, 0, wxGROW | (wxALL & ~wxLEFT), 10);
 358     sizerTop->Add(sizerMiddle, 0, wxGROW | wxALL, 10);
 359     sizerTop->Add(sizerRight, 1, wxGROW | (wxALL & ~wxRIGHT), 10);
 360
 361     // final initializations
 362     SetSizer(sizerTop);
 363 }
 364
 365 // ----------------------------------------------------------------------------
 366 // operations
 367 // ----------------------------------------------------------------------------
 368
 369 void SliderWidgetsPage::Reset()
 370 {
 371     m_chkInverse->SetValue(false);
 372     m_chkTicks->SetValue(true);
 373     m_chkLabels->SetValue(true);
 374     m_chkBothSides->SetValue(false);
 375
 376     m_radioSides->SetSelection(SliderTicks_Top);
 377 }
 378
 379 void SliderWidgetsPage::CreateSlider()
 380 {
 381     int flags = ms_defaultFlags;
 382
 383     if ( m_chkInverse->GetValue() )
 384     {
 385         flags |= wxSL_INVERSE;
 386     }
 387
 388     if ( m_chkLabels->GetValue() )
 389     {
 390         flags |= wxSL_LABELS;
 391     }
 392
 393     if ( m_chkTicks->GetValue() )
 394     {
 395         flags |= wxSL_AUTOTICKS;
 396     }
 397
 398     switch ( m_radioSides->GetSelection() )
 399     {
 400         case SliderTicks_Top:
 401             flags |= wxSL_TOP;
 402             break;
 403
 404         case SliderTicks_Left:
 405             flags |= wxSL_LEFT;
 406             break;
 407
 408         case SliderTicks_Bottom:
 409             flags |= wxSL_BOTTOM;
 410             break;
 411
 412         case SliderTicks_Right:
 413             flags |= wxSL_RIGHT;
 414             break;
 415
 416         default:
 417             wxFAIL_MSG(_T("unexpected radiobox selection"));
 418             // fall through
 419     }
 420
 421     if ( m_chkBothSides->GetValue() )
 422     {
 423         flags |= wxSL_BOTH;
 424     }
 425
 426     int val = m_min;
 427     if ( m_slider )
 428     {
 429         int valOld = m_slider->GetValue();
 430         if ( !IsValidValue(valOld) )
 431         {
 432             val = valOld;
 433         }
 434
 435         m_sizerSlider->Detach( m_slider );
 436
 437         if ( m_sizerSlider->GetChildren().GetCount() )
 438         {
 439             // we have 2 spacers, remove them too
 440             m_sizerSlider->Remove( 0 );
 441             m_sizerSlider->Remove( 0 );
 442         }
 443
 444         delete m_slider;
 445     }
 446
 447     m_slider = new wxSlider(this, SliderPage_Slider,
 448                             val, m_min, m_max,
 449                             wxDefaultPosition, wxDefaultSize,
 450                             flags);
 451
 452     if ( m_slider->HasFlag(wxSL_VERTICAL) )
 453     {
 454         m_sizerSlider->Add(0, 0, 1);
 455         m_sizerSlider->Add(m_slider, 0, wxGROW | wxALL, 5);
 456         m_sizerSlider->Add(0, 0, 1);
 457     }
 458     else
 459     {
 460         m_sizerSlider->Add(m_slider, 1, wxCENTRE | wxALL, 5);
 461     }
 462
 463     if ( m_chkTicks->GetValue() )
 464     {
 465         DoSetTickFreq();
 466     }
 467
 468     m_sizerSlider->Layout();
 469 }
 470
 471 void SliderWidgetsPage::DoSetLineSize()
 472 {
 473     long lineSize;
 474     if ( !m_textLineSize->GetValue().ToLong(&lineSize) )
 475     {
 476         wxLogWarning(_T("Invalid slider line size"));
 477
 478         return;
 479     }
 480
 481     m_slider->SetLineSize(lineSize);
 482
 483     if ( m_slider->GetLineSize() != lineSize )
 484     {
 485         wxLogWarning(_T("Invalid line size in slider."));
 486     }
 487 }
 488
 489 void SliderWidgetsPage::DoSetPageSize()
 490 {
 491     long pageSize;
 492     if ( !m_textPageSize->GetValue().ToLong(&pageSize) )
 493     {
 494         wxLogWarning(_T("Invalid slider page size"));
 495
 496         return;
 497     }
 498
 499     m_slider->SetPageSize(pageSize);
 500
 501     if ( m_slider->GetPageSize() != pageSize )
 502     {
 503         wxLogWarning(_T("Invalid page size in slider."));
 504     }
 505 }
 506
 507 void SliderWidgetsPage::DoSetTickFreq()
 508 {
 509     long freq;
 510     if ( !m_textTickFreq->GetValue().ToLong(&freq) )
 511     {
 512         wxLogWarning(_T("Invalid slider tick frequency"));
 513
 514         return;
 515     }
 516
 517     m_slider->SetTickFreq(freq, 0 /* unused */);
 518 }
 519
 520 void SliderWidgetsPage::DoSetThumbLen()
 521 {
 522     long len;
 523     if ( !m_textThumbLen->GetValue().ToLong(&len) )
 524     {
 525         wxLogWarning(_T("Invalid slider thumb length"));
 526
 527         return;
 528     }
 529
 530     m_slider->SetThumbLength(len);
 531 }
 532
 533 // ----------------------------------------------------------------------------
 534 // event handlers
 535 // ----------------------------------------------------------------------------
 536
 537 void SliderWidgetsPage::OnButtonReset(wxCommandEvent& WXUNUSED(event))
 538 {
 539     Reset();
 540
 541     CreateSlider();
 542 }
 543
 544 void SliderWidgetsPage::OnButtonSetLineSize(wxCommandEvent& WXUNUSED(event))
 545 {
 546     DoSetLineSize();
 547 }
 548
 549 void SliderWidgetsPage::OnButtonSetPageSize(wxCommandEvent& WXUNUSED(event))
 550 {
 551     DoSetPageSize();
 552 }
 553
 554 void SliderWidgetsPage::OnButtonSetTickFreq(wxCommandEvent& WXUNUSED(event))
 555 {
 556     DoSetTickFreq();
 557 }
 558
 559 void SliderWidgetsPage::OnButtonSetThumbLen(wxCommandEvent& WXUNUSED(event))
 560 {
 561     DoSetThumbLen();
 562 }
 563
 564 void SliderWidgetsPage::OnButtonSetMinAndMax(wxCommandEvent& WXUNUSED(event))
 565 {
 566     long minNew,
 567          maxNew = 0; // init to suppress compiler warning
 568     if ( !m_textMin->GetValue().ToLong(&minNew) ||
 569          !m_textMax->GetValue().ToLong(&maxNew) ||
 570          minNew >= maxNew )
 571     {
 572         wxLogWarning(_T("Invalid min/max values for the slider."));
 573
 574         return;
 575     }
 576
 577     m_min = minNew;
 578     m_max = maxNew;
 579
 580     m_slider->SetRange(minNew, maxNew);
 581
 582     if ( m_slider->GetMin() != m_min ||
 583          m_slider->GetMax() != m_max )
 584     {
 585         wxLogWarning(_T("Invalid range in slider."));
 586     }
 587 }
 588
 589 void SliderWidgetsPage::OnButtonSetValue(wxCommandEvent& WXUNUSED(event))
 590 {
 591     long val;
 592     if ( !m_textValue->GetValue().ToLong(&val) || !IsValidValue(val) )
 593     {
 594         wxLogWarning(_T("Invalid slider value."));
 595
 596         return;
 597     }
 598
 599     m_slider->SetValue(val);
 600 }
 601
 602 void SliderWidgetsPage::OnUpdateUIValueButton(wxUpdateUIEvent& event)
 603 {
 604     long val;
 605     event.Enable( m_textValue->GetValue().ToLong(&val) && IsValidValue(val) );
 606 }
 607
 608 void SliderWidgetsPage::OnUpdateUILineSize(wxUpdateUIEvent& event)
 609 {
 610     long lineSize;
 611     event.Enable( m_textLineSize->GetValue().ToLong(&lineSize) &&
 612             (lineSize > 0) && (lineSize <= m_max - m_min) );
 613 }
 614
 615 void SliderWidgetsPage::OnUpdateUIPageSize(wxUpdateUIEvent& event)
 616 {
 617     long pageSize;
 618     event.Enable( m_textPageSize->GetValue().ToLong(&pageSize) &&
 619             (pageSize > 0) && (pageSize <= m_max - m_min) );
 620 }
 621
 622 void SliderWidgetsPage::OnUpdateUITickFreq(wxUpdateUIEvent& event)
 623 {
 624     long freq;
 625     event.Enable( m_chkTicks->GetValue() &&
 626                   m_textTickFreq->GetValue().ToLong(&freq) &&
 627                   (freq > 0) && (freq <= m_max - m_min) );
 628 }
 629
 630 void SliderWidgetsPage::OnUpdateUIThumbLen(wxUpdateUIEvent& event)
 631 {
 632     long val;
 633     event.Enable( m_textThumbLen->GetValue().ToLong(&val));
 634 }
 635
 636 void SliderWidgetsPage::OnUpdateUIMinMaxButton(wxUpdateUIEvent& event)
 637 {
 638     long mn, mx;
 639     event.Enable( m_textMin->GetValue().ToLong(&mn) &&
 640                   m_textMax->GetValue().ToLong(&mx) &&
 641                   mn < mx);
 642 }
 643
 644 void SliderWidgetsPage::OnUpdateUIResetButton(wxUpdateUIEvent& event)
 645 {
 646     event.Enable( m_chkInverse->GetValue() ||
 647                   !m_chkTicks->GetValue() ||
 648                   !m_chkLabels->GetValue() ||
 649                   m_chkBothSides->GetValue() ||
 650                   m_radioSides->GetSelection() != SliderTicks_Top );
 651 }
 652
 653 void SliderWidgetsPage::OnCheckOrRadioBox(wxCommandEvent& WXUNUSED(event))
 654 {
 655     CreateSlider();
 656 }
 657
 658 void SliderWidgetsPage::OnUpdateUICurValueText(wxUpdateUIEvent& event)
 659 {
 660     event.SetText( wxString::Format(_T("%d"), m_slider->GetValue()) );
 661 }
 662
 663 void SliderWidgetsPage::OnUpdateUIRadioSides(wxUpdateUIEvent& event)
 664 {
 665     event.Enable( m_chkLabels->GetValue() || m_chkTicks->GetValue() );
 666 }
 667
 668 void SliderWidgetsPage::OnUpdateUIBothSides(wxUpdateUIEvent& event)
 669 {
 670 #if defined(__WXMSW__) || defined(__WXUNIVERSAL__)
 671     event.Enable( m_chkTicks->GetValue() );
 672 #else
 673     event.Enable( false );
 674 #endif // defined(__WXMSW__) || defined(__WXUNIVERSAL__)
 675 }
 676
 677 void SliderWidgetsPage::OnSlider(wxScrollEvent& event)
 678 {
 679     wxASSERT_MSG( event.GetInt() == m_slider->GetValue(),
 680                   wxT("slider value should be the same") );
 681
 682     wxEventType eventType = event.GetEventType();
 683
 684     /*
 685         This array takes the EXACT order of the declarations in
 686         include/wx/event.h
 687         (section "wxScrollBar and wxSlider event identifiers")
 688     */
 689     static const wxChar *eventNames[] =
 690     {
 691         wxT("wxEVT_SCROLL_TOP"),
 692         wxT("wxEVT_SCROLL_BOTTOM"),
 693         wxT("wxEVT_SCROLL_LINEUP"),
 694         wxT("wxEVT_SCROLL_LINEDOWN"),
 695         wxT("wxEVT_SCROLL_PAGEUP"),
 696         wxT("wxEVT_SCROLL_PAGEDOWN"),
 697         wxT("wxEVT_SCROLL_THUMBTRACK"),
 698         wxT("wxEVT_SCROLL_THUMBRELEASE"),
 699         wxT("wxEVT_SCROLL_CHANGED")
 700     };
 701
 702     int index = eventType - wxEVT_SCROLL_TOP;
 703
 704     /*
 705         If this assert is triggered, there is an unknown slider event which
 706         should be added to the above eventNames array.
 707     */
 708     wxASSERT_MSG(index >= 0 && (size_t)index < WXSIZEOF(eventNames),
 709                  wxT("Unknown slider event") );
 710
 711
 712     static int s_numSliderEvents = 0;
 713
 714     wxLogMessage(wxT("Slider event #%d: %s (pos = %d, int value = %d)"),
 715                  s_numSliderEvents++,
 716                  eventNames[index],
 717                  event.GetPosition(),
 718                  event.GetInt());
 719 }
 720
 721 #endif // wxUSE_SLIDER