Merge lp:~cimi/overlay-scrollbar/use-enums into lp:overlay-scrollbar

[Andrea Cimitan]

If you have ideas on namings or other sets of enums to create, just ping me in IRC and not marking as "NEED FIXING" :)
Or they could be handled in separated branches

Unmerged revisions

=== modified file 'os/os-private.h'
--- os/os-private.h	2011-06-27 17:03:25 +0000
+++ os/os-private.h	2011-07-07 15:06:32 +0000
@@ -36,6 +36,15 @@
 
 G_BEGIN_DECLS
 
+typedef enum
+{
+  OS_EVENT_NONE = 0,
+  OS_EVENT_BUTTON_PRESS = 1,
+  OS_EVENT_ENTER_NOTIFY = 2,
+  OS_EVENT_MOTION_NOTIFY = 4,
+  OS_EVENT_VALUE_CHANGED = 8
+} OsEvent;
+
 /* os-log.c */
 
 /* Severity levels. */
@@ -71,7 +80,7 @@
     }                                                                      \
   } G_STMT_END
 
-/* Macro loggging an error message to stderr and breaking the program execution
+/* Macro logging an error message to stderr and breaking the program execution
  * if the assertion fails. */
 #define OS_CHECK(cond)                                        \
   G_STMT_START {                                              \

=== modified file 'os/os-scrollbar.c'
--- os/os-scrollbar.c	2011-07-05 18:13:09 +0000
+++ os/os-scrollbar.c	2011-07-07 15:06:32 +0000
@@ -91,13 +91,11 @@
   OsAnimation *animation;
   OsPager *pager;
   OsSide side;
-  gboolean button_press_event;
-  gboolean enter_notify_event;
-  gboolean motion_notify_event;
-  gboolean value_changed_event;
+  OsEvent event;
   gboolean active_window;
   gboolean can_deactivate_pager;
   gboolean can_hide;
+  gboolean detached_scroll;
   gboolean filter;
   gboolean fullsize;
   gboolean internal;
@@ -368,10 +366,7 @@
   priv = scrollbar->priv;
 
   if (priv->can_hide)
-    {
-      priv->value_changed_event = FALSE;
-      gtk_widget_hide (priv->thumb);
-    }
+    gtk_widget_hide (priv->thumb);
 }
 
 /* timeout before hiding the thumb */
@@ -773,19 +768,6 @@
   gtk_adjustment_set_value (priv->adjustment, new_value);
 }
 
-/* stop_func called by the set-scroll animation */
-static void
-set_scroll_stop_cb (gpointer user_data)
-{
-  OsScrollbar *scrollbar;
-  OsScrollbarPrivate *priv;
-
-  scrollbar = OS_SCROLLBAR (user_data);
-  priv = scrollbar->priv;
-
-  priv->value = gtk_adjustment_get_value (priv->adjustment);
-}
-
 /* swap adjustment pointer */
 static void
 swap_adjustment (OsScrollbar   *scrollbar,
@@ -933,12 +915,98 @@
   calc_layout_pager (scrollbar, gtk_adjustment_get_value (adjustment));
   calc_layout_slider (scrollbar, gtk_adjustment_get_value (adjustment));
 
-  if (!priv->motion_notify_event && !priv->enter_notify_event)
+  if (!(priv->event & OS_EVENT_ENTER_NOTIFY) &&
+      !(priv->event & OS_EVENT_MOTION_NOTIFY))
     gtk_widget_hide (priv->thumb);
 
   move_pager (scrollbar);
 }
 
+/* update the visual connection between pager and thumb. */
+static void
+update_visual_connection (OsScrollbar *scrollbar)
+{
+  OsScrollbarPrivate *priv;
+  gint x_pos, y_pos;
+
+  priv = scrollbar->priv;
+
+  gdk_window_get_origin (gtk_widget_get_window (priv->thumb), &x_pos, &y_pos);
+
+  if (priv->orientation == GTK_ORIENTATION_VERTICAL)
+    {
+      if (priv->win_y + priv->overlay.y >= y_pos + priv->slider.height)
+        {
+          GdkRectangle mask;
+
+          mask.x = 0;
+          mask.y = y_pos + priv->slider.height / 2 - priv->win_y;
+          mask.width = priv->pager_all.width;
+          mask.height = priv->overlay.y - mask.y;
+
+          os_pager_connect (priv->pager, mask);
+          os_pager_set_detached (priv->pager, TRUE);
+
+          os_thumb_set_detached (OS_THUMB (priv->thumb), TRUE);
+        }
+      else if (priv->win_y + priv->overlay.y + priv->overlay.height <= y_pos)
+        {
+          GdkRectangle mask;
+
+          mask.x = 0;
+          mask.y = priv->overlay.y + priv->overlay.height;
+          mask.width = priv->pager_all.width;
+          mask.height = y_pos + priv->slider.height / 2 - priv->win_y - mask.y;
+
+          os_pager_connect (priv->pager, mask);
+          os_pager_set_detached (priv->pager, TRUE);
+
+          os_thumb_set_detached (OS_THUMB (priv->thumb), TRUE);
+        }
+      else 
+        {
+          os_pager_set_detached (priv->pager, FALSE);
+          os_thumb_set_detached (OS_THUMB (priv->thumb), FALSE);
+        }
+    }
+  else
+    {
+      if (priv->win_x + priv->overlay.x >= x_pos + priv->slider.width)
+        {
+          GdkRectangle mask;
+
+          mask.x = x_pos + priv->slider.width / 2 - priv->win_x;
+          mask.y = 0;
+          mask.width = priv->overlay.x - mask.x;
+          mask.height = priv->pager_all.height;
+
+          os_pager_connect (priv->pager, mask);
+          os_pager_set_detached (priv->pager, TRUE);
+
+          os_thumb_set_detached (OS_THUMB (priv->thumb), TRUE);
+        }
+      else if (priv->win_x + priv->overlay.x + priv->overlay.width <= x_pos)
+        {
+          GdkRectangle mask;
+
+          mask.x = priv->overlay.x + priv->overlay.width;
+          mask.y = 0;
+          mask.width = x_pos + priv->slider.width / 2 - priv->win_x - mask.x;
+          mask.height = priv->pager_all.height;
+
+          os_pager_connect (priv->pager, mask);
+          os_pager_set_detached (priv->pager, TRUE);
+
+          os_thumb_set_detached (OS_THUMB (priv->thumb), TRUE);
+        }
+      else
+        {
+          os_pager_set_detached (priv->pager, FALSE);
+          os_thumb_set_detached (OS_THUMB (priv->thumb), FALSE);
+        }
+    }
+}
+
 static void
 adjustment_value_changed_cb (GtkAdjustment *adjustment,
                              gpointer       user_data)
@@ -952,95 +1020,20 @@
   calc_layout_pager (scrollbar, gtk_adjustment_get_value (adjustment));
   calc_layout_slider (scrollbar, gtk_adjustment_get_value (adjustment));
 
-  if (!priv->motion_notify_event && !priv->enter_notify_event)
+  if (!(priv->event & OS_EVENT_ENTER_NOTIFY) &&
+      !(priv->event & OS_EVENT_MOTION_NOTIFY))
     gtk_widget_hide (priv->thumb);
 
   if (gtk_widget_get_mapped (priv->thumb))
     {
       /* if we're dragging the thumb, it can't be detached. */
-      if (priv->motion_notify_event)
+      if (priv->event & OS_EVENT_MOTION_NOTIFY)
         {
           os_pager_set_detached (priv->pager, FALSE);
           os_thumb_set_detached (OS_THUMB (priv->thumb), FALSE);
         }
       else
-        {
-          gint x_pos, y_pos;
-          gdk_window_get_origin (gtk_widget_get_window (priv->thumb), &x_pos, &y_pos);
-
-          if (priv->orientation == GTK_ORIENTATION_VERTICAL)
-            {
-              if (priv->win_y + priv->overlay.y > y_pos + priv->slider.height)
-                {
-                  GdkRectangle mask;
-
-                  mask.x = 0;
-                  mask.y = y_pos + priv->slider.height / 2 - priv->win_y;
-                  mask.width = priv->pager_all.width;
-                  mask.height = priv->overlay.y - mask.y;
-
-                  os_pager_connect (priv->pager, mask);
-                  os_pager_set_detached (priv->pager, TRUE);
-
-                  os_thumb_set_detached (OS_THUMB (priv->thumb), TRUE);
-                }
-              else if (priv->win_y + priv->overlay.y + priv->overlay.height < y_pos)
-                {
-                  GdkRectangle mask;
-
-                  mask.x = 0;
-                  mask.y = priv->overlay.y + priv->overlay.height;
-                  mask.width = priv->pager_all.width;
-                  mask.height = y_pos + priv->slider.height / 2 - priv->win_y - mask.y;
-
-                  os_pager_connect (priv->pager, mask);
-                  os_pager_set_detached (priv->pager, TRUE);
-
-                  os_thumb_set_detached (OS_THUMB (priv->thumb), TRUE);
-                }
-              else 
-                {
-                  os_pager_set_detached (priv->pager, FALSE);
-                  os_thumb_set_detached (OS_THUMB (priv->thumb), FALSE);
-                }
-            }
-          else
-            {
-              if (priv->win_x + priv->overlay.x > x_pos + priv->slider.width)
-                {
-                  GdkRectangle mask;
-
-                  mask.x = x_pos + priv->slider.width / 2 - priv->win_x;
-                  mask.y = 0;
-                  mask.width = priv->overlay.x - mask.x;
-                  mask.height = priv->pager_all.height;
-
-                  os_pager_connect (priv->pager, mask);
-                  os_pager_set_detached (priv->pager, TRUE);
-
-                  os_thumb_set_detached (OS_THUMB (priv->thumb), TRUE);
-                }
-              else if (priv->win_x + priv->overlay.x + priv->overlay.width < x_pos)
-                {
-                  GdkRectangle mask;
-
-                  mask.x = priv->overlay.x + priv->overlay.width;
-                  mask.y = 0;
-                  mask.width = x_pos + priv->slider.width / 2 - priv->win_x - mask.x;
-                  mask.height = priv->pager_all.height;
-
-                  os_pager_connect (priv->pager, mask);
-                  os_pager_set_detached (priv->pager, TRUE);
-
-                  os_thumb_set_detached (OS_THUMB (priv->thumb), TRUE);
-                }
-              else
-                {
-                  os_pager_set_detached (priv->pager, FALSE);
-                  os_thumb_set_detached (OS_THUMB (priv->thumb), FALSE);
-                }
-            }
-        }
+        update_visual_connection (scrollbar);
     }
 
   move_pager (scrollbar);
@@ -1257,8 +1250,10 @@
           priv->present_time = g_get_monotonic_time ();
           present_gdk_window_with_timestamp (GTK_WIDGET (scrollbar), event->time);
 
-          priv->button_press_event = TRUE;
-          priv->motion_notify_event = FALSE;
+          priv->event |= OS_EVENT_BUTTON_PRESS;
+          priv->event &= ~(OS_EVENT_MOTION_NOTIFY);
+
+          priv->detached_scroll = FALSE;
 
           if (priv->orientation == GTK_ORIENTATION_VERTICAL)
             {
@@ -1352,7 +1347,7 @@
 
           gtk_window_set_transient_for (GTK_WINDOW (widget), NULL);
 
-          if (!priv->motion_notify_event)
+          if (!(priv->event & OS_EVENT_MOTION_NOTIFY) && !priv->detached_scroll)
             {
               if (priv->orientation == GTK_ORIENTATION_VERTICAL)
                 {
@@ -1369,11 +1364,10 @@
                     page_down (scrollbar);
                 }
 
-              priv->value_changed_event = TRUE;
+              priv->event |= OS_EVENT_VALUE_CHANGED;
             }
 
-          priv->button_press_event = FALSE;
-          priv->motion_notify_event = FALSE;
+          priv->event &= ~(OS_EVENT_BUTTON_PRESS | OS_EVENT_MOTION_NOTIFY);
         }
     }
 
@@ -1391,7 +1385,8 @@
   scrollbar = OS_SCROLLBAR (user_data);
   priv = scrollbar->priv;
 
-  priv->enter_notify_event = TRUE;
+  priv->event |= OS_EVENT_ENTER_NOTIFY;
+
   priv->can_deactivate_pager = FALSE;
   priv->can_hide = FALSE;
 
@@ -1414,7 +1409,7 @@
 
   /* add the timeouts only if you are
    * not interacting with the thumb. */
-  if (!priv->button_press_event)
+  if (!(priv->event & OS_EVENT_BUTTON_PRESS))
     {
       /* never deactivate the pager in an active window. */
       if (!priv->active_window)
@@ -1586,46 +1581,6 @@
   gtk_adjustment_set_value (priv->adjustment, new_value);
 }
 
-/* from pointer movement, store the right adjustment value */
-static void
-capture_movement_for_animation (OsScrollbar *scrollbar,
-                                gint         mouse_x,
-                                gint         mouse_y)
-{
-  OsScrollbarPrivate *priv;
-  gint delta;
-  gint c;
-  gdouble current_value, old_value, new_value;
-
-  priv = scrollbar->priv;
-
-  if (priv->orientation == GTK_ORIENTATION_VERTICAL)
-    delta = mouse_y - priv->slide_initial_coordinate;
-  else
-    delta = mouse_x - priv->slide_initial_coordinate;
-
-  c = priv->slide_initial_slider_position + delta;
-
-  current_value = gtk_adjustment_get_value (priv->adjustment);
-  old_value = priv->value;
-  new_value = coord_to_value (scrollbar, c);
-
-  /* stop the animation if we are connecting. */
-  if ((current_value > old_value &&
-       new_value > current_value) ||
-      (current_value < old_value &&
-       new_value < current_value))
-    {
-      os_animation_stop (priv->animation, NULL);
-
-      gtk_adjustment_set_value (priv->adjustment, new_value);
-    }
-
-  /* update the adjustment value for the reconnect animation:
-   * set_scroll_cb could be running at that time. */
-  priv->value = new_value;
-}
-
 static gboolean
 thumb_motion_notify_event_cb (GtkWidget      *widget,
                               GdkEventMotion *event,
@@ -1637,72 +1592,129 @@
   scrollbar = OS_SCROLLBAR (user_data);
   priv = scrollbar->priv;
 
-  if (priv->button_press_event)
+  if (priv->event & OS_EVENT_BUTTON_PRESS)
     {
       gint x, y;
 
-      /* reconnect slider and overlay after key press */
-      if (priv->value_changed_event)
+      /* thumb and pager are detached.
+       * Detached scroll: keep the thumb detached during the scroll,
+       * update the visual connection when reaching an edge. */
+      if (priv->event & OS_EVENT_VALUE_CHANGED)
         {
           /* return if the mouse movement is small. */
           if (abs (priv->pointer_x - event->x) <= TOLERANCE_PIXELS &&
               abs (priv->pointer_y - event->y) <= TOLERANCE_PIXELS)
             return FALSE;
 
-          if (priv->orientation == GTK_ORIENTATION_VERTICAL)
-            {
-              priv->slide_initial_slider_position = event->y_root - priv->win_y - event->y;
-              priv->slide_initial_coordinate = event->y_root;
-            }
-          else
-            {
-              priv->slide_initial_slider_position = event->x_root - priv->win_x - event->x;
-              priv->slide_initial_coordinate = event->x_root;
-            }
+          priv->detached_scroll = TRUE;
 
           /* stop the scroll animation if it's running. */
-          os_animation_stop (priv->animation, set_scroll_stop_cb);
-
-          /* set the initial adjustment value required for reconnect. */
-          capture_movement_for_animation (scrollbar, event->x_root, event->y_root);
-
-          /* animate the reconnect, using the same animation object. */
-          os_animation_start (priv->animation);
-
-          priv->value_changed_event = FALSE;
-        }
-
-      /* only the reconnect animation can be running at that time. */
-      if (os_animation_is_running (priv->animation))
-        {
-          /* update the adjustment value. */
-          capture_movement_for_animation (scrollbar, event->x_root, event->y_root);
-
-          /* limit x and y within the thumb allocation. */
+          os_animation_stop (priv->animation, NULL);
+
+          /* limit x and y within the allocation. */
           if (priv->orientation == GTK_ORIENTATION_VERTICAL)
             {
               x = priv->win_x;
               y = CLAMP (event->y_root - priv->pointer_y,
                          priv->win_y,
-                         priv->win_y + priv->thumb_all.height);
+                         priv->win_y + priv->thumb_all.height - priv->slider.height);
             }
           else
             {
               x = CLAMP (event->x_root - priv->pointer_x,
                          priv->win_x,
-                         priv->win_x + priv->thumb_all.width);
+                         priv->win_x + priv->thumb_all.width - priv->slider.width);
               y = priv->win_y;
             }
 
+          /* fine scroll while detached,
+           * do not scroll when hitting an edge. */
+          if ((priv->orientation == GTK_ORIENTATION_VERTICAL &&
+               y > priv->win_y &&
+               y < priv->win_y + priv->thumb_all.height - priv->slider.height) ||
+              (priv->orientation == GTK_ORIENTATION_HORIZONTAL &&
+               x > priv->win_x &&
+               x < priv->win_x + priv->thumb_all.width - priv->slider.width))
+            capture_movement (scrollbar, event->x_root, event->y_root);
+
           move_thumb (scrollbar, x, y);
 
-          /* return if the reconnect animation is still running after
-           * capture_movement_for_animation. */
-          if (os_animation_is_running (priv->animation))
-            return FALSE;
+          if (priv->orientation == GTK_ORIENTATION_VERTICAL)
+            {
+              if (gtk_adjustment_get_value (priv->adjustment) == 0)
+                {
+                  update_visual_connection (scrollbar);                
+
+                  if (priv->overlay.height > priv->slider.height)
+                    {
+                      priv->slide_initial_slider_position = 0;
+                      priv->slide_initial_coordinate = MAX (event->y_root, priv->win_y + priv->pointer_y);
+                    }
+                  else
+                    {
+                      priv->slide_initial_slider_position = 0;
+                      priv->slide_initial_coordinate = event->y_root;
+                    }
+                }
+              else if (priv->overlay.y + priv->overlay.height >= priv->trough.height)
+                {
+                  update_visual_connection (scrollbar);
+
+                  if (priv->overlay.height > priv->slider.height)
+                    {
+                      priv->slide_initial_slider_position = priv->trough.height - priv->overlay.height;
+                      priv->slide_initial_coordinate = MAX (event->y_root, priv->win_y + priv->pointer_y);
+                    }
+                  else
+                    {
+                      priv->slide_initial_slider_position = priv->trough.height - priv->slider.height;
+                      priv->slide_initial_coordinate = event->y_root;
+                    }
+                }
+            }
+          else
+            {
+              if (gtk_adjustment_get_value (priv->adjustment) == 0)
+                {
+                  update_visual_connection (scrollbar);                
+
+                  if (priv->overlay.width > priv->slider.width)
+                    {
+                      priv->slide_initial_slider_position = 0;
+                      priv->slide_initial_coordinate = MAX (event->x_root, priv->win_x + priv->pointer_x);
+                    }
+                  else
+                    {
+                      priv->slide_initial_slider_position = 0;
+                      priv->slide_initial_coordinate = event->x_root;
+                    }
+                }
+              else if (priv->overlay.x + priv->overlay.width >= priv->trough.width)
+                {
+                  update_visual_connection (scrollbar);
+
+                  if (priv->overlay.width > priv->slider.width)
+                    {
+                      priv->slide_initial_slider_position = priv->trough.width - priv->overlay.width;
+                      priv->slide_initial_coordinate = MAX (event->x_root, priv->win_x + priv->pointer_x);
+                    }
+                  else
+                    {
+                      priv->slide_initial_slider_position = priv->trough.width - priv->slider.width;
+                      priv->slide_initial_coordinate = event->x_root;
+                    }
+                }
+            }
+
+          return FALSE;            
         }
 
-      priv->motion_notify_event = TRUE;
+      OS_DCHECK (!priv->detached_scroll);
+
+      /* thumb and pager are connected.
+       * Normal scroll: keep the thumb in sync with the pager,
+       * do not update the visual connection. */
+      priv->event |= OS_EVENT_MOTION_NOTIFY;
 
       capture_movement (scrollbar, event->x_root, event->y_root);
 
@@ -1798,7 +1810,7 @@
   scrollbar = OS_SCROLLBAR (user_data);
   priv = scrollbar->priv;
 
-  priv->value_changed_event = TRUE;
+  priv->event |= OS_EVENT_VALUE_CHANGED;
 
   delta = get_wheel_delta (scrollbar, event->direction);
 
@@ -1821,9 +1833,9 @@
   scrollbar = OS_SCROLLBAR (user_data);
   priv = scrollbar->priv;
 
-  priv->button_press_event = FALSE;
-  priv->motion_notify_event = FALSE;
-  priv->enter_notify_event = FALSE;
+  priv->event = OS_EVENT_NONE;
+
+  priv->detached_scroll = FALSE;
 
   os_pager_set_detached (priv->pager, FALSE);
 }
@@ -2555,14 +2567,12 @@
       os_root_list = g_list_append (os_root_list, scrollbar);
     }
 
-  priv->button_press_event = FALSE;
-  priv->enter_notify_event = FALSE;
-  priv->motion_notify_event = FALSE;
-  priv->value_changed_event = FALSE;
+  priv->event = OS_EVENT_NONE;
 
   priv->active_window = FALSE;
   priv->can_deactivate_pager = TRUE;
   priv->can_hide = TRUE;
+  priv->detached_scroll = FALSE;
   priv->filter = FALSE;
   priv->fullsize = FALSE;
   priv->internal = FALSE;

=== modified file 'os/os-thumb.c'
--- os/os-thumb.c	2011-06-30 10:52:41 +0000
+++ os/os-thumb.c	2011-07-07 15:06:32 +0000
@@ -56,8 +56,7 @@
   GtkOrientation orientation;
   GtkWidget *grabbed_widget;
   OsAnimation *animation;
-  gboolean button_press_event;
-  gboolean motion_notify_event;
+  OsEvent event;
   gboolean can_rgba;
   gboolean detached;
   gboolean use_tolerance;
@@ -190,8 +189,7 @@
                                              OsThumbPrivate);
   priv = thumb->priv;
 
-  priv->button_press_event = FALSE;
-  priv->motion_notify_event = FALSE;
+  priv->event = OS_EVENT_NONE;
 
   priv->can_rgba = FALSE;
   priv->detached = FALSE;
@@ -245,8 +243,8 @@
           priv->pointer_x = event->x;
           priv->pointer_y = event->y;
 
-          priv->button_press_event = TRUE;
-          priv->motion_notify_event = FALSE;
+          priv->event |= OS_EVENT_BUTTON_PRESS;
+          priv->event &= ~(OS_EVENT_MOTION_NOTIFY);
 
           priv->use_tolerance = TRUE;
 
@@ -276,8 +274,7 @@
         {
           gtk_grab_remove (widget);
 
-          priv->button_press_event = FALSE;
-          priv->motion_notify_event = FALSE;
+          priv->event &= ~(OS_EVENT_BUTTON_PRESS | OS_EVENT_MOTION_NOTIFY);
 
           gtk_widget_queue_draw (widget);
         }
@@ -687,7 +684,8 @@
   else
     pat = cairo_pattern_create_linear (0, 0, width, 0);
 
-  if (priv->button_press_event && !priv->motion_notify_event)
+  if ((priv->event & OS_EVENT_BUTTON_PRESS) &&
+      !(priv->event & OS_EVENT_MOTION_NOTIFY))
     {
       if ((priv->orientation == GTK_ORIENTATION_VERTICAL && (priv->pointer_y < height / 2)) ||
           (priv->orientation == GTK_ORIENTATION_HORIZONTAL && (priv->pointer_x < width / 2)))
@@ -715,7 +713,7 @@
   cairo_set_source (cr, pat);
   cairo_pattern_destroy (pat);
 
-  if (priv->motion_notify_event)
+  if (priv->event & OS_EVENT_MOTION_NOTIFY)
     {
       cairo_fill_preserve (cr);
       set_source_gdk_rgba (cr, &bg_arrow_down, 0.3);
@@ -837,8 +835,8 @@
   /* If we exit the thumb when a button is pressed,
    * there's no need to stop the animation, it should
    * already be stopped.
-   * Stop it only if priv->button_press_event is FALSE. */
-  if (!priv->button_press_event)
+   * Stop it only if OS_EVENT_BUTTON_PRESS is not set. */
+  if (!(priv->event & OS_EVENT_BUTTON_PRESS))
     {
       if (priv->source_id != 0)
         {
@@ -901,9 +899,9 @@
 
   /* If you're not dragging, and you're outside
    * the tolerance pixels, enable the fade-out.
-   * priv->motion_notify_event is TRUE only on dragging,
+   * OS_EVENT_MOTION_NOTIFY is set only on dragging,
    * see code few lines below. */
-  if (!priv->motion_notify_event)
+  if (!(priv->event & OS_EVENT_MOTION_NOTIFY))
   {
     if (!priv->use_tolerance ||
         (abs (priv->pointer_x - event->x) > TOLERANCE_PIXELS ||
@@ -916,12 +914,12 @@
       }
   }
 
-  if (priv->button_press_event)
+  if (priv->event & OS_EVENT_BUTTON_PRESS)
     {
-      if (!priv->motion_notify_event)
+      if (!(priv->event & OS_EVENT_MOTION_NOTIFY))
         gtk_widget_queue_draw (widget);
 
-      priv->motion_notify_event = TRUE;
+      priv->event |= OS_EVENT_MOTION_NOTIFY;
     }
 
   return FALSE;
@@ -988,8 +986,7 @@
   thumb = OS_THUMB (widget);
   priv = thumb->priv;
 
-  priv->button_press_event = FALSE;
-  priv->motion_notify_event = FALSE;
+  priv->event = OS_EVENT_NONE;
 
   priv->use_tolerance = FALSE;
 
@@ -1155,6 +1152,7 @@
   if (priv->detached != detached)
     {
       priv->detached = detached;
+
       gtk_widget_queue_draw (GTK_WIDGET (thumb));
     }
 }