src/gtk/slider.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/gtk/slider.cpp
   3 // Purpose:
   4 // Author:      Robert Roebling
   5 // Id:          $Id$
   6 // Copyright:   (c) 1998 Robert Roebling
   7 // Licence:     wxWindows licence
   8 /////////////////////////////////////////////////////////////////////////////
   9
  10 // For compilers that support precompilation, includes "wx.h".
  11 #include "wx/wxprec.h"
  12
  13 #if wxUSE_SLIDER
  14
  15 #include "wx/slider.h"
  16
  17 #ifndef WX_PRECOMP
  18     #include "wx/utils.h"
  19     #include "wx/math.h"
  20 #endif
  21
  22 #include <gtk/gtk.h>
  23
  24 //-----------------------------------------------------------------------------
  25 // data
  26 //-----------------------------------------------------------------------------
  27
  28 extern bool g_blockEventsOnDrag;
  29
  30 // ----------------------------------------------------------------------------
  31 // helper functions
  32 // ----------------------------------------------------------------------------
  33
  34 // process a scroll event
  35 static void
  36 ProcessScrollEvent(wxSlider *win, wxEventType evtType)
  37 {
  38     const int orient = win->HasFlag(wxSL_VERTICAL) ? wxVERTICAL
  39                                                    : wxHORIZONTAL;
  40
  41     const int value = win->GetValue();
  42
  43     // if we have any "special" event (i.e. the value changed by a line or a
  44     // page), send this specific event first
  45     if ( evtType != wxEVT_NULL )
  46     {
  47         wxScrollEvent event( evtType, win->GetId(), value, orient );
  48         event.SetEventObject( win );
  49         win->HandleWindowEvent( event );
  50     }
  51
  52     // but, in any case, except if we're dragging the slider (and so the change
  53     // is not definitive), send a generic "changed" event
  54     if ( evtType != wxEVT_SCROLL_THUMBTRACK )
  55     {
  56         wxScrollEvent event(wxEVT_SCROLL_CHANGED, win->GetId(), value, orient);
  57         event.SetEventObject( win );
  58         win->HandleWindowEvent( event );
  59     }
  60
  61     // and also generate a command event for compatibility
  62     wxCommandEvent event( wxEVT_COMMAND_SLIDER_UPDATED, win->GetId() );
  63     event.SetEventObject( win );
  64     event.SetInt( value );
  65     win->HandleWindowEvent( event );
  66 }
  67
  68 static inline wxEventType GtkScrollTypeToWx(int scrollType)
  69 {
  70     wxEventType eventType;
  71     switch (scrollType)
  72     {
  73     case GTK_SCROLL_STEP_BACKWARD:
  74     case GTK_SCROLL_STEP_LEFT:
  75     case GTK_SCROLL_STEP_UP:
  76         eventType = wxEVT_SCROLL_LINEUP;
  77         break;
  78     case GTK_SCROLL_STEP_DOWN:
  79     case GTK_SCROLL_STEP_FORWARD:
  80     case GTK_SCROLL_STEP_RIGHT:
  81         eventType = wxEVT_SCROLL_LINEDOWN;
  82         break;
  83     case GTK_SCROLL_PAGE_BACKWARD:
  84     case GTK_SCROLL_PAGE_LEFT:
  85     case GTK_SCROLL_PAGE_UP:
  86         eventType = wxEVT_SCROLL_PAGEUP;
  87         break;
  88     case GTK_SCROLL_PAGE_DOWN:
  89     case GTK_SCROLL_PAGE_FORWARD:
  90     case GTK_SCROLL_PAGE_RIGHT:
  91         eventType = wxEVT_SCROLL_PAGEDOWN;
  92         break;
  93     case GTK_SCROLL_START:
  94         eventType = wxEVT_SCROLL_TOP;
  95         break;
  96     case GTK_SCROLL_END:
  97         eventType = wxEVT_SCROLL_BOTTOM;
  98         break;
  99     case GTK_SCROLL_JUMP:
 100         eventType = wxEVT_SCROLL_THUMBTRACK;
 101         break;
 102     default:
 103         wxFAIL_MSG(wxT("Unknown GtkScrollType"));
 104         eventType = wxEVT_NULL;
 105         break;
 106     }
 107     return eventType;
 108 }
 109
 110 // Determine if increment is the same as +/-x, allowing for some small
 111 //   difference due to possible inexactness in floating point arithmetic
 112 static inline bool IsScrollIncrement(double increment, double x)
 113 {
 114     wxASSERT(increment > 0);
 115     const double tolerance = 1.0 / 1024;
 116     return fabs(increment - fabs(x)) < tolerance;
 117 }
 118
 119 //-----------------------------------------------------------------------------
 120 // "value_changed"
 121 //-----------------------------------------------------------------------------
 122
 123 extern "C" {
 124 static void
 125 gtk_value_changed(GtkRange* range, wxSlider* win)
 126 {
 127     GtkAdjustment* adj = gtk_range_get_adjustment (range);
 128     const int pos = wxRound(adj->value);
 129     const double oldPos = win->m_pos;
 130     win->m_pos = adj->value;
 131
 132     if (!win->m_hasVMT || g_blockEventsOnDrag)
 133         return;
 134
 135     if (win->GTKEventsDisabled())
 136     {
 137         win->m_scrollEventType = GTK_SCROLL_NONE;
 138         return;
 139     }
 140
 141     wxEventType eventType = wxEVT_NULL;
 142     if (win->m_isScrolling)
 143     {
 144         eventType = wxEVT_SCROLL_THUMBTRACK;
 145     }
 146     else if (win->m_scrollEventType != GTK_SCROLL_NONE)
 147     {
 148         // Scroll event from "move-slider" (keyboard)
 149         eventType = GtkScrollTypeToWx(win->m_scrollEventType);
 150     }
 151     else if (win->m_mouseButtonDown)
 152     {
 153         // Difference from last change event
 154         const double diff = adj->value - oldPos;
 155         const bool isDown = diff > 0;
 156
 157         if (IsScrollIncrement(adj->page_increment, diff))
 158         {
 159             eventType = isDown ? wxEVT_SCROLL_PAGEDOWN : wxEVT_SCROLL_PAGEUP;
 160         }
 161         else if (wxIsSameDouble(adj->value, 0))
 162         {
 163             eventType = wxEVT_SCROLL_PAGEUP;
 164         }
 165         else if (wxIsSameDouble(adj->value, adj->upper))
 166         {
 167             eventType = wxEVT_SCROLL_PAGEDOWN;
 168         }
 169         else
 170         {
 171             // Assume track event
 172             eventType = wxEVT_SCROLL_THUMBTRACK;
 173             // Remember that we're tracking
 174             win->m_isScrolling = true;
 175         }
 176     }
 177
 178     win->m_scrollEventType = GTK_SCROLL_NONE;
 179
 180     // If integral position has changed
 181     if (wxRound(oldPos) != pos)
 182     {
 183         ProcessScrollEvent(win, eventType);
 184         win->m_needThumbRelease = eventType == wxEVT_SCROLL_THUMBTRACK;
 185     }
 186 }
 187 }
 188
 189 //-----------------------------------------------------------------------------
 190 // "move_slider" (keyboard event)
 191 //-----------------------------------------------------------------------------
 192
 193 extern "C" {
 194 static void
 195 gtk_move_slider(GtkRange*, GtkScrollType scrollType, wxSlider* win)
 196 {
 197     // Save keyboard scroll type for "value_changed" handler
 198     win->m_scrollEventType = scrollType;
 199 }
 200 }
 201
 202 //-----------------------------------------------------------------------------
 203 // "button_press_event"
 204 //-----------------------------------------------------------------------------
 205
 206 extern "C" {
 207 static gboolean
 208 gtk_button_press_event(GtkWidget*, GdkEventButton*, wxSlider* win)
 209 {
 210     win->m_mouseButtonDown = true;
 211
 212     return false;
 213 }
 214 }
 215
 216 //-----------------------------------------------------------------------------
 217 // "event_after"
 218 //-----------------------------------------------------------------------------
 219
 220 extern "C" {
 221 static void
 222 gtk_event_after(GtkRange* range, GdkEvent* event, wxSlider* win)
 223 {
 224     if (event->type == GDK_BUTTON_RELEASE)
 225     {
 226         g_signal_handlers_block_by_func(range, (gpointer) gtk_event_after, win);
 227
 228         if (win->m_needThumbRelease)
 229         {
 230             win->m_needThumbRelease = false;
 231             ProcessScrollEvent(win, wxEVT_SCROLL_THUMBRELEASE);
 232         }
 233         // Keep slider at an integral position
 234         win->GTKDisableEvents();
 235         gtk_range_set_value(GTK_RANGE (win->m_scale), win->GetValue());
 236         win->GTKEnableEvents();
 237     }
 238 }
 239 }
 240
 241 //-----------------------------------------------------------------------------
 242 // "button_release_event"
 243 //-----------------------------------------------------------------------------
 244
 245 extern "C" {
 246 static gboolean
 247 gtk_button_release_event(GtkRange* range, GdkEventButton*, wxSlider* win)
 248 {
 249     win->m_mouseButtonDown = false;
 250     if (win->m_isScrolling)
 251     {
 252         win->m_isScrolling = false;
 253         g_signal_handlers_unblock_by_func(range, (gpointer) gtk_event_after, win);
 254     }
 255     return false;
 256 }
 257 }
 258
 259 //-----------------------------------------------------------------------------
 260 // "format_value"
 261 //-----------------------------------------------------------------------------
 262
 263 extern "C" {
 264 static gchar* gtk_format_value(GtkScale*, double value, void*)
 265 {
 266     // Format value as nearest integer
 267     return g_strdup_printf("%d", wxRound(value));
 268 }
 269 }
 270
 271 //-----------------------------------------------------------------------------
 272 // wxSlider
 273 //-----------------------------------------------------------------------------
 274
 275 IMPLEMENT_DYNAMIC_CLASS(wxSlider,wxControl)
 276
 277 wxSlider::wxSlider()
 278 {
 279     m_pos = 0;
 280     m_scrollEventType = GTK_SCROLL_NONE;
 281     m_needThumbRelease = false;
 282     m_blockScrollEvent = false;
 283 }
 284
 285 bool wxSlider::Create(wxWindow *parent,
 286                       wxWindowID id,
 287                       int value,
 288                       int minValue,
 289                       int maxValue,
 290                       const wxPoint& pos,
 291                       const wxSize& size,
 292                       long style,
 293                       const wxValidator& validator,
 294                       const wxString& name)
 295 {
 296     m_pos = value;
 297     m_scrollEventType = GTK_SCROLL_NONE;
 298
 299     if (!PreCreation( parent, pos, size ) ||
 300         !CreateBase( parent, id, pos, size, style, validator, name ))
 301     {
 302         wxFAIL_MSG( wxT("wxSlider creation failed") );
 303         return false;
 304     }
 305
 306
 307     if (style & wxSL_VERTICAL)
 308         m_scale = gtk_vscale_new( NULL );
 309     else
 310         m_scale = gtk_hscale_new( NULL );
 311     g_object_ref(m_scale);
 312
 313     if (style & wxSL_MIN_MAX_LABELS)
 314     {
 315         gtk_widget_show( m_scale );
 316
 317         if (style & wxSL_VERTICAL)
 318             m_widget = gtk_hbox_new(false, 0);
 319         else
 320             m_widget = gtk_vbox_new(false, 0);
 321         g_object_ref(m_widget);
 322         gtk_widget_show( m_widget );
 323         gtk_container_add( GTK_CONTAINER(m_widget), m_scale );
 324
 325         GtkWidget *box;
 326         if (style & wxSL_VERTICAL)
 327             box = gtk_vbox_new(false,0);
 328         else
 329             box = gtk_hbox_new(false,0);
 330         g_object_ref(box);
 331         gtk_widget_show(box);
 332         gtk_container_add( GTK_CONTAINER(m_widget), box );
 333
 334         m_minLabel = gtk_label_new(NULL);
 335         g_object_ref(m_minLabel);
 336         gtk_widget_show( m_minLabel );
 337         gtk_container_add( GTK_CONTAINER(box), m_minLabel );
 338         gtk_box_set_child_packing( GTK_BOX(box), m_minLabel, FALSE, FALSE, 0, GTK_PACK_START );
 339
 340         // expanding empty space between the min/max labels
 341         GtkWidget *space = gtk_label_new(NULL);
 342         g_object_ref(space);
 343         gtk_widget_show( space );
 344         gtk_container_add( GTK_CONTAINER(box), space );
 345         gtk_box_set_child_packing( GTK_BOX(box), space, TRUE, FALSE, 0, GTK_PACK_START );
 346
 347         m_maxLabel = gtk_label_new(NULL);
 348         g_object_ref(m_maxLabel);
 349         gtk_widget_show( m_maxLabel );
 350         gtk_container_add( GTK_CONTAINER(box), m_maxLabel );
 351         gtk_box_set_child_packing( GTK_BOX(box), m_maxLabel, FALSE, FALSE, 0, GTK_PACK_END );
 352     }
 353     else
 354     {
 355         m_widget = m_scale;
 356         m_maxLabel = NULL;
 357         m_minLabel = NULL;
 358     }
 359
 360     const bool showValueLabel = (style & wxSL_VALUE_LABEL) != 0;
 361     gtk_scale_set_draw_value(GTK_SCALE (m_scale), showValueLabel );
 362     if ( showValueLabel )
 363     {
 364         // position the label appropriately: notice that wxSL_DIRECTION flags
 365         // specify the position of the ticks, not label, under MSW and so the
 366         // label is on the opposite side
 367         GtkPositionType posLabel;
 368         if ( style & wxSL_VERTICAL )
 369         {
 370             if ( style & wxSL_LEFT )
 371                 posLabel = GTK_POS_RIGHT;
 372             else // if ( style & wxSL_RIGHT ) -- this is also the default
 373                 posLabel = GTK_POS_LEFT;
 374         }
 375         else // horizontal slider
 376         {
 377             if ( style & wxSL_TOP )
 378                 posLabel = GTK_POS_BOTTOM;
 379             else // if ( style & wxSL_BOTTOM) -- this is again the default
 380                 posLabel = GTK_POS_TOP;
 381         }
 382
 383         gtk_scale_set_value_pos( GTK_SCALE(m_scale), posLabel );
 384     }
 385
 386     // Keep full precision in position value
 387     gtk_scale_set_digits(GTK_SCALE (m_scale), -1);
 388
 389     if (style & wxSL_INVERSE)
 390         gtk_range_set_inverted( GTK_RANGE(m_scale), TRUE );
 391
 392     g_signal_connect(m_scale, "button_press_event", G_CALLBACK(gtk_button_press_event), this);
 393     g_signal_connect(m_scale, "button_release_event", G_CALLBACK(gtk_button_release_event), this);
 394     g_signal_connect(m_scale, "move_slider", G_CALLBACK(gtk_move_slider), this);
 395     g_signal_connect(m_scale, "format_value", G_CALLBACK(gtk_format_value), NULL);
 396     g_signal_connect(m_scale, "value_changed", G_CALLBACK(gtk_value_changed), this);
 397     gulong handler_id = g_signal_connect(m_scale, "event_after", G_CALLBACK(gtk_event_after), this);
 398     g_signal_handler_block(m_scale, handler_id);
 399
 400     SetRange( minValue, maxValue );
 401
 402     // don't call the public SetValue() as it won't do anything unless the
 403     // value really changed
 404     GTKSetValue( value );
 405
 406     m_parent->DoAddChild( this );
 407
 408     PostCreation(size);
 409
 410     return true;
 411 }
 412
 413 void wxSlider::GTKDisableEvents()
 414 {
 415     m_blockScrollEvent = true;
 416 }
 417
 418 void wxSlider::GTKEnableEvents()
 419 {
 420     m_blockScrollEvent = false;
 421 }
 422
 423 bool wxSlider::GTKEventsDisabled() const
 424 {
 425    return m_blockScrollEvent;
 426 }
 427
 428 int wxSlider::GetValue() const
 429 {
 430     return wxRound(m_pos);
 431 }
 432
 433 void wxSlider::SetValue( int value )
 434 {
 435     if (GetValue() != value)
 436         GTKSetValue(value);
 437 }
 438
 439 void wxSlider::GTKSetValue(int value)
 440 {
 441     GTKDisableEvents();
 442     gtk_range_set_value(GTK_RANGE (m_scale), value);
 443     GTKEnableEvents();
 444 }
 445
 446 void wxSlider::SetRange( int minValue, int maxValue )
 447 {
 448     GTKDisableEvents();
 449     if (minValue == maxValue)
 450        maxValue++;
 451     gtk_range_set_range(GTK_RANGE (m_scale), minValue, maxValue);
 452     gtk_range_set_increments(GTK_RANGE (m_scale), 1, (maxValue - minValue + 9) / 10);
 453     GTKEnableEvents();
 454
 455     if (HasFlag(wxSL_MIN_MAX_LABELS))
 456     {
 457         wxString str;
 458
 459         str.Printf( "%d", minValue );
 460         if (HasFlag(wxSL_INVERSE))
 461             gtk_label_set_text( GTK_LABEL(m_maxLabel), str.utf8_str() );
 462         else
 463             gtk_label_set_text( GTK_LABEL(m_minLabel), str.utf8_str() );
 464
 465         str.Printf( "%d", maxValue );
 466         if (HasFlag(wxSL_INVERSE))
 467             gtk_label_set_text( GTK_LABEL(m_minLabel), str.utf8_str() );
 468         else
 469             gtk_label_set_text( GTK_LABEL(m_maxLabel), str.utf8_str() );
 470
 471     }
 472 }
 473
 474 int wxSlider::GetMin() const
 475 {
 476     return int(gtk_range_get_adjustment (GTK_RANGE (m_scale))->lower);
 477 }
 478
 479 int wxSlider::GetMax() const
 480 {
 481     return int(gtk_range_get_adjustment (GTK_RANGE (m_scale))->upper);
 482 }
 483
 484 void wxSlider::SetPageSize( int pageSize )
 485 {
 486     GTKDisableEvents();
 487     gtk_range_set_increments(GTK_RANGE (m_scale), GetLineSize(), pageSize);
 488     GTKEnableEvents();
 489 }
 490
 491 int wxSlider::GetPageSize() const
 492 {
 493     return int(gtk_range_get_adjustment (GTK_RANGE (m_scale))->page_increment);
 494 }
 495
 496 // GTK does not support changing the size of the slider
 497 void wxSlider::SetThumbLength(int)
 498 {
 499 }
 500
 501 int wxSlider::GetThumbLength() const
 502 {
 503     return 0;
 504 }
 505
 506 void wxSlider::SetLineSize( int lineSize )
 507 {
 508     GTKDisableEvents();
 509     gtk_range_set_increments(GTK_RANGE (m_scale), lineSize, GetPageSize());
 510     GTKEnableEvents();
 511 }
 512
 513 int wxSlider::GetLineSize() const
 514 {
 515     return int(gtk_range_get_adjustment (GTK_RANGE (m_scale))->step_increment);
 516 }
 517
 518 GdkWindow *wxSlider::GTKGetWindow(wxArrayGdkWindows& WXUNUSED(windows)) const
 519 {
 520     return GTK_RANGE(m_scale)->event_window;
 521 }
 522
 523 // static
 524 wxVisualAttributes
 525 wxSlider::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant))
 526 {
 527     return GetDefaultAttributesFromGTKWidget(gtk_vscale_new);
 528 }
 529
 530 #endif // wxUSE_SLIDER