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 "wx/gtk/private.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->GetEventHandler()->ProcessEvent( 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->GetEventHandler()->ProcessEvent( 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->GetEventHandler()->ProcessEvent( 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(_T("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     if (g_isIdle) wxapp_install_idle_handler();
 128
 129     if (!win->m_hasVMT) return;
 130     if (g_blockEventsOnDrag) return;
 131
 132     GtkAdjustment* adj = range->adjustment;
 133     const int pos = wxRound(adj->value);
 134     const double oldPos = win->m_pos;
 135     win->m_pos = adj->value;
 136     if (win->m_blockScrollEvent)
 137     {
 138         win->m_scrollEventType = GTK_SCROLL_NONE;
 139         return;
 140     }
 141
 142     wxEventType eventType = wxEVT_NULL;
 143     if (win->m_isScrolling)
 144     {
 145         eventType = wxEVT_SCROLL_THUMBTRACK;
 146     }
 147     else if (win->m_scrollEventType != GTK_SCROLL_NONE)
 148     {
 149         // Scroll event from "move-slider" (keyboard)
 150         eventType = GtkScrollTypeToWx(win->m_scrollEventType);
 151     }
 152     else if (win->m_mouseButtonDown)
 153     {
 154         // Difference from last change event
 155         const double diff = adj->value - oldPos;
 156         const bool isDown = diff > 0;
 157
 158         if (IsScrollIncrement(adj->page_increment, diff))
 159         {
 160             eventType = isDown ? wxEVT_SCROLL_PAGEDOWN : wxEVT_SCROLL_PAGEUP;
 161         }
 162         else if (wxIsSameDouble(adj->value, 0))
 163         {
 164             eventType = wxEVT_SCROLL_PAGEUP;
 165         }
 166         else if (wxIsSameDouble(adj->value, adj->upper))
 167         {
 168             eventType = wxEVT_SCROLL_PAGEDOWN;
 169         }
 170         else
 171         {
 172             // Assume track event
 173             eventType = wxEVT_SCROLL_THUMBTRACK;
 174             // Remember that we're tracking
 175             win->m_isScrolling = true;
 176         }
 177     }
 178
 179     win->m_scrollEventType = GTK_SCROLL_NONE;
 180
 181     // If integral position has changed
 182     if (wxRound(oldPos) != pos)
 183     {
 184         wxCHECK_RET(eventType != wxEVT_NULL, _T("Unknown slider scroll event type"));
 185         ProcessScrollEvent(win, eventType);
 186         win->m_needThumbRelease = eventType == wxEVT_SCROLL_THUMBTRACK;
 187     }
 188 }
 189 }
 190
 191 //-----------------------------------------------------------------------------
 192 // "move_slider" (keyboard event)
 193 //-----------------------------------------------------------------------------
 194
 195 extern "C" {
 196 static void
 197 gtk_move_slider(GtkRange*, GtkScrollType scrollType, wxSlider* win)
 198 {
 199     // Save keyboard scroll type for "value_changed" handler
 200     win->m_scrollEventType = scrollType;
 201 }
 202 }
 203
 204 //-----------------------------------------------------------------------------
 205 // "button_press_event"
 206 //-----------------------------------------------------------------------------
 207
 208 extern "C" {
 209 static gboolean
 210 gtk_button_press_event(GtkWidget*, GdkEventButton*, wxSlider* win)
 211 {
 212     win->m_mouseButtonDown = true;
 213
 214     return false;
 215 }
 216 }
 217
 218 //-----------------------------------------------------------------------------
 219 // "event_after"
 220 //-----------------------------------------------------------------------------
 221
 222 extern "C" {
 223 static void
 224 gtk_event_after(GtkRange* range, GdkEvent* event, wxSlider* win)
 225 {
 226     if (event->type == GDK_BUTTON_RELEASE)
 227     {
 228         g_signal_handlers_block_by_func(range, (void*)gtk_event_after, win);
 229
 230         if (win->m_needThumbRelease)
 231         {
 232             win->m_needThumbRelease = false;
 233             ProcessScrollEvent(win, wxEVT_SCROLL_THUMBRELEASE);
 234         }
 235         // Keep slider at an integral position
 236         win->BlockScrollEvent();
 237         gtk_range_set_value((GtkRange*)win->m_widget, win->GetValue());
 238         win->UnblockScrollEvent();
 239     }
 240 }
 241 }
 242
 243 //-----------------------------------------------------------------------------
 244 // "button_release_event"
 245 //-----------------------------------------------------------------------------
 246
 247 extern "C" {
 248 static gboolean
 249 gtk_button_release_event(GtkRange* range, GdkEventButton*, wxSlider* win)
 250 {
 251     win->m_mouseButtonDown = false;
 252     if (win->m_isScrolling)
 253     {
 254         win->m_isScrolling = false;
 255         g_signal_handlers_unblock_by_func(range, (void*)gtk_event_after, win);
 256     }
 257     return false;
 258 }
 259 }
 260
 261 //-----------------------------------------------------------------------------
 262 // "format_value"
 263 //-----------------------------------------------------------------------------
 264
 265 extern "C" {
 266 static gchar* gtk_format_value(GtkScale*, double value, void*)
 267 {
 268     // Format value as nearest integer
 269     return g_strdup_printf("%d", wxRound(value));
 270 }
 271 }
 272
 273 //-----------------------------------------------------------------------------
 274 // wxSlider
 275 //-----------------------------------------------------------------------------
 276
 277 IMPLEMENT_DYNAMIC_CLASS(wxSlider,wxControl)
 278
 279 wxSlider::wxSlider()
 280 {
 281     m_pos = 0;
 282     m_scrollEventType = 0;
 283     m_needThumbRelease = false;
 284 }
 285
 286 bool wxSlider::Create(wxWindow *parent, wxWindowID id,
 287         int value, int minValue, int maxValue,
 288         const wxPoint& pos, const wxSize& size,
 289         long style, const wxValidator& validator, const wxString& name )
 290 {
 291     m_acceptsFocus = true;
 292     m_needParent = true;
 293
 294     if (!PreCreation( parent, pos, size ) ||
 295         !CreateBase( parent, id, pos, size, style, validator, name ))
 296     {
 297         wxFAIL_MSG( wxT("wxSlider creation failed") );
 298         return false;
 299     }
 300
 301     m_pos = 0;
 302     m_scrollEventType = 0;
 303     m_needThumbRelease = false;
 304
 305     if (style & wxSL_VERTICAL)
 306         m_widget = gtk_vscale_new( (GtkAdjustment *) NULL );
 307     else
 308         m_widget = gtk_hscale_new( (GtkAdjustment *) NULL );
 309
 310     gtk_scale_set_draw_value((GtkScale*)m_widget, (style & wxSL_LABELS) != 0);
 311     // Keep full precision in position value
 312     gtk_scale_set_digits((GtkScale*)m_widget, -1);
 313
 314     if (style & wxSL_INVERSE)
 315         gtk_range_set_inverted( GTK_RANGE(m_widget), TRUE );
 316
 317     g_signal_connect(m_widget, "button_press_event", G_CALLBACK(gtk_button_press_event), this);
 318     g_signal_connect(m_widget, "button_release_event", G_CALLBACK(gtk_button_release_event), this);
 319     g_signal_connect(m_widget, "move_slider", G_CALLBACK(gtk_move_slider), this);
 320     g_signal_connect(m_widget, "format_value", G_CALLBACK(gtk_format_value), NULL);
 321     g_signal_connect(m_widget, "value_changed", G_CALLBACK(gtk_value_changed), this);
 322     gulong handler_id;
 323     handler_id = g_signal_connect(
 324         m_widget, "event_after", G_CALLBACK(gtk_event_after), this);
 325     g_signal_handler_block(m_widget, handler_id);
 326
 327     SetRange( minValue, maxValue );
 328     SetValue( value );
 329
 330     m_parent->DoAddChild( this );
 331
 332     PostCreation(size);
 333
 334     return true;
 335 }
 336
 337 int wxSlider::GetValue() const
 338 {
 339     return wxRound(m_pos);
 340 }
 341
 342 void wxSlider::SetValue( int value )
 343 {
 344     if (GetValue() != value)
 345     {
 346         BlockScrollEvent();
 347         gtk_range_set_value((GtkRange*)m_widget, value);
 348         UnblockScrollEvent();
 349     }
 350 }
 351
 352 void wxSlider::SetRange( int minValue, int maxValue )
 353 {
 354     BlockScrollEvent();
 355     gtk_range_set_range((GtkRange*)m_widget, minValue, maxValue);
 356     gtk_range_set_increments((GtkRange*)m_widget, 1, (maxValue - minValue + 9) / 10);
 357     UnblockScrollEvent();
 358 }
 359
 360 int wxSlider::GetMin() const
 361 {
 362     return int(((GtkRange*)m_widget)->adjustment->lower);
 363 }
 364
 365 int wxSlider::GetMax() const
 366 {
 367     return int(((GtkRange*)m_widget)->adjustment->upper);
 368 }
 369
 370 void wxSlider::SetPageSize( int pageSize )
 371 {
 372     BlockScrollEvent();
 373     gtk_range_set_increments((GtkRange*)m_widget, 1, pageSize);
 374     UnblockScrollEvent();
 375 }
 376
 377 int wxSlider::GetPageSize() const
 378 {
 379     return int(((GtkRange*)m_widget)->adjustment->page_increment);
 380 }
 381
 382 // GTK does not support changing the size of the slider
 383 void wxSlider::SetThumbLength(int)
 384 {
 385 }
 386
 387 int wxSlider::GetThumbLength() const
 388 {
 389     return 0;
 390 }
 391
 392 void wxSlider::SetLineSize( int WXUNUSED(lineSize) )
 393 {
 394 }
 395
 396 int wxSlider::GetLineSize() const
 397 {
 398     return 0;
 399 }
 400
 401 bool wxSlider::IsOwnGtkWindow( GdkWindow *window )
 402 {
 403     GtkRange *range = GTK_RANGE(m_widget);
 404     return (range->event_window == window);
 405 }
 406
 407 // static
 408 wxVisualAttributes
 409 wxSlider::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant))
 410 {
 411     return GetDefaultAttributesFromGTKWidget(gtk_vscale_new);
 412 }
 413
 414 #endif // wxUSE_SLIDER