Merge lp:~cimi/overlay-scrollbar/0.2-refactoring into lp:overlay-scrollbar

[Andrea Cimitan]

Functions moved, comments, etc etc...

........(compiles) :D

[lp:~cimi/overlay-scrollbar/0.2-refactoring]

239. By Andrea Cimitan on 2011-05-18

Renamed xevent into xev to save space

[Ted Gould (ted)]

Wow, major reshuffle. Kinda hard to trace everything in the diff, but I couldn't find anything unexpected.

review: Approve

=== modified file 'os/os-animation.c'
--- os/os-animation.c	2011-04-04 16:17:15 +0000
+++ os/os-animation.c	2011-05-18 18:39:29 +0000
@@ -37,45 +37,9 @@
   guint32 source_id;
 };
 
-static gboolean os_animation_update_cb (gpointer user_data);
 static void os_animation_dispose (GObject* object);
 static void os_animation_finalize (GObject* object);
 
-/* Private functions. */
-
-static gboolean
-os_animation_update_cb (gpointer user_data)
-{
-  OsAnimation *animation = OS_ANIMATION (user_data);
-  OsAnimationPrivate *priv = animation->priv;
-  const gint64 current_time = g_get_monotonic_time ();
-  const gint64 end_time = priv->start_time + priv->duration;
-
-  if (current_time < end_time)
-    {
-      /* On-going animation. */
-      const gfloat diff_time = current_time - priv->start_time;
-      const gfloat weight = diff_time / priv->duration;
-
-      priv->update_func (weight, priv->user_data);
-
-      return TRUE;
-    }
-  else
-    {
-      /* Animation ended. */
-      priv->update_func (1.0f, priv->user_data);
-      priv->source_id = 0;
-
-      if (priv->end_func != NULL)
-        priv->end_func (priv->user_data);
-
-      return FALSE;
-    }
-}
-
-/* Type definition. */
-
 G_DEFINE_TYPE (OsAnimation, os_animation, G_TYPE_OBJECT);
 
 static void
@@ -189,6 +153,38 @@
   priv->duration = (gint64) duration * G_GINT64_CONSTANT (1000);
 }
 
+/* callback called by the animation */
+static gboolean
+update_cb (gpointer user_data)
+{
+  OsAnimation *animation = OS_ANIMATION (user_data);
+  OsAnimationPrivate *priv = animation->priv;
+  const gint64 current_time = g_get_monotonic_time ();
+  const gint64 end_time = priv->start_time + priv->duration;
+
+  if (current_time < end_time)
+    {
+      /* On-going animation. */
+      const gfloat diff_time = current_time - priv->start_time;
+      const gfloat weight = diff_time / priv->duration;
+
+      priv->update_func (weight, priv->user_data);
+
+      return TRUE;
+    }
+  else
+    {
+      /* Animation ended. */
+      priv->update_func (1.0f, priv->user_data);
+      priv->source_id = 0;
+
+      if (priv->end_func != NULL)
+        priv->end_func (priv->user_data);
+
+      return FALSE;
+    }
+}
+
 /**
  * os_animation_start:
  * @animation: a #OsAnimation
@@ -207,7 +203,7 @@
   if (priv->source_id == 0)
     {
       priv->start_time = g_get_monotonic_time ();
-      priv->source_id = g_timeout_add (priv->rate, os_animation_update_cb, animation);
+      priv->source_id = g_timeout_add (priv->rate, update_cb, animation);
     }
 }
 
 
=== modified file 'os/os-pager.c'
--- os/os-pager.c	2011-05-12 23:39:33 +0000
+++ os/os-pager.c	2011-05-18 18:39:29 +0000
@@ -49,135 +49,40 @@
   gboolean detached;
   gboolean visible;
   gfloat weight;
-  gint width;
-  gint height;
   gulong handler_id;
 };
 
-static gboolean rectangle_changed (GdkRectangle rectangle1, GdkRectangle rectangle2);
 static void os_pager_dispose (GObject *object);
 static void os_pager_finalize (GObject *object);
-static void os_pager_change_state_cb (gfloat weight, gpointer user_data);
-static void os_pager_create (OsPager *pager);
-static void os_pager_draw (OsPager *pager);
-static void os_pager_draw_connection (OsPager *pager);
-static void os_pager_mask (OsPager *pager);
-static void os_pager_notify_gtk_theme_name_cb (GObject *object, GParamSpec* pspec, gpointer user_data);
 
 /* Private functions */
 
-static gboolean
-rectangle_changed (GdkRectangle rectangle1,
-                   GdkRectangle rectangle2)
-{
-  if (rectangle1.x != rectangle2.x) return TRUE;
-  if (rectangle1.y != rectangle2.y) return TRUE;
-  if (rectangle1.width  != rectangle2.width)  return TRUE;
-  if (rectangle1.height != rectangle2.height) return TRUE;
-
-  return FALSE;
-}
-
-/* Create a pager. */
-static void
-os_pager_create (OsPager *pager)
-{
-  GdkWindowAttr attributes;
-  OsPagerPrivate *priv;
-
-  priv = pager->priv;
-
-  /* Instead reparenting,
-   * which doesn't seem to work well,
-   * destroy the two windows. */
-  if (priv->connection_window != NULL)
-    {
-      /* From the Gdk documentation:
-       * "Note that a window will not be destroyed
-       *  automatically when its reference count
-       *  reaches zero. You must call
-       *  gdk_window_destroy ()
-       *  yourself before that happens". */
-      gdk_window_destroy (priv->connection_window);
-
-      g_object_unref (priv->connection_window);
-      priv->connection_window = NULL;
-    }
-
-  if (priv->pager_window != NULL)
-    {
-      /* From the Gdk documentation:
-       * "Note that a window will not be destroyed
-       *  automatically when its reference count
-       *  reaches zero. You must call
-       *  gdk_window_destroy ()
-       *  yourself before that happens". */
-      gdk_window_destroy (priv->pager_window);
-
-      g_object_unref (priv->pager_window);
-      priv->pager_window = NULL;
-    }
-
-  attributes.width = priv->allocation.width;
-  attributes.height = priv->allocation.height;
-  attributes.wclass = GDK_INPUT_OUTPUT;
-  attributes.window_type = GDK_WINDOW_CHILD;
-  attributes.visual = gtk_widget_get_visual (priv->parent);
-  attributes.colormap = gtk_widget_get_colormap (priv->parent);
-
-  /* connection_window */
-  priv->connection_window = gdk_window_new (gtk_widget_get_window (priv->parent),
-                                            &attributes,
-                                            GDK_WA_VISUAL | GDK_WA_COLORMAP);
-
-  g_object_ref_sink (priv->connection_window);
-
-  gdk_window_set_transient_for (priv->connection_window,
-                                gtk_widget_get_window (priv->parent));
-
-  gdk_window_input_shape_combine_region (priv->connection_window,
-                                         gdk_region_new (),
-                                         0, 0);
-
-  /* pager_window */
-  priv->pager_window = gdk_window_new (gtk_widget_get_window (priv->parent),
-                                       &attributes,
-                                       GDK_WA_VISUAL | GDK_WA_COLORMAP);
-
-  g_object_ref_sink (priv->pager_window);
-
-  /* stay above the connection_window */
-  gdk_window_set_transient_for (priv->pager_window,
-                                priv->connection_window);
-
-  gdk_window_input_shape_combine_region (priv->pager_window,
-                                         gdk_region_new (),
-                                         0, 0);
-}
-
-static void
-os_pager_change_state_cb (gfloat weight,
-                          gpointer user_data)
-{
-  OsPager *pager;
-  OsPagerPrivate *priv;
-
-  pager = OS_PAGER (user_data);
-
-  priv = pager->priv;
-
-  priv->weight = weight;
-
-  if (priv->parent == NULL)
-    return;
-
-  os_pager_draw_connection (pager);
-  os_pager_draw (pager);
-}
-
-/* Draw on the pager_window. */
-static void
-os_pager_draw (OsPager *pager)
+/* draw on the connection_window */
+static void
+draw_connection (OsPager *pager)
+{
+  GdkColor color;
+  OsPagerPrivate *priv;
+
+  priv = pager->priv;
+
+  /* 0.6 is taken from os_thumb_expose. */
+  color.red   = 65535 * 0.6;
+  color.green = 65535 * 0.6;
+  color.blue  = 65535 * 0.6;
+
+  gdk_colormap_alloc_color (gdk_drawable_get_colormap (priv->connection_window), &color, FALSE, TRUE);
+
+  gdk_window_set_background (priv->connection_window, &color);
+
+  gdk_window_clear (priv->connection_window);
+
+  gdk_window_invalidate_rect (gtk_widget_get_window (priv->parent), &priv->allocation, TRUE);
+}
+
+/* draw on the pager_window */
+static void
+draw_pager (OsPager *pager)
 {
   GdkColor c1, c2, color;
   GtkStyle *style;
@@ -214,63 +119,32 @@
   gdk_window_invalidate_rect (gtk_widget_get_window (priv->parent), &priv->allocation, TRUE);
 }
 
-/* Draw on the connection_window. */
-static void
-os_pager_draw_connection (OsPager *pager)
-{
-  GdkColor color;
-  OsPagerPrivate *priv;
-
-  priv = pager->priv;
-
-  /* 0.6 is taken from os_thumb_expose. */
-  color.red   = 65535 * 0.6;
-  color.green = 65535 * 0.6;
-  color.blue  = 65535 * 0.6;
-
-  gdk_colormap_alloc_color (gdk_drawable_get_colormap (priv->connection_window), &color, FALSE, TRUE);
-
-  gdk_window_set_background (priv->connection_window, &color);
-
-  gdk_window_clear (priv->connection_window);
-
-  gdk_window_invalidate_rect (gtk_widget_get_window (priv->parent), &priv->allocation, TRUE);
-}
-
-/* Mask the pager_window. */
-static void
-os_pager_mask (OsPager *pager)
-{
-  OsPagerPrivate *priv;
-
-  priv = pager->priv;
-
-  gdk_window_shape_combine_region (priv->pager_window,
-                                   gdk_region_rectangle (&priv->mask),
-                                   0, 0);
-
-  gdk_window_clear (priv->pager_window);
-}
-
-/* Mask the connection_window. */
-static void
-os_pager_mask_connection (OsPager *pager)
-{
-  OsPagerPrivate *priv;
-
-  priv = pager->priv;
-
-  gdk_window_shape_combine_region (priv->connection_window,
-                                   gdk_region_rectangle (&priv->connection_mask),
-                                   0, 0);
-
-  gdk_window_clear (priv->connection_window);
-}
-
-static void
-os_pager_notify_gtk_theme_name_cb (GObject*    gobject,
-                                   GParamSpec* pspec,
-                                   gpointer    user_data)
+/* callback called by the change-state animation */
+static void
+change_state_cb (gfloat   weight,
+                 gpointer user_data)
+{
+  OsPager *pager;
+  OsPagerPrivate *priv;
+
+  pager = OS_PAGER (user_data);
+
+  priv = pager->priv;
+
+  priv->weight = weight;
+
+  if (priv->parent == NULL)
+    return;
+
+  draw_connection (pager);
+  draw_pager (pager);
+}
+
+/* callback called when the Gtk+ theme changes */
+static void
+notify_gtk_theme_name_cb (GObject*    gobject,
+                          GParamSpec* pspec,
+                          gpointer    user_data)
 {
   OsPager *pager;
   OsPagerPrivate *priv;
@@ -283,11 +157,22 @@
       priv->connection_window == NULL)
     return;
 
-  os_pager_draw_connection (pager);
-  os_pager_draw (pager);
-}
-
-/* Type definition. */
+  draw_connection (pager);
+  draw_pager (pager);
+}
+
+/* check if two GdkRectangle are different */
+static gboolean
+rectangle_changed (GdkRectangle rectangle1,
+                   GdkRectangle rectangle2)
+{
+  if (rectangle1.x != rectangle2.x) return TRUE;
+  if (rectangle1.y != rectangle2.y) return TRUE;
+  if (rectangle1.width  != rectangle2.width)  return TRUE;
+  if (rectangle1.height != rectangle2.height) return TRUE;
+
+  return FALSE;
+}
 
 G_DEFINE_TYPE (OsPager, os_pager, G_TYPE_OBJECT);
 
@@ -335,10 +220,10 @@
   priv->weight = 1.0f;
 
   priv->animation = os_animation_new (RATE_FADE, DURATION_FADE_OUT,
-                                      os_pager_change_state_cb, NULL, pager);
+                                      change_state_cb, NULL, pager);
 
   priv->handler_id = g_signal_connect (gtk_settings_get_default (), "notify::gtk-theme-name",
-                                       G_CALLBACK (os_pager_notify_gtk_theme_name_cb), pager);
+                                       G_CALLBACK (notify_gtk_theme_name_cb), pager);
 }
 
 static void
@@ -413,6 +298,21 @@
   return g_object_new (OS_TYPE_PAGER, NULL);
 }
 
+/* move a mask on the connection_window, fake movement */
+static void
+mask_connection (OsPager *pager)
+{
+  OsPagerPrivate *priv;
+
+  priv = pager->priv;
+
+  gdk_window_shape_combine_region (priv->connection_window,
+                                   gdk_region_rectangle (&priv->connection_mask),
+                                   0, 0);
+
+  gdk_window_clear (priv->connection_window);
+}
+
 /**
  * os_pager_connect:
  * @pager: a #OsPager
@@ -438,7 +338,7 @@
   if (priv->parent == NULL)
     return;
 
-  os_pager_mask_connection (pager);
+  mask_connection (pager);
 }
 
 /**
@@ -468,6 +368,21 @@
   gdk_window_hide (priv->pager_window);
 }
 
+/* move a mask on the pager_window, fake movement */
+static void
+mask_pager (OsPager *pager)
+{
+  OsPagerPrivate *priv;
+
+  priv = pager->priv;
+
+  gdk_window_shape_combine_region (priv->pager_window,
+                                   gdk_region_rectangle (&priv->mask),
+                                   0, 0);
+
+  gdk_window_clear (priv->pager_window);
+}
+
 /**
  * os_pager_move_resize:
  * @pager: a #OsPager
@@ -493,7 +408,7 @@
   if (priv->parent == NULL)
     return;
 
-  os_pager_mask (pager);
+  mask_pager (pager);
 }
 
 /**
@@ -534,7 +449,7 @@
         {
           priv->weight = 1.0f;
 
-          os_pager_draw (pager);
+          draw_pager (pager);
         }
     }
 }
@@ -574,6 +489,83 @@
     }
 }
 
+/* create connection_window and pager_window */
+static void
+create_windows (OsPager *pager)
+{
+  GdkWindowAttr attributes;
+  OsPagerPrivate *priv;
+
+  priv = pager->priv;
+
+  /* Instead reparenting,
+   * which doesn't seem to work well,
+   * destroy the two windows. */
+  if (priv->connection_window != NULL)
+    {
+      /* From the Gdk documentation:
+       * "Note that a window will not be destroyed
+       *  automatically when its reference count
+       *  reaches zero. You must call
+       *  gdk_window_destroy ()
+       *  yourself before that happens". */
+      gdk_window_destroy (priv->connection_window);
+
+      g_object_unref (priv->connection_window);
+      priv->connection_window = NULL;
+    }
+
+  if (priv->pager_window != NULL)
+    {
+      /* From the Gdk documentation:
+       * "Note that a window will not be destroyed
+       *  automatically when its reference count
+       *  reaches zero. You must call
+       *  gdk_window_destroy ()
+       *  yourself before that happens". */
+      gdk_window_destroy (priv->pager_window);
+
+      g_object_unref (priv->pager_window);
+      priv->pager_window = NULL;
+    }
+
+  attributes.width = priv->allocation.width;
+  attributes.height = priv->allocation.height;
+  attributes.wclass = GDK_INPUT_OUTPUT;
+  attributes.window_type = GDK_WINDOW_CHILD;
+  attributes.visual = gtk_widget_get_visual (priv->parent);
+  attributes.colormap = gtk_widget_get_colormap (priv->parent);
+
+  /* connection_window */
+  priv->connection_window = gdk_window_new (gtk_widget_get_window (priv->parent),
+                                            &attributes,
+                                            GDK_WA_VISUAL | GDK_WA_COLORMAP);
+
+  g_object_ref_sink (priv->connection_window);
+
+  gdk_window_set_transient_for (priv->connection_window,
+                                gtk_widget_get_window (priv->parent));
+
+  gdk_window_input_shape_combine_region (priv->connection_window,
+                                         gdk_region_new (),
+                                         0, 0);
+
+  /* pager_window */
+  priv->pager_window = gdk_window_new (gtk_widget_get_window (priv->parent),
+                                       &attributes,
+                                       GDK_WA_VISUAL | GDK_WA_COLORMAP);
+
+  g_object_ref_sink (priv->pager_window);
+
+  /* stay above the connection_window */
+  gdk_window_set_transient_for (priv->pager_window,
+                                priv->connection_window);
+
+  gdk_window_input_shape_combine_region (priv->pager_window,
+                                         gdk_region_new (),
+                                         0, 0);
+}
+
 /**
  * os_pager_set_parent:
  * @pager: a #OsPager
@@ -608,10 +600,10 @@
 
       priv->weight = 1.0f;
 
-      os_pager_create (pager);
-      os_pager_draw_connection (pager);
-      os_pager_draw (pager);
-      os_pager_mask (pager);
+      create_windows (pager);
+      draw_connection (pager);
+      draw_pager (pager);
+      mask_pager (pager);
 
       gdk_window_move_resize (priv->connection_window,
                               priv->allocation.x,
 
=== modified file 'os/os-scrollbar.c'
--- os/os-scrollbar.c	2011-05-17 20:54:31 +0000
+++ os/os-scrollbar.c	2011-05-18 18:39:29 +0000
@@ -65,12 +65,12 @@
   gboolean active_window;
   gboolean can_deactivate_pager;
   gboolean can_hide;
-  gboolean toplevel_button_press;
   gboolean filter;
   gboolean fullsize;
   gboolean internal;
   gboolean lock_position;
   gboolean proximity;
+  gboolean toplevel_button_press;
   gint win_x;
   gint win_y;
   gint slide_initial_slider_position;
@@ -86,7 +86,20 @@
 static Atom net_active_window_atom = None;
 static GList *os_root_list = NULL;
 
+static void swap_adjustment (OsScrollbar *scrollbar, GtkAdjustment *adjustment);
+static void swap_thumb (OsScrollbar *scrollbar, GtkWidget *thumb);
+static void adjustment_changed_cb (GtkAdjustment *adjustment, gpointer user_data);
+static void adjustment_value_changed_cb (GtkAdjustment *adjustment, gpointer user_data);
+static gboolean thumb_button_press_event_cb (GtkWidget *widget, GdkEventButton *event, gpointer user_data);
+static gboolean thumb_button_release_event_cb (GtkWidget *widget, GdkEventButton *event, gpointer user_data);
+static gboolean thumb_enter_notify_event_cb (GtkWidget *widget, GdkEventCrossing *event, gpointer user_data);
+static gboolean thumb_leave_notify_event_cb (GtkWidget *widget, GdkEventCrossing *event, gpointer user_data);
+static void thumb_map_cb (GtkWidget *widget, gpointer user_data);
+static gboolean thumb_motion_notify_event_cb (GtkWidget *widget, GdkEventMotion *event, gpointer user_data);
+static gboolean thumb_scroll_event_cb (GtkWidget *widget, GdkEventScroll *event, gpointer user_data);
+static void thumb_unmap_cb (GtkWidget *widget, gpointer user_data);
 static gboolean os_scrollbar_expose_event (GtkWidget *widget, GdkEventExpose *event);
+
 static void os_scrollbar_grab_notify (GtkWidget *widget, gboolean was_grabbed);
 static void os_scrollbar_hide (GtkWidget *widget);
 static void os_scrollbar_map (GtkWidget *widget);
@@ -98,98 +111,13 @@
 static void os_scrollbar_unrealize (GtkWidget *widget);
 static void os_scrollbar_dispose (GObject *object);
 static void os_scrollbar_finalize (GObject *object);
-static void os_scrollbar_calc_layout_pager (OsScrollbar *scrollbar, gdouble adjustment_value);
-static void os_scrollbar_calc_layout_slider (OsScrollbar *scrollbar, gdouble adjustment_value);
-static gdouble os_scrollbar_coord_to_value (OsScrollbar *scrollbar, gint coord);
-static void os_scrollbar_deactivate_pager (OsScrollbar *scrollbar);
-static gboolean os_scrollbar_deactivate_pager_cb (gpointer user_data);
-static gdouble os_scrollbar_get_wheel_delta (OsScrollbar *scrollbar, GdkScrollDirection direction);
-static void os_scrollbar_hide_thumb (OsScrollbar *scrollbar);
-static gboolean os_scrollbar_hide_thumb_cb (gpointer user_data);
-static gboolean os_scrollbar_unlock_thumb_cb (gpointer user_data);
-static void os_scrollbar_move (OsScrollbar *scrollbar, gint mouse_x, gint mouse_y);
-static void os_scrollbar_move_thumb (OsScrollbar *scrollbar, gint x, gint y);
-static void os_scrollbar_notify_adjustment_cb (GObject *object, gpointer user_data);
-static void os_scrollbar_notify_orientation_cb (GObject *object, gpointer user_data);
-static gint os_scrollbar_sanitize_x (OsScrollbar *scrollbar, gint x, gint y);
-static gint os_scrollbar_sanitize_y (OsScrollbar *scrollbar, gint x, gint y);
-static void os_scrollbar_store_window_position (OsScrollbar *scrollbar);
-static void os_scrollbar_swap_adjustment (OsScrollbar *scrollbar, GtkAdjustment *adjustment);
-static void os_scrollbar_swap_thumb (OsScrollbar *scrollbar, GtkWidget *thumb);
-static gboolean thumb_button_press_event_cb (GtkWidget *widget, GdkEventButton *event, gpointer user_data);
-static gboolean thumb_button_release_event_cb (GtkWidget *widget, GdkEventButton *event, gpointer user_data);
-static gboolean thumb_enter_notify_event_cb (GtkWidget *widget, GdkEventCrossing *event, gpointer user_data);
-static gboolean thumb_leave_notify_event_cb (GtkWidget *widget, GdkEventCrossing *event, gpointer user_data);
-static void thumb_map_cb (GtkWidget *widget, gpointer user_data);
-static gboolean thumb_motion_notify_event_cb (GtkWidget *widget, GdkEventMotion *event, gpointer user_data);
-static gboolean thumb_scroll_event_cb (GtkWidget *widget, GdkEventScroll *event, gpointer user_data);
-static void thumb_unmap_cb (GtkWidget *widget, gpointer user_data);
-static void pager_move (OsScrollbar *scrollbar);
-static void pager_set_state_from_pointer (OsScrollbar *scrollbar, gint x, gint y);
-static void adjustment_changed_cb (GtkAdjustment *adjustment, gpointer user_data);
-static void adjustment_value_changed_cb (GtkAdjustment *adjustment, gpointer user_data);
-static GdkFilterReturn root_filter_func (GdkXEvent *gdkxevent, GdkEvent *event, gpointer user_data);
-static void root_gfunc (gpointer data, gpointer user_data);
-static gboolean toplevel_configure_event_cb (GtkWidget *widget, GdkEventConfigure *event, gpointer user_data);
-static GdkFilterReturn toplevel_filter_func (GdkXEvent *gdkxevent, GdkEvent *event, gpointer user_data);
 
 /* Private functions. */
 
-/* Present a X11 window. */
-static void
-os_present_window_with_timestamp (Screen  *screen,
-                                  gint     xid,
-                                  guint32  timestamp)
-{
-  Display *display;
-  Window root;
-  XEvent xev;
-
-  if (timestamp == 0)
-    g_warning ("Received a timestamp of 0; window activation may not "
-               "function properly.\n");
-
-  display = DisplayOfScreen (screen);
-  root = RootWindowOfScreen (screen);
-
-  xev.xclient.type = ClientMessage;
-  xev.xclient.serial = 0;
-  xev.xclient.send_event = True;
-  xev.xclient.display = display;
-  xev.xclient.window = xid;
-  xev.xclient.message_type = gdk_x11_get_xatom_by_name ("_NET_ACTIVE_WINDOW");
-  xev.xclient.format = 32;
-  xev.xclient.data.l[0] = 1;
-  xev.xclient.data.l[1] = timestamp;
-  xev.xclient.data.l[2] = 0;
-  xev.xclient.data.l[3] = 0;
-  xev.xclient.data.l[4] = 0;
-
-  gdk_error_trap_push ();
-
-  XSendEvent (display, root, False,
-              SubstructureRedirectMask | SubstructureNotifyMask,
-              &xev);
-
-  gdk_flush ();
-
-  gdk_error_trap_pop ();
-}
-
-/* Present a GDK window. */
-static void
-os_present_gdk_window_with_timestamp (GtkWidget *widget,
-                                      guint32    timestamp)
-{
-  os_present_window_with_timestamp (GDK_SCREEN_XSCREEN (gtk_widget_get_screen (widget)),
-                                    GDK_WINDOW_XID (gtk_widget_get_window (widget)),
-                                    timestamp);
-}
-
-/* Calculate layout and store info. */
-static void
-os_scrollbar_calc_layout_pager (OsScrollbar *scrollbar,
-                                gdouble      adjustment_value)
+/* calculate pager layout info */
+static void
+calc_layout_pager (OsScrollbar *scrollbar,
+                   gdouble      adjustment_value)
 {
   OsScrollbarPrivate *priv;
 
@@ -261,10 +189,10 @@
     }
 }
 
-/* Calculate OsScrollbar layout and store info. */
+/* calculate slider (thumb) layout info */
 static void
-os_scrollbar_calc_layout_slider (OsScrollbar *scrollbar,
-                                 gdouble      adjustment_value)
+calc_layout_slider (OsScrollbar *scrollbar,
+                    gdouble      adjustment_value)
 {
   OsScrollbarPrivate *priv;
 
@@ -316,51 +244,9 @@
     }
 }
 
-/* Traduce pixels into proper values. */
-static gdouble
-os_scrollbar_coord_to_value (OsScrollbar *scrollbar,
-                             gint         coord)
-{
-  OsScrollbarPrivate *priv;
-  gdouble frac;
-  gdouble value;
-  gint    trough_length;
-  gint    trough_start;
-  gint    slider_length;
-
-  priv = scrollbar->priv;
-
-  if (priv->orientation == GTK_ORIENTATION_VERTICAL)
-    {
-      trough_length = priv->trough.height;
-      trough_start  = priv->trough.y;
-      slider_length = MAX (priv->slider.height, priv->overlay.height);
-    }
-  else
-    {
-      trough_length = priv->trough.width;
-      trough_start  = priv->trough.y;
-      slider_length = MAX (priv->slider.width, priv->overlay.width);
-    }
-
-  if (trough_length == slider_length)
-    frac = 1.0;
-  else
-    frac = (MAX (0, coord - trough_start) /
-            (gdouble) (trough_length - slider_length));
-
-  value = priv->adjustment->lower + frac * (priv->adjustment->upper -
-                                            priv->adjustment->lower -
-                                            priv->adjustment->page_size);
-
-  value = CLAMP (value, priv->adjustment->lower, priv->adjustment->upper - priv->adjustment->page_size);
-
-  return value;
-}
-
-/* Deactivate pager if it's ok to make it inactive. */
+/* deactivate the pager if it's the case */
 static void
-os_scrollbar_deactivate_pager (OsScrollbar *scrollbar)
+deactivate_pager (OsScrollbar *scrollbar)
 {
   OsScrollbarPrivate *priv;
 
@@ -370,8 +256,9 @@
     os_pager_set_active (OS_PAGER (priv->pager), FALSE);
 }
 
+/* timeout before deactivating the pager */
 static gboolean
-os_scrollbar_deactivate_pager_cb (gpointer user_data)
+deactivate_pager_cb (gpointer user_data)
 {
   OsScrollbar *scrollbar;
   OsScrollbarPrivate *priv;
@@ -381,33 +268,15 @@
 
   OS_DCHECK (!priv->active_window);
 
-  os_scrollbar_deactivate_pager (scrollbar);
+  deactivate_pager (scrollbar);
   priv->source_deactivate_pager_id = 0;
 
   return FALSE;
 }
 
-static gdouble
-os_scrollbar_get_wheel_delta (OsScrollbar       *scrollbar,
-                              GdkScrollDirection direction)
-{
-  OsScrollbarPrivate *priv;
-  gdouble delta;
-
-  priv = scrollbar->priv;
-
-  delta = pow (priv->adjustment->page_size, 2.0 / 3.0);
-
-  if (direction == GDK_SCROLL_UP ||
-      direction == GDK_SCROLL_LEFT)
-    delta = - delta;
-
-  return delta;
-}
-
-/* Hide if it's ok to hide. */
+/* hide the thumb if it's the case */
 static void
-os_scrollbar_hide_thumb (OsScrollbar *scrollbar)
+hide_thumb (OsScrollbar *scrollbar)
 {
   OsScrollbarPrivate *priv;
 
@@ -420,8 +289,9 @@
     }
 }
 
+/* timeout before hiding the thumb */
 static gboolean
-os_scrollbar_hide_thumb_cb (gpointer user_data)
+hide_thumb_cb (gpointer user_data)
 {
   OsScrollbar *scrollbar;
   OsScrollbarPrivate *priv;
@@ -429,97 +299,44 @@
   scrollbar = OS_SCROLLBAR (user_data);
   priv = scrollbar->priv;
 
-  os_scrollbar_hide_thumb (scrollbar);
+  hide_thumb (scrollbar);
   priv->source_hide_thumb_id = 0;
 
   return FALSE;
 }
 
-static gboolean
-os_scrollbar_unlock_thumb_cb (gpointer user_data)
-{
-  OsScrollbar *scrollbar;
-  OsScrollbarPrivate *priv;
-
-  scrollbar = OS_SCROLLBAR (user_data);
-  priv = scrollbar->priv;
-
-  if (priv->can_hide)
-    priv->lock_position = FALSE;
-
-  priv->source_unlock_thumb_id = 0;
-
-  return FALSE;
-}
-
+/* move the pager */
 static void
-os_scrollbar_move (OsScrollbar *scrollbar,
-                   gint         mouse_x,
-                   gint         mouse_y)
+move_pager (OsScrollbar *scrollbar)
 {
+  GdkRectangle mask;
   OsScrollbarPrivate *priv;
-  gint delta;
-  gint c;
-  gdouble new_value;
 
   priv = scrollbar->priv;
 
   if (priv->orientation == GTK_ORIENTATION_VERTICAL)
-    delta = mouse_y - priv->slide_initial_coordinate;
+    {
+      mask.x = 0;
+      mask.y = priv->overlay.y;
+      mask.width = DEFAULT_PAGER_WIDTH;
+      mask.height = priv->overlay.height;
+    }
   else
-    delta = mouse_x - priv->slide_initial_coordinate;
-
-  c = priv->slide_initial_slider_position + delta;
-
-  new_value = os_scrollbar_coord_to_value (scrollbar, c);
-
-  gtk_adjustment_set_value (priv->adjustment, new_value);
-}
-
-static void
-os_scrollbar_move_thumb (OsScrollbar *scrollbar,
-                         gint         x,
-                         gint         y)
-{
-  OsScrollbarPrivate *priv;
-
-  priv = scrollbar->priv;
-
-  gtk_window_move (GTK_WINDOW (priv->thumb),
-                   os_scrollbar_sanitize_x (scrollbar, x, y),
-                   os_scrollbar_sanitize_y (scrollbar, x, y));
-}
-
-static void
-os_scrollbar_notify_adjustment_cb (GObject *object,
-                                   gpointer user_data)
-{
-  OsScrollbar *scrollbar;
-
-  scrollbar = OS_SCROLLBAR (object);
-
-  os_scrollbar_swap_adjustment (scrollbar, gtk_range_get_adjustment (GTK_RANGE (object)));
-}
-
-static void
-os_scrollbar_notify_orientation_cb (GObject *object,
-                                    gpointer user_data)
-{
-  OsScrollbar *scrollbar;
-  OsScrollbarPrivate *priv;
-
-  scrollbar = OS_SCROLLBAR (object);
-  priv = scrollbar->priv;
-
-  priv->orientation = gtk_orientable_get_orientation (GTK_ORIENTABLE (object));
-
-  os_scrollbar_swap_thumb (scrollbar, os_thumb_new (priv->orientation));
-}
-
+    {
+      mask.x = priv->overlay.x;
+      mask.y = 0;
+      mask.width = priv->overlay.width;
+      mask.height = DEFAULT_PAGER_WIDTH;
+    }
+
+  os_pager_move_resize (OS_PAGER (priv->pager), mask);
+}
+
+/* sanitize x coordinate of thumb window */
 static gint
-os_scrollbar_sanitize_x (OsScrollbar *scrollbar,
-                         gint         x,
-                         gint         y)
+sanitize_x (OsScrollbar *scrollbar,
+            gint         x,
+            gint         y)
 {
   GdkRectangle rect;
   OsScrollbarPrivate *priv;
@@ -550,10 +367,11 @@
   return x;
 }
 
+/* sanitize y coordinate of thumb window */
 static gint
-os_scrollbar_sanitize_y (OsScrollbar *scrollbar,
-                         gint         x,
-                         gint         y)
+sanitize_y (OsScrollbar *scrollbar,
+            gint         x,
+            gint         y)
 {
   GdkRectangle rect;
   OsScrollbarPrivate *priv;
@@ -584,33 +402,53 @@
   return y;
 }
 
-/* Store scrollbar window position. */
-static void
-os_scrollbar_store_window_position (OsScrollbar *scrollbar)
-{
-  OsScrollbarPrivate *priv;
-  gint win_x, win_y;
-
-  priv = scrollbar->priv;
-
-  gdk_window_get_origin (gtk_widget_get_window (GTK_WIDGET (scrollbar)), &win_x, &win_y);
-
-  if (priv->orientation == GTK_ORIENTATION_VERTICAL)
-    {
-      priv->win_x = win_x + priv->thumb_all.x;
-      priv->win_y = win_y + priv->thumb_all.y;
-    }
-  else
-    {
-      priv->win_x = win_x + priv->thumb_all.x;
-      priv->win_y = win_y + priv->thumb_all.y;
-    }
-}
-
-/* Swap the adjustment pointer. */
-static void
-os_scrollbar_swap_adjustment (OsScrollbar   *scrollbar,
-                              GtkAdjustment *adjustment)
+/* move the thumb window */
+static void
+move_thumb (OsScrollbar *scrollbar,
+            gint         x,
+            gint         y)
+{
+  OsScrollbarPrivate *priv;
+
+  priv = scrollbar->priv;
+
+  gtk_window_move (GTK_WINDOW (priv->thumb),
+                   sanitize_x (scrollbar, x, y),
+                   sanitize_y (scrollbar, x, y));
+}
+
+/* callback called when the adjustment changes */
+static void
+notify_adjustment_cb (GObject *object,
+                      gpointer user_data)
+{
+  OsScrollbar *scrollbar;
+
+  scrollbar = OS_SCROLLBAR (object);
+
+  swap_adjustment (scrollbar, gtk_range_get_adjustment (GTK_RANGE (object)));
+}
+
+/* callback called when the orientation changes */
+static void
+notify_orientation_cb (GObject *object,
+                       gpointer user_data)
+{
+  OsScrollbar *scrollbar;
+  OsScrollbarPrivate *priv;
+
+  scrollbar = OS_SCROLLBAR (object);
+  priv = scrollbar->priv;
+
+  priv->orientation = gtk_orientable_get_orientation (GTK_ORIENTABLE (object));
+
+  swap_thumb (scrollbar, os_thumb_new (priv->orientation));
+}
+
+/* swap adjustment pointer */
+static void
+swap_adjustment (OsScrollbar   *scrollbar,
+                 GtkAdjustment *adjustment)
 {
   OsScrollbarPrivate *priv;
 
@@ -639,10 +477,10 @@
     }
 }
 
-/* Swap the thumb pointer. */
+/* swap thumb pointer */
 static void
-os_scrollbar_swap_thumb (OsScrollbar *scrollbar,
-                         GtkWidget   *thumb)
+swap_thumb (OsScrollbar *scrollbar,
+            GtkWidget   *thumb)
 {
   OsScrollbarPrivate *priv;
 
@@ -697,6 +535,353 @@
     }
 }
 
+/* timeout before unlocking the thumb */
+static gboolean
+unlock_thumb_cb (gpointer user_data)
+{
+  OsScrollbar *scrollbar;
+  OsScrollbarPrivate *priv;
+
+  scrollbar = OS_SCROLLBAR (user_data);
+  priv = scrollbar->priv;
+
+  if (priv->can_hide)
+    priv->lock_position = FALSE;
+
+  priv->source_unlock_thumb_id = 0;
+
+  return FALSE;
+}
+
+/* adjustment functions */
+
+static void
+adjustment_changed_cb (GtkAdjustment *adjustment,
+                       gpointer       user_data)
+{
+  OsScrollbar *scrollbar;
+  OsScrollbarPrivate *priv;
+
+  scrollbar = OS_SCROLLBAR (user_data);
+  priv = scrollbar->priv;
+
+  /* FIXME(Cimi) we should control each time os_pager_show()/hide()
+   * is called here and in map()/unmap().
+   * We are arbitrary calling that and I'm frightened we should show or keep
+   * hidden a pager that is meant to be hidden/shown.
+   * I don't want to see pagers reappearing because
+   * of a change in the adjustment of an invisible pager or viceversa. */
+  if ((adjustment->upper - adjustment->lower) > adjustment->page_size)
+    {
+      priv->fullsize = FALSE;
+      if (priv->proximity != FALSE)
+        os_pager_show (OS_PAGER (priv->pager));
+    }
+  else
+    {
+      priv->fullsize = TRUE;
+      if (priv->proximity != FALSE)
+        {
+          os_pager_hide (OS_PAGER (priv->pager));
+
+          gtk_widget_hide (priv->thumb);
+        }
+    }
+
+  calc_layout_pager (scrollbar, adjustment->value);
+  calc_layout_slider (scrollbar, adjustment->value);
+
+  if (!priv->motion_notify_event && !priv->enter_notify_event)
+    gtk_widget_hide (GTK_WIDGET (priv->thumb));
+
+  move_pager (scrollbar);
+}
+
+static void
+adjustment_value_changed_cb (GtkAdjustment *adjustment,
+                             gpointer       user_data)
+{
+  OsScrollbar *scrollbar;
+  OsScrollbarPrivate *priv;
+
+  scrollbar = OS_SCROLLBAR (user_data);
+  priv = scrollbar->priv;
+
+  calc_layout_pager (scrollbar, adjustment->value);
+  calc_layout_slider (scrollbar, adjustment->value);
+
+  if (!priv->motion_notify_event && !priv->enter_notify_event)
+    gtk_widget_hide (GTK_WIDGET (priv->thumb));
+
+  if (gtk_widget_get_mapped (GTK_WIDGET (priv->thumb)))
+    {
+      /* if we're dragging the thumb, it can't be detached. */
+      if (priv->motion_notify_event)
+        {
+          os_pager_set_detached (OS_PAGER (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 (GTK_WIDGET (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 = DEFAULT_PAGER_WIDTH;
+                  mask.height = priv->overlay.y - mask.y;
+
+                  os_pager_connect (OS_PAGER (priv->pager), mask);
+                  os_pager_set_detached (OS_PAGER (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 = DEFAULT_PAGER_WIDTH;
+                  mask.height = y_pos + priv->slider.height / 2 - priv->win_y - mask.y;
+
+                  os_pager_connect (OS_PAGER (priv->pager), mask);
+                  os_pager_set_detached (OS_PAGER (priv->pager), TRUE);
+
+                  os_thumb_set_detached (OS_THUMB (priv->thumb), TRUE);
+                }
+              else 
+                {
+                  os_pager_set_detached (OS_PAGER (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 = DEFAULT_PAGER_WIDTH;
+
+                  os_pager_connect (OS_PAGER (priv->pager), mask);
+                  os_pager_set_detached (OS_PAGER (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.y + priv->overlay.height;
+                  mask.y = 0;
+                  mask.width = x_pos + priv->slider.width / 2 - priv->win_x - mask.x;
+                  mask.height = DEFAULT_PAGER_WIDTH;
+
+                  os_pager_connect (OS_PAGER (priv->pager), mask);
+                  os_pager_set_detached (OS_PAGER (priv->pager), TRUE);                
+                }
+              else
+                {
+                  os_pager_set_detached (OS_PAGER (priv->pager), FALSE);
+                  os_thumb_set_detached (OS_THUMB (priv->thumb), FALSE);
+                }
+            }
+        }
+    }
+
+  move_pager (scrollbar);
+}
+
+/* pager functions */
+
+/* set the state of the pager checking mouse position */
+static void
+pager_set_state_from_pointer (OsScrollbar *scrollbar,
+                              gint         x,
+                              gint         y)
+{
+  GtkAllocation allocation;
+  OsScrollbarPrivate *priv;
+
+  priv = scrollbar->priv;
+
+  OS_DCHECK (!priv->active_window);
+
+  gtk_widget_get_allocation (gtk_widget_get_parent (GTK_WIDGET (scrollbar)), &allocation);
+
+  if ((x > allocation.x && x < allocation.x + allocation.width) &&
+      (y > allocation.y && y < allocation.y + allocation.height))
+    {
+      priv->can_deactivate_pager = FALSE;
+      os_pager_set_active (OS_PAGER (priv->pager), TRUE);
+    }
+  else
+    {
+      priv->can_deactivate_pager = TRUE;
+      os_pager_set_active (OS_PAGER (priv->pager), FALSE);
+    }
+}
+
+/* root window functions */
+
+/* react on active window changes */
+static void
+root_gfunc (gpointer data,
+            gpointer user_data)
+{
+  OsScrollbar *scrollbar;
+  OsScrollbarPrivate *priv;
+
+  scrollbar = OS_SCROLLBAR (data);
+  priv = scrollbar->priv;
+
+  OS_DCHECK (scrollbar != NULL);
+
+  if (gtk_widget_get_mapped (GTK_WIDGET (scrollbar)))
+    {
+      if (gtk_widget_get_window (gtk_widget_get_toplevel (GTK_WIDGET (scrollbar))) ==
+          gdk_screen_get_active_window (gtk_widget_get_screen (GTK_WIDGET (scrollbar))))
+        {
+          /* stops potential running timeout. */
+          if (priv->source_deactivate_pager_id != 0)
+            {
+              g_source_remove (priv->source_deactivate_pager_id);
+              priv->source_deactivate_pager_id = 0;
+            }
+
+          priv->active_window = TRUE;
+
+          priv->can_deactivate_pager = FALSE;
+          os_pager_set_active (OS_PAGER (priv->pager), TRUE);
+        }
+      else if (priv->active_window)
+        {
+          GdkWindow *parent;
+          GdkWindow *window;
+          const gint64 current_time = g_get_monotonic_time ();
+          const gint64 end_time = priv->present_time + TIMEOUT_PRESENT_WINDOW * 1000;
+
+          priv->active_window = FALSE;
+
+          /* loop through parent windows until it reaches
+           * either an unknown GdkWindow (NULL),
+           * or the toplevel window. */
+          window = gtk_widget_get_window (GTK_WIDGET (scrollbar));
+          parent = gdk_window_at_pointer (NULL, NULL);
+          while (parent != NULL)
+            {
+              if (window == parent)
+                break;
+
+              parent = gdk_window_get_parent (parent);
+            }
+
+          if (parent != NULL)
+            {
+              gint x, y;
+
+              gdk_window_get_pointer (window, &x, &y, NULL);
+
+              /* when the window is unfocused,
+               * check the position of the pointer
+               * and set the state accordingly. */
+              pager_set_state_from_pointer (scrollbar, x, y);
+            }
+          else
+            {
+              /* if the pointer is outside of the window, set it inactive. */
+              priv->can_deactivate_pager = TRUE;
+              os_pager_set_active (OS_PAGER (priv->pager), FALSE);
+            }
+
+          if ((current_time > end_time) && priv->thumb != NULL)
+            gtk_widget_hide (priv->thumb);
+        }
+    }
+}
+
+/* filter function applied to the root window */
+static GdkFilterReturn
+root_filter_func (GdkXEvent *gdkxevent,
+                  GdkEvent  *event,
+                  gpointer   user_data)
+{
+  XEvent* xev;
+
+  xev = gdkxevent;
+
+  if (xev->xany.type == PropertyNotify &&
+      xev->xproperty.atom == net_active_window_atom)
+    {
+      g_list_foreach (os_root_list, root_gfunc, NULL);
+    }
+
+  return GDK_FILTER_CONTINUE;
+}
+
+/* thumb functions */
+
+/* present a X11 window */
+static void
+present_window_with_timestamp (Screen  *screen,
+                               gint     xid,
+                               guint32  timestamp)
+{
+  Display *display;
+  Window root;
+  XEvent xev;
+
+  if (timestamp == 0)
+    g_warning ("Received a timestamp of 0; window activation may not "
+               "function properly.\n");
+
+  display = DisplayOfScreen (screen);
+  root = RootWindowOfScreen (screen);
+
+  xev.xclient.type = ClientMessage;
+  xev.xclient.serial = 0;
+  xev.xclient.send_event = True;
+  xev.xclient.display = display;
+  xev.xclient.window = xid;
+  xev.xclient.message_type = gdk_x11_get_xatom_by_name ("_NET_ACTIVE_WINDOW");
+  xev.xclient.format = 32;
+  xev.xclient.data.l[0] = 1;
+  xev.xclient.data.l[1] = timestamp;
+  xev.xclient.data.l[2] = 0;
+  xev.xclient.data.l[3] = 0;
+  xev.xclient.data.l[4] = 0;
+
+  gdk_error_trap_push ();
+
+  XSendEvent (display, root, False,
+              SubstructureRedirectMask | SubstructureNotifyMask,
+              &xev);
+
+  gdk_flush ();
+
+  gdk_error_trap_pop ();
+}
+
+/* present a Gdk window */
+static void
+present_gdk_window_with_timestamp (GtkWidget *widget,
+                                   guint32    timestamp)
+{
+  present_window_with_timestamp (GDK_SCREEN_XSCREEN (gtk_widget_get_screen (widget)),
+                                 GDK_WINDOW_XID (gtk_widget_get_window (widget)),
+                                 timestamp);
+}
+
 static gboolean
 thumb_button_press_event_cb (GtkWidget      *widget,
                              GdkEventButton *event,
@@ -716,7 +901,7 @@
                                         GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (scrollbar))));
 
           priv->present_time = g_get_monotonic_time ();
-          os_present_gdk_window_with_timestamp (GTK_WIDGET (scrollbar), event->time);
+          present_gdk_window_with_timestamp (GTK_WIDGET (scrollbar), event->time);
 
           priv->button_press_event = TRUE;
           priv->motion_notify_event = FALSE;
@@ -830,7 +1015,7 @@
             g_source_remove (priv->source_deactivate_pager_id);
 
           priv->source_deactivate_pager_id = g_timeout_add (TIMEOUT_THUMB_HIDE,
-                                                            os_scrollbar_deactivate_pager_cb,
+                                                            deactivate_pager_cb,
                                                             scrollbar);
         }
 
@@ -840,7 +1025,7 @@
         g_source_remove (priv->source_hide_thumb_id);
 
       priv->source_hide_thumb_id = g_timeout_add (TIMEOUT_THUMB_HIDE,
-                                                  os_scrollbar_hide_thumb_cb,
+                                                  hide_thumb_cb,
                                                   scrollbar);
     }
 
@@ -916,6 +1101,73 @@
     }
 }
 
+/* traduce coordinates into GtkRange values */
+static gdouble
+coord_to_value (OsScrollbar *scrollbar,
+                gint         coord)
+{
+  OsScrollbarPrivate *priv;
+  gdouble frac;
+  gdouble value;
+  gint    trough_length;
+  gint    trough_start;
+  gint    slider_length;
+
+  priv = scrollbar->priv;
+
+  if (priv->orientation == GTK_ORIENTATION_VERTICAL)
+    {
+      trough_length = priv->trough.height;
+      trough_start  = priv->trough.y;
+      slider_length = MAX (priv->slider.height, priv->overlay.height);
+    }
+  else
+    {
+      trough_length = priv->trough.width;
+      trough_start  = priv->trough.y;
+      slider_length = MAX (priv->slider.width, priv->overlay.width);
+    }
+
+  if (trough_length == slider_length)
+    frac = 1.0;
+  else
+    frac = (MAX (0, coord - trough_start) /
+            (gdouble) (trough_length - slider_length));
+
+  value = priv->adjustment->lower + frac * (priv->adjustment->upper -
+                                            priv->adjustment->lower -
+                                            priv->adjustment->page_size);
+
+  value = CLAMP (value, priv->adjustment->lower, priv->adjustment->upper - priv->adjustment->page_size);
+
+  return value;
+}
+
+/* from pointer movement, set GtkRange value */
+static void
+capture_movement (OsScrollbar *scrollbar,
+                  gint         mouse_x,
+                  gint         mouse_y)
+{
+  OsScrollbarPrivate *priv;
+  gint delta;
+  gint c;
+  gdouble 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;
+
+  new_value = coord_to_value (scrollbar, c);
+
+  gtk_adjustment_set_value (priv->adjustment, new_value);
+}
+
 static gboolean
 thumb_motion_notify_event_cb (GtkWidget      *widget,
                               GdkEventMotion *event,
@@ -945,13 +1197,14 @@
               priv->slide_initial_coordinate = event->x_root;
             }
 
-          os_scrollbar_move (scrollbar, event->x_root, event->y_root);
+          /* FIXME(Cimi) seems useless. */
+          capture_movement (scrollbar, event->x_root, event->y_root);
           priv->value_changed_event = FALSE;
         }
 
       priv->motion_notify_event = TRUE;
 
-      os_scrollbar_move (scrollbar, event->x_root, event->y_root);
+      capture_movement (scrollbar, event->x_root, event->y_root);
 
       if (priv->orientation == GTK_ORIENTATION_VERTICAL)
         {
@@ -1006,12 +1259,31 @@
             }
         }
 
-      os_scrollbar_move_thumb (scrollbar, x, y);
+      move_thumb (scrollbar, x, y);
     }
 
   return FALSE;
 }
 
+/* mouse wheel delta */
+static gdouble
+get_wheel_delta (OsScrollbar       *scrollbar,
+                 GdkScrollDirection direction)
+{
+  OsScrollbarPrivate *priv;
+  gdouble delta;
+
+  priv = scrollbar->priv;
+
+  delta = pow (priv->adjustment->page_size, 2.0 / 3.0);
+
+  if (direction == GDK_SCROLL_UP ||
+      direction == GDK_SCROLL_LEFT)
+    delta = - delta;
+
+  return delta;
+}
+
 static gboolean
 thumb_scroll_event_cb (GtkWidget      *widget,
                        GdkEventScroll *event,
@@ -1026,7 +1298,7 @@
 
   priv->value_changed_event = TRUE;
 
-  delta = os_scrollbar_get_wheel_delta (scrollbar, event->direction);
+  delta = get_wheel_delta (scrollbar, event->direction);
 
   gtk_adjustment_set_value (priv->adjustment,
                             CLAMP (priv->adjustment->value + delta,
@@ -1054,297 +1326,30 @@
   os_pager_set_detached (OS_PAGER (priv->pager), FALSE);
 }
 
-/* Move the pager to the right position. */
+/* toplevel functions */
+
+/* store the position of the toplevel window */
 static void
-pager_move (OsScrollbar *scrollbar)
+store_toplevel_position (OsScrollbar *scrollbar)
 {
-  GdkRectangle mask;
   OsScrollbarPrivate *priv;
+  gint win_x, win_y;
 
   priv = scrollbar->priv;
 
+  /* In reality, I'm storing widget's window, not the toplevel.
+   * Is that the same with gdk_window_get_origin? */
+  gdk_window_get_origin (gtk_widget_get_window (GTK_WIDGET (scrollbar)), &win_x, &win_y);
+
   if (priv->orientation == GTK_ORIENTATION_VERTICAL)
     {
-      mask.x = 0;
-      mask.y = priv->overlay.y;
-      mask.width = DEFAULT_PAGER_WIDTH;
-      mask.height = priv->overlay.height;
-    }
-  else
-    {
-      mask.x = priv->overlay.x;
-      mask.y = 0;
-      mask.width = priv->overlay.width;
-      mask.height = DEFAULT_PAGER_WIDTH;
-    }
-
-  os_pager_move_resize (OS_PAGER (priv->pager), mask);
-}
-
-static void
-pager_set_state_from_pointer (OsScrollbar *scrollbar,
-                              gint x,
-                              gint y)
-{
-  GtkAllocation allocation;
-  OsScrollbarPrivate *priv;
-
-  priv = scrollbar->priv;
-
-  OS_DCHECK (!priv->active_window);
-
-  gtk_widget_get_allocation (gtk_widget_get_parent (GTK_WIDGET (scrollbar)), &allocation);
-
-  if ((x > allocation.x && x < allocation.x + allocation.width) &&
-      (y > allocation.y && y < allocation.y + allocation.height))
-    {
-      priv->can_deactivate_pager = FALSE;
-      os_pager_set_active (OS_PAGER (priv->pager), TRUE);
-    }
-  else
-    {
-      priv->can_deactivate_pager = TRUE;
-      os_pager_set_active (OS_PAGER (priv->pager), FALSE);
-    }
-}
-
-static void
-adjustment_changed_cb (GtkAdjustment *adjustment,
-                       gpointer       user_data)
-{
-  OsScrollbar *scrollbar;
-  OsScrollbarPrivate *priv;
-
-  scrollbar = OS_SCROLLBAR (user_data);
-  priv = scrollbar->priv;
-
-  /* FIXME(Cimi) we should control each time os_pager_show()/hide()
-   * is called here and in map()/unmap().
-   * We are arbitrary calling that and I'm frightened we should show or keep
-   * hidden a pager that is meant to be hidden/shown.
-   * I don't want to see pagers reappearing because
-   * of a change in the adjustment of an invisible pager or viceversa. */
-  if ((adjustment->upper - adjustment->lower) > adjustment->page_size)
-    {
-      priv->fullsize = FALSE;
-      if (priv->proximity != FALSE)
-        os_pager_show (OS_PAGER (priv->pager));
-    }
-  else
-    {
-      priv->fullsize = TRUE;
-      if (priv->proximity != FALSE)
-        {
-          os_pager_hide (OS_PAGER (priv->pager));
-
-          gtk_widget_hide (priv->thumb);
-        }
-    }
-
-  os_scrollbar_calc_layout_pager (scrollbar, adjustment->value);
-  os_scrollbar_calc_layout_slider (scrollbar, adjustment->value);
-
-  if (!priv->motion_notify_event && !priv->enter_notify_event)
-    gtk_widget_hide (GTK_WIDGET (priv->thumb));
-
-  pager_move (scrollbar);
-}
-
-static void
-adjustment_value_changed_cb (GtkAdjustment *adjustment,
-                             gpointer       user_data)
-{
-  OsScrollbar *scrollbar;
-  OsScrollbarPrivate *priv;
-
-  scrollbar = OS_SCROLLBAR (user_data);
-  priv = scrollbar->priv;
-
-  os_scrollbar_calc_layout_pager (scrollbar, adjustment->value);
-  os_scrollbar_calc_layout_slider (scrollbar, adjustment->value);
-
-  if (!priv->motion_notify_event && !priv->enter_notify_event)
-    gtk_widget_hide (GTK_WIDGET (priv->thumb));
-
-  if (gtk_widget_get_mapped (GTK_WIDGET (priv->thumb)))
-    {
-      /* if we're dragging the thumb, it can't be detached. */
-      if (priv->motion_notify_event)
-        {
-          os_pager_set_detached (OS_PAGER (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 (GTK_WIDGET (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 = DEFAULT_PAGER_WIDTH;
-                  mask.height = priv->overlay.y - mask.y;
-
-                  os_pager_connect (OS_PAGER (priv->pager), mask);
-                  os_pager_set_detached (OS_PAGER (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 = DEFAULT_PAGER_WIDTH;
-                  mask.height = y_pos + priv->slider.height / 2 - priv->win_y - mask.y;
-
-                  os_pager_connect (OS_PAGER (priv->pager), mask);
-                  os_pager_set_detached (OS_PAGER (priv->pager), TRUE);
-
-                  os_thumb_set_detached (OS_THUMB (priv->thumb), TRUE);
-                }
-              else 
-                {
-                  os_pager_set_detached (OS_PAGER (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 = DEFAULT_PAGER_WIDTH;
-
-                  os_pager_connect (OS_PAGER (priv->pager), mask);
-                  os_pager_set_detached (OS_PAGER (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.y + priv->overlay.height;
-                  mask.y = 0;
-                  mask.width = x_pos + priv->slider.width / 2 - priv->win_x - mask.x;
-                  mask.height = DEFAULT_PAGER_WIDTH;
-
-                  os_pager_connect (OS_PAGER (priv->pager), mask);
-                  os_pager_set_detached (OS_PAGER (priv->pager), TRUE);                
-                }
-              else
-                {
-                  os_pager_set_detached (OS_PAGER (priv->pager), FALSE);
-                  os_thumb_set_detached (OS_THUMB (priv->thumb), FALSE);
-                }
-            }
-        }
-    }
-
-  pager_move (scrollbar);
-}
-
-static GdkFilterReturn
-root_filter_func (GdkXEvent *gdkxevent,
-                  GdkEvent  *event,
-                  gpointer   user_data)
-{
-  XEvent* xevent;
-
-  xevent = gdkxevent;
-
-  if (xevent->xany.type == PropertyNotify &&
-      xevent->xproperty.atom == net_active_window_atom)
-    {
-      g_list_foreach (os_root_list, root_gfunc, NULL);
-    }
-
-  return GDK_FILTER_CONTINUE;
-}
-
-static void
-root_gfunc (gpointer data,
-            gpointer user_data)
-{
-  OsScrollbar *scrollbar;
-  OsScrollbarPrivate *priv;
-
-  scrollbar = OS_SCROLLBAR (data);
-  priv = scrollbar->priv;
-
-  OS_DCHECK (scrollbar != NULL);
-
-  if (gtk_widget_get_mapped (GTK_WIDGET (scrollbar)))
-    {
-      if (gtk_widget_get_window (gtk_widget_get_toplevel (GTK_WIDGET (scrollbar))) ==
-          gdk_screen_get_active_window (gtk_widget_get_screen (GTK_WIDGET (scrollbar))))
-        {
-          /* stops potential running timeout. */
-          if (priv->source_deactivate_pager_id != 0)
-            {
-              g_source_remove (priv->source_deactivate_pager_id);
-              priv->source_deactivate_pager_id = 0;
-            }
-
-          priv->active_window = TRUE;
-
-          priv->can_deactivate_pager = FALSE;
-          os_pager_set_active (OS_PAGER (priv->pager), TRUE);
-        }
-      else if (priv->active_window)
-        {
-          GdkWindow *parent;
-          GdkWindow *window;
-          const gint64 current_time = g_get_monotonic_time ();
-          const gint64 end_time = priv->present_time + TIMEOUT_PRESENT_WINDOW * 1000;
-
-          priv->active_window = FALSE;
-
-          /* loop through parent windows until it reaches
-           * either an unknown GdkWindow (NULL),
-           * or the toplevel window. */
-          window = gtk_widget_get_window (GTK_WIDGET (scrollbar));
-          parent = gdk_window_at_pointer (NULL, NULL);
-          while (parent != NULL)
-            {
-              if (window == parent)
-                break;
-
-              parent = gdk_window_get_parent (parent);
-            }
-
-          if (parent != NULL)
-            {
-              gint x, y;
-
-              gdk_window_get_pointer (window, &x, &y, NULL);
-
-              /* when the window is unfocused,
-               * check the position of the pointer
-               * and set the state accordingly. */
-              pager_set_state_from_pointer (scrollbar, x, y);
-            }
-          else
-            {
-              /* if the pointer is outside of the window, set it inactive. */
-              priv->can_deactivate_pager = TRUE;
-              os_pager_set_active (OS_PAGER (priv->pager), FALSE);
-            }
-
-          if ((current_time > end_time) && priv->thumb != NULL)
-            gtk_widget_hide (priv->thumb);
-        }
+      priv->win_x = win_x + priv->thumb_all.x;
+      priv->win_y = win_y + priv->thumb_all.y;
+    }
+  else
+    {
+      priv->win_x = win_x + priv->thumb_all.x;
+      priv->win_y = win_y + priv->thumb_all.y;
     }
 }
 
@@ -1405,15 +1410,15 @@
 
   priv->lock_position = FALSE;
 
-  os_scrollbar_calc_layout_pager (scrollbar, priv->adjustment->value);
-  os_scrollbar_calc_layout_slider (scrollbar, priv->adjustment->value);
+  calc_layout_pager (scrollbar, priv->adjustment->value);
+  calc_layout_slider (scrollbar, priv->adjustment->value);
 
-  os_scrollbar_store_window_position (scrollbar);
+  store_toplevel_position (scrollbar);
 
   return FALSE;
 }
 
-/* Add a filter to the toplevel GdkWindow, to activate proximity effect. */
+/* filter function applied to the toplevel window */
 static GdkFilterReturn
 toplevel_filter_func (GdkXEvent *gdkxevent,
                       GdkEvent  *event,
@@ -1421,37 +1426,37 @@
 {
   OsScrollbar *scrollbar;
   OsScrollbarPrivate *priv;
-  XEvent *xevent;
+  XEvent *xev;
 
   g_return_val_if_fail (OS_SCROLLBAR (user_data), GDK_FILTER_CONTINUE);
 
   scrollbar = OS_SCROLLBAR (user_data);
 
   priv = scrollbar->priv;
-  xevent = gdkxevent;
+  xev = gdkxevent;
 
   g_return_val_if_fail (priv->pager != NULL, GDK_FILTER_CONTINUE);
   g_return_val_if_fail (priv->thumb != NULL, GDK_FILTER_CONTINUE);
 
   if (!priv->fullsize)
     {
-      if (xevent->type == ButtonPress)
+      if (xev->type == ButtonPress)
         {
           priv->toplevel_button_press = TRUE;
           gtk_widget_hide (priv->thumb);
         }
 
-      if (priv->toplevel_button_press && xevent->type == ButtonRelease)
+      if (priv->toplevel_button_press && xev->type == ButtonRelease)
         {
           priv->toplevel_button_press = FALSE;
 
           /* proximity area */
           if (priv->orientation == GTK_ORIENTATION_VERTICAL)
             {
-              if ((priv->thumb_all.x - xevent->xbutton.x <= PROXIMITY_WIDTH &&
-                   priv->thumb_all.x - xevent->xbutton.x >= 0) &&
-                  (xevent->xbutton.y >= priv->thumb_all.y + priv->overlay.y &&
-                   xevent->xbutton.y <= priv->thumb_all.y + priv->overlay.y + priv->overlay.height))
+              if ((priv->thumb_all.x - xev->xbutton.x <= PROXIMITY_WIDTH &&
+                   priv->thumb_all.x - xev->xbutton.x >= 0) &&
+                  (xev->xbutton.y >= priv->thumb_all.y + priv->overlay.y &&
+                   xev->xbutton.y <= priv->thumb_all.y + priv->overlay.y + priv->overlay.height))
                 {
                   priv->can_hide = FALSE;
 
@@ -1465,15 +1470,15 @@
                       gdk_window_get_origin (gtk_widget_get_window (GTK_WIDGET (scrollbar)), &x_pos, &y_pos);
 
                       x = priv->thumb_all.x;
-                      y = CLAMP (xevent->xbutton.y - priv->slider.height / 2,
+                      y = CLAMP (xev->xbutton.y - priv->slider.height / 2,
                                  priv->thumb_all.y + priv->overlay.y,
                                  priv->thumb_all.y + priv->overlay.y + priv->overlay.height - priv->slider.height);
 
-                      os_scrollbar_move_thumb (scrollbar, x_pos + x, y_pos + y);
+                      move_thumb (scrollbar, x_pos + x, y_pos + y);
                     }
                   else
                     {
-                      os_scrollbar_move_thumb (scrollbar, priv->win_x, priv->win_y + priv->slider.y);
+                      move_thumb (scrollbar, priv->win_x, priv->win_y + priv->slider.y);
                     }
 
                   gtk_widget_show (GTK_WIDGET (priv->thumb));
@@ -1481,10 +1486,10 @@
             }
           else
             {
-              if ((priv->thumb_all.y - xevent->xbutton.y <= PROXIMITY_WIDTH &&
-                   priv->thumb_all.y - xevent->xbutton.y >= 0) &&
-                  (xevent->xbutton.x >= priv->thumb_all.x + priv->overlay.x &&
-                   xevent->xbutton.x <= priv->thumb_all.x + priv->overlay.x + priv->overlay.width))
+              if ((priv->thumb_all.y - xev->xbutton.y <= PROXIMITY_WIDTH &&
+                   priv->thumb_all.y - xev->xbutton.y >= 0) &&
+                  (xev->xbutton.x >= priv->thumb_all.x + priv->overlay.x &&
+                   xev->xbutton.x <= priv->thumb_all.x + priv->overlay.x + priv->overlay.width))
                 {
                   priv->can_hide = FALSE;
 
@@ -1497,16 +1502,16 @@
 
                       gdk_window_get_origin (gtk_widget_get_window (GTK_WIDGET (scrollbar)), &x_pos, &y_pos);
 
-                      x = CLAMP (xevent->xbutton.x - priv->slider.width / 2,
+                      x = CLAMP (xev->xbutton.x - priv->slider.width / 2,
                                  priv->thumb_all.x + priv->overlay.x,
                                  priv->thumb_all.x + priv->overlay.x + priv->overlay.width - priv->slider.width);
                       y = priv->thumb_all.y;
 
-                      os_scrollbar_move_thumb (scrollbar, x_pos + x, y_pos + y);
+                      move_thumb (scrollbar, x_pos + x, y_pos + y);
                     }
                   else
                     {
-                      os_scrollbar_move_thumb (scrollbar, priv->win_x, priv->win_y + priv->slider.y);
+                      move_thumb (scrollbar, priv->win_x, priv->win_y + priv->slider.y);
                     }
 
                   gtk_widget_show (GTK_WIDGET (priv->thumb));
@@ -1520,10 +1525,10 @@
        * this call checks the pointer after the scroll-event,
        * since it enters the window,
        * then sets the state accordingly. */
-      if (!priv->active_window && xevent->type == EnterNotify)
-        pager_set_state_from_pointer (scrollbar, xevent->xcrossing.x, xevent->xcrossing.y);
+      if (!priv->active_window && xev->type == EnterNotify)
+        pager_set_state_from_pointer (scrollbar, xev->xcrossing.x, xev->xcrossing.y);
 
-      if (xevent->type == LeaveNotify)
+      if (xev->type == LeaveNotify)
         {
           /* never deactivate the pager in an active window. */
           if (!priv->active_window)
@@ -1534,7 +1539,7 @@
                 g_source_remove (priv->source_deactivate_pager_id);
 
               priv->source_deactivate_pager_id = g_timeout_add (TIMEOUT_TOPLEVEL_HIDE,
-                                                                os_scrollbar_deactivate_pager_cb,
+                                                                deactivate_pager_cb,
                                                                 scrollbar);
             }
 
@@ -1545,32 +1550,32 @@
             g_source_remove (priv->source_hide_thumb_id);
 
           priv->source_hide_thumb_id = g_timeout_add (TIMEOUT_TOPLEVEL_HIDE,
-                                                      os_scrollbar_hide_thumb_cb,
+                                                      hide_thumb_cb,
                                                       scrollbar);
 
           if (priv->source_unlock_thumb_id != 0)
             g_source_remove (priv->source_unlock_thumb_id);
 
           priv->source_unlock_thumb_id = g_timeout_add (TIMEOUT_TOPLEVEL_HIDE,
-                                                        os_scrollbar_unlock_thumb_cb,
+                                                        unlock_thumb_cb,
                                                         scrollbar);
         }
 
       /* get the motion_notify_event trough XEvent */
-      if (!priv->toplevel_button_press && xevent->type == MotionNotify)
+      if (!priv->toplevel_button_press && xev->type == MotionNotify)
         {
           /* react to motion_notify_event
            * and set the state accordingly. */
           if (!priv->active_window)
-            pager_set_state_from_pointer (scrollbar, xevent->xmotion.x, xevent->xmotion.y);
+            pager_set_state_from_pointer (scrollbar, xev->xmotion.x, xev->xmotion.y);
 
           /* proximity area */
           if (priv->orientation == GTK_ORIENTATION_VERTICAL)
             {
-              if ((priv->thumb_all.x - xevent->xmotion.x <= PROXIMITY_WIDTH &&
-                   priv->thumb_all.x - xevent->xmotion.x >= 0) &&
-                  (xevent->xmotion.y >= priv->thumb_all.y + priv->overlay.y &&
-                   xevent->xmotion.y <= priv->thumb_all.y + priv->overlay.y + priv->overlay.height))
+              if ((priv->thumb_all.x - xev->xmotion.x <= PROXIMITY_WIDTH &&
+                   priv->thumb_all.x - xev->xmotion.x >= 0) &&
+                  (xev->xmotion.y >= priv->thumb_all.y + priv->overlay.y &&
+                   xev->xmotion.y <= priv->thumb_all.y + priv->overlay.y + priv->overlay.height))
                 {
                   priv->can_hide = FALSE;
 
@@ -1584,15 +1589,15 @@
                       gdk_window_get_origin (gtk_widget_get_window (GTK_WIDGET (scrollbar)), &x_pos, &y_pos);
 
                       x = priv->thumb_all.x;
-                      y = CLAMP (xevent->xmotion.y - priv->slider.height / 2,
+                      y = CLAMP (xev->xmotion.y - priv->slider.height / 2,
                                  priv->thumb_all.y + priv->overlay.y,
                                  priv->thumb_all.y + priv->overlay.y + priv->overlay.height - priv->slider.height);
 
-                      os_scrollbar_move_thumb (scrollbar, x_pos + x, y_pos + y);
+                      move_thumb (scrollbar, x_pos + x, y_pos + y);
                     }
                   else
                     {
-                      os_scrollbar_move_thumb (scrollbar, priv->win_x, priv->win_y + priv->slider.y);
+                      move_thumb (scrollbar, priv->win_x, priv->win_y + priv->slider.y);
                     }
 
                   os_pager_set_detached (OS_PAGER (priv->pager), FALSE);
@@ -1603,15 +1608,15 @@
                 {
                   priv->can_hide = TRUE;
                   priv->lock_position = FALSE;
-                  os_scrollbar_hide_thumb (scrollbar);
+                  hide_thumb (scrollbar);
                 }
             }
           else
             {
-              if ((priv->thumb_all.y - xevent->xmotion.y <= PROXIMITY_WIDTH &&
-                   priv->thumb_all.y - xevent->xmotion.y >= 0) &&
-                  (xevent->xmotion.x >= priv->thumb_all.x + priv->overlay.x &&
-                   xevent->xmotion.x <= priv->thumb_all.x + priv->overlay.x + priv->overlay.width))
+              if ((priv->thumb_all.y - xev->xmotion.y <= PROXIMITY_WIDTH &&
+                   priv->thumb_all.y - xev->xmotion.y >= 0) &&
+                  (xev->xmotion.x >= priv->thumb_all.x + priv->overlay.x &&
+                   xev->xmotion.x <= priv->thumb_all.x + priv->overlay.x + priv->overlay.width))
                 {
                   priv->can_hide = FALSE;
 
@@ -1624,16 +1629,16 @@
 
                       gdk_window_get_origin (gtk_widget_get_window (GTK_WIDGET (scrollbar)), &x_pos, &y_pos);
 
-                      x = CLAMP (xevent->xmotion.x - priv->slider.width / 2,
+                      x = CLAMP (xev->xmotion.x - priv->slider.width / 2,
                                  priv->thumb_all.x + priv->overlay.x,
                                  priv->thumb_all.x + priv->overlay.x + priv->overlay.width - priv->slider.width);
                       y = priv->thumb_all.y;
 
-                      os_scrollbar_move_thumb (scrollbar, x_pos + x, y_pos + y);
+                      move_thumb (scrollbar, x_pos + x, y_pos + y);
                     }
                   else
                     {
-                      os_scrollbar_move_thumb (scrollbar, priv->win_x + priv->slider.x, priv->win_y);
+                      move_thumb (scrollbar, priv->win_x + priv->slider.x, priv->win_y);
                     }
 
                   os_pager_set_detached (OS_PAGER (priv->pager), FALSE);
@@ -1644,7 +1649,7 @@
                 {
                   priv->can_hide = TRUE;
                   priv->lock_position = FALSE;
-                  os_scrollbar_hide_thumb (scrollbar);
+                  hide_thumb (scrollbar);
                 }
             }
         }
@@ -1653,8 +1658,6 @@
   return GDK_FILTER_CONTINUE;
 }
 
-/* Type definition. */
-
 G_DEFINE_TYPE (OsScrollbar, os_scrollbar, GTK_TYPE_SCROLLBAR);
 
 static void
@@ -1717,6 +1720,11 @@
       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->active_window = FALSE;
   priv->can_deactivate_pager = TRUE;
   priv->can_hide = TRUE;
@@ -1733,10 +1741,10 @@
   priv->pager = os_pager_new ();
 
   g_signal_connect (G_OBJECT (scrollbar), "notify::adjustment",
-                    G_CALLBACK (os_scrollbar_notify_adjustment_cb), NULL);
+                    G_CALLBACK (notify_adjustment_cb), NULL);
 
   g_signal_connect (G_OBJECT (scrollbar), "notify::orientation",
-                    G_CALLBACK (os_scrollbar_notify_orientation_cb), NULL);
+                    G_CALLBACK (notify_orientation_cb), NULL);
 }
 
 static void
@@ -1778,8 +1786,8 @@
       priv->pager = NULL;
     }
 
-  os_scrollbar_swap_adjustment (scrollbar, NULL);
-  os_scrollbar_swap_thumb (scrollbar, NULL);
+  swap_adjustment (scrollbar, NULL);
+  swap_thumb (scrollbar, NULL);
 
   G_OBJECT_CLASS (os_scrollbar_parent_class)->dispose (object);
 }
@@ -1892,11 +1900,11 @@
   g_signal_connect (G_OBJECT (gtk_widget_get_toplevel (widget)), "configure-event",
                     G_CALLBACK (toplevel_configure_event_cb), scrollbar);
 
-  os_scrollbar_calc_layout_pager (scrollbar, priv->adjustment->value);
+  calc_layout_pager (scrollbar, priv->adjustment->value);
 
   os_pager_set_parent (OS_PAGER (priv->pager), widget);
 
-  os_scrollbar_store_window_position (scrollbar);
+  store_toplevel_position (scrollbar);
 }
 
 static void
@@ -1955,16 +1963,16 @@
 
   if (priv->adjustment != NULL)
     {
-      os_scrollbar_calc_layout_pager (scrollbar, priv->adjustment->value);
-      os_scrollbar_calc_layout_slider (scrollbar, priv->adjustment->value);
+      calc_layout_pager (scrollbar, priv->adjustment->value);
+      calc_layout_slider (scrollbar, priv->adjustment->value);
     }
 
   os_pager_size_allocate (OS_PAGER (priv->pager), rect);
 
-  pager_move (scrollbar);
+  move_pager (scrollbar);
 
   if (gtk_widget_get_realized (widget))
-    os_scrollbar_store_window_position (scrollbar);
+    store_toplevel_position (scrollbar);
 
   widget->allocation = *allocation;
 }
 
=== modified file 'os/os-thumb.c'
--- os/os-thumb.c	2011-05-17 22:10:53 +0000
+++ os/os-thumb.c	2011-05-18 18:39:29 +0000
@@ -50,8 +50,8 @@
   gboolean button_press_event;
   gboolean motion_notify_event;
   gboolean can_rgba;
+  gboolean detached;
   gboolean use_tolerance;
-  gboolean detached;
   gint pointer_x;
   gint pointer_y;
   guint32 source_id;
@@ -63,8 +63,6 @@
   LAST_ARG
 };
 
-static void os_thumb_fade_out_cb (gfloat weight, gpointer user_data);
-static gboolean os_thumb_timeout_fade_out_cb (gpointer user_data);
 static gboolean os_thumb_button_press_event (GtkWidget *widget, GdkEventButton *event);
 static gboolean os_thumb_button_release_event (GtkWidget *widget, GdkEventButton *event);
 static void os_thumb_composited_changed (GtkWidget *widget);
@@ -81,61 +79,12 @@
 static void os_thumb_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec);
 static void os_thumb_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec);
 
-/* Private functions. */
-
-/* Draw an arror. */
-static void
-os_cairo_draw_arrow (cairo_t *cr,
-                     gdouble  x,
-                     gdouble  y,
-                     gdouble  width,
-                     gdouble  height)
-{
-  cairo_save (cr);
-
-  cairo_translate (cr, x, y);
-  cairo_move_to (cr, -width / 2, -height / 2);
-  cairo_line_to (cr, 0, height / 2);
-  cairo_line_to (cr, width / 2, -height / 2);
-  cairo_close_path (cr);
-
-  cairo_set_source_rgba (cr, 0.3, 0.3, 0.3, 0.75);
-  cairo_fill_preserve (cr);
-
-  cairo_set_source_rgba (cr, 0.3, 0.3, 0.3, 1.0);
-  cairo_stroke (cr);
-
-  cairo_restore (cr);
-}
-
-/* Draw a rounded rectangle. */
-static void
-os_cairo_draw_rounded_rect (cairo_t *cr,
-                            gdouble  x,
-                            gdouble  y,
-                            gdouble  width,
-                            gdouble  height,
-                            gdouble  radius)
-{
-  if (radius < 1)
-    {
-      cairo_rectangle (cr, x, y, width, height);
-      return;
-    }
-
-  radius = MIN (radius, MIN (width / 2.0, height / 2.0));
-
-  cairo_move_to (cr, x + radius, y);
-
-  cairo_arc (cr, x + width - radius, y + radius, radius, G_PI * 1.5, G_PI * 2);
-  cairo_arc (cr, x + width - radius, y + height - radius, radius, 0, G_PI * 0.5);
-  cairo_arc (cr, x + radius, y + height - radius, radius, G_PI * 0.5, G_PI);
-  cairo_arc (cr, x + radius, y + radius, radius, G_PI, G_PI * 1.5);
-}
-
-static void
-os_thumb_fade_out_cb (gfloat weight,
-                      gpointer user_data)
+/* Private functions */
+
+/* callback called by the fade-out animation */
+static void
+fade_out_cb (gfloat   weight,
+             gpointer user_data)
 {
   OsThumb *thumb;
 
@@ -147,8 +96,9 @@
     gtk_widget_hide (GTK_WIDGET (thumb));
 }
 
+/* timeout before starting the fade-out animation */
 static gboolean
-os_thumb_timeout_fade_out_cb (gpointer user_data)
+timeout_fade_out_cb (gpointer user_data)
 {
   OsThumb *thumb;
   OsThumbPrivate *priv;
@@ -163,8 +113,6 @@
   return FALSE;
 }
 
-/* Type definition. */
-
 G_DEFINE_TYPE (OsThumb, os_thumb, GTK_TYPE_WINDOW);
 
 static void
@@ -214,16 +162,19 @@
                                              OsThumbPrivate);
   priv = thumb->priv;
 
+  priv->button_press_event = FALSE;
+  priv->motion_notify_event = FALSE;
+
   priv->can_rgba = FALSE;
   priv->detached = FALSE;
+  priv->use_tolerance = FALSE;
 
   priv->source_id = 0;
   priv->animation = os_animation_new (RATE_FADE_OUT, DURATION_FADE_OUT,
-                                      os_thumb_fade_out_cb, NULL, thumb);
+                                      fade_out_cb, NULL, thumb);
 
   gtk_window_set_skip_pager_hint (GTK_WINDOW (thumb), TRUE);
   gtk_window_set_skip_taskbar_hint (GTK_WINDOW (thumb), TRUE);
-  /* gtk_window_set_has_resize_grip (GTK_WINDOW (thumb), FALSE); */
   gtk_window_set_decorated (GTK_WINDOW (thumb), FALSE);
   gtk_window_set_focus_on_map (GTK_WINDOW (thumb), FALSE);
   gtk_window_set_accept_focus (GTK_WINDOW (thumb), FALSE);
@@ -237,43 +188,6 @@
   os_thumb_composited_changed (GTK_WIDGET (thumb));
 }
 
-static void
-os_thumb_dispose (GObject *object)
-{
-  OsThumb *thumb;
-  OsThumbPrivate *priv;
-
-  thumb = OS_THUMB (object);
-  priv = thumb->priv;
-
-  if (priv->source_id != 0)
-    {
-      g_source_remove (priv->source_id);
-      priv->source_id = 0;
-    }
-
-  if (priv->animation != NULL)
-    {
-      g_object_unref (priv->animation);
-      priv->animation = NULL;
-    }
-
-  if (priv->grabbed_widget != NULL)
-    {
-      g_object_unref (priv->grabbed_widget);
-      priv->grabbed_widget = NULL;
-    }
-
-  G_OBJECT_CLASS (os_thumb_parent_class)->dispose (object);
-}
-
-static void
-os_thumb_finalize (GObject *object)
-{
-  G_OBJECT_CLASS (os_thumb_parent_class)->finalize (object);
-}
-
-
 static gboolean
 os_thumb_button_press_event (GtkWidget      *widget,
                              GdkEventButton *event)
@@ -371,6 +285,56 @@
   gtk_widget_queue_draw (widget);
 }
 
+/* draw an arrow using cairo */
+static void
+draw_arrow (cairo_t *cr,
+            gdouble  x,
+            gdouble  y,
+            gdouble  width,
+            gdouble  height)
+{
+  cairo_save (cr);
+
+  cairo_translate (cr, x, y);
+  cairo_move_to (cr, -width / 2, -height / 2);
+  cairo_line_to (cr, 0, height / 2);
+  cairo_line_to (cr, width / 2, -height / 2);
+  cairo_close_path (cr);
+
+  cairo_set_source_rgba (cr, 0.3, 0.3, 0.3, 0.75);
+  cairo_fill_preserve (cr);
+
+  cairo_set_source_rgba (cr, 0.3, 0.3, 0.3, 1.0);
+  cairo_stroke (cr);
+
+  cairo_restore (cr);
+}
+
+/* draw a rounded rectangle using cairo */
+static void
+draw_round_rect (cairo_t *cr,
+                 gdouble  x,
+                 gdouble  y,
+                 gdouble  width,
+                 gdouble  height,
+                 gdouble  radius)
+{
+  radius = MIN (radius, MIN (width / 2.0, height / 2.0));
+
+  if (radius < 1)
+    {
+      cairo_rectangle (cr, x, y, width, height);
+      return;
+    }
+
+  cairo_move_to (cr, x + radius, y);
+
+  cairo_arc (cr, x + width - radius, y + radius, radius, G_PI * 1.5, G_PI * 2);
+  cairo_arc (cr, x + width - radius, y + height - radius, radius, 0, G_PI * 0.5);
+  cairo_arc (cr, x + radius, y + height - radius, radius, G_PI * 0.5, G_PI);
+  cairo_arc (cr, x + radius, y + radius, radius, G_PI, G_PI * 1.5);
+}
+
 static gboolean
 os_thumb_expose (GtkWidget      *widget,
                  GdkEventExpose *event)
@@ -413,7 +377,7 @@
   cairo_set_line_width (cr, 1);
   cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
 
-  os_cairo_draw_rounded_rect (cr, x, y, width, height, radius);
+  draw_round_rect (cr, x, y, width, height, radius);
 
   if (priv->orientation == GTK_ORIENTATION_VERTICAL)
     pat = cairo_pattern_create_linear (x, y, width + x, y);
@@ -426,7 +390,7 @@
   cairo_pattern_destroy (pat);
   cairo_fill (cr);
 
-  os_cairo_draw_rounded_rect (cr, x, y, width, height, radius);
+  draw_round_rect (cr, x, y, width, height, radius);
 
   if (priv->orientation == GTK_ORIENTATION_VERTICAL)
     pat = cairo_pattern_create_linear (x, y, x, height + y);
@@ -461,7 +425,6 @@
   cairo_set_source (cr, pat);
   cairo_pattern_destroy (pat);
 
-
   if (priv->motion_notify_event)
     {
       cairo_fill_preserve (cr);
@@ -472,7 +435,7 @@
     cairo_fill (cr);
 
   cairo_set_line_width (cr, 2.0);
-  os_cairo_draw_rounded_rect (cr, x + 0.5, y + 0.5, width - 1, height - 1, radius - 1);
+  draw_round_rect (cr, x + 0.5, y + 0.5, width - 1, height - 1, radius - 1);
   if (!priv->detached)
     cairo_set_source_rgba (cr, style->bg[GTK_STATE_SELECTED].red/65535.0,
                                style->bg[GTK_STATE_SELECTED].green/65535.0,
@@ -482,15 +445,15 @@
   cairo_stroke (cr);
 
   cairo_set_line_width (cr, 1.0);
-  os_cairo_draw_rounded_rect (cr, x + 1, y + 1, width - 2, height - 2, radius - 1);
+  draw_round_rect (cr, x + 1, y + 1, width - 2, height - 2, radius - 1);
   cairo_set_source_rgba (cr, 0.1, 0.1, 0.1, 0.1);
   cairo_stroke (cr);
 
-  os_cairo_draw_rounded_rect (cr, x + 2, y + 2, width - 4, height - 4, radius - 3);
+  draw_round_rect (cr, x + 2, y + 2, width - 4, height - 4, radius - 3);
   cairo_set_source_rgba (cr, 0.6, 0.6, 0.6, 0.5);
   cairo_stroke (cr);
 
-  os_cairo_draw_rounded_rect (cr, x + 3, y + 3, width - 6, height - 6, radius - 4);
+  draw_round_rect (cr, x + 3, y + 3, width - 6, height - 6, radius - 4);
   cairo_set_source_rgba (cr, 1, 1, 1, 0.2);
   cairo_stroke (cr);
 
@@ -525,14 +488,14 @@
       cairo_save (cr);
       cairo_translate (cr, 8.5, 8.5);
       cairo_rotate (cr, G_PI);  
-      os_cairo_draw_arrow (cr, 0.5, 0, 4, 3);
+      draw_arrow (cr, 0.5, 0, 4, 3);
       cairo_restore (cr);
 
       /* direction DOWN. */
       cairo_save (cr);
       cairo_translate (cr, 8.5, height - 8.5);
       cairo_rotate (cr, 0);
-      os_cairo_draw_arrow (cr, -0.5, 0, 4, 3);
+      draw_arrow (cr, -0.5, 0, 4, 3);
       cairo_restore (cr);
     }
   else
@@ -541,14 +504,14 @@
       cairo_save (cr);
       cairo_translate (cr, 8.5, 8.5);
       cairo_rotate (cr, G_PI * 0.5);  
-      os_cairo_draw_arrow (cr, -0.5, 0, 4, 3);
+      draw_arrow (cr, -0.5, 0, 4, 3);
       cairo_restore (cr);
 
       /* direction RIGHT. */
       cairo_save (cr);
       cairo_translate (cr, width - 8.5, 8.5);
       cairo_rotate (cr, G_PI * 1.5);
-      os_cairo_draw_arrow (cr, 0.5, 0, 4, 3);
+      draw_arrow (cr, 0.5, 0, 4, 3);
       cairo_restore (cr);
     }
 
@@ -649,7 +612,7 @@
       {
         priv->use_tolerance = FALSE;
         priv->source_id = g_timeout_add (TIMEOUT_FADE_OUT,
-                                         os_thumb_timeout_fade_out_cb,
+                                         timeout_fade_out_cb,
                                          thumb);
       }
   }
@@ -700,7 +663,7 @@
   gtk_window_set_opacity (GTK_WINDOW (widget), 1.0f);
 
   priv->source_id = g_timeout_add (TIMEOUT_FADE_OUT,
-                                   os_thumb_timeout_fade_out_cb,
+                                   timeout_fade_out_cb,
                                    thumb);
 
   return FALSE;
@@ -742,6 +705,42 @@
 }
 
 static void
+os_thumb_dispose (GObject *object)
+{
+  OsThumb *thumb;
+  OsThumbPrivate *priv;
+
+  thumb = OS_THUMB (object);
+  priv = thumb->priv;
+
+  if (priv->source_id != 0)
+    {
+      g_source_remove (priv->source_id);
+      priv->source_id = 0;
+    }
+
+  if (priv->animation != NULL)
+    {
+      g_object_unref (priv->animation);
+      priv->animation = NULL;
+    }
+
+  if (priv->grabbed_widget != NULL)
+    {
+      g_object_unref (priv->grabbed_widget);
+      priv->grabbed_widget = NULL;
+    }
+
+  G_OBJECT_CLASS (os_thumb_parent_class)->dispose (object);
+}
+
+static void
+os_thumb_finalize (GObject *object)
+{
+  G_OBJECT_CLASS (os_thumb_parent_class)->finalize (object);
+}
+
+static void
 os_thumb_get_property (GObject    *object,
                        guint       prop_id,
                        GValue     *value,