Merge lp:~cimi/overlay-scrollbar/gtk3 into lp:overlay-scrollbar

[Andrea Cimitan]

WIP port to gtk3 (compile with --with-gtk=3)

[lp:~cimi/overlay-scrollbar/gtk3]

249. By Andrea Cimitan on 2011-06-08

Code formatting

250. By Andrea Cimitan on 2011-06-08

Removed old gtk+ patch

[Ted Gould (ted)]

review: Approve

[Ted Gould (ted)]

Let's get this in so the little patches are easier to read ;-)

=== modified file 'configure.ac'
--- configure.ac	2011-05-19 15:06:11 +0000
+++ configure.ac	2011-06-08 15:38:03 +0000
@@ -66,11 +66,27 @@
 
 AC_SUBST(glib_req, 2.26.0)
 AC_SUBST(gtk_req, 2.22.0)
+AC_SUBST(gtk3_req, 3.0.9)
 AC_SUBST(cairo_req, 1.10)
 
-PKG_CHECK_MODULES(DEPS, glib-2.0 >= $glib_req gtk+-2.0 >= $gtk_req cairo >= $cairo_req)
-AC_SUBST(DEPS_CFLAGS)
-AC_SUBST(DEPS_LIBS)
+AC_ARG_WITH([gtk],
+  [AS_HELP_STRING([--with-gtk],
+    [Which version of gtk to use @<:@default=2@:>@])],
+  [],
+  [with_gtk=2])
+AS_IF([test "x$with_gtk" = x3],
+        [PKG_CHECK_MODULES(DEPS, glib-2.0 >= $glib_req gtk+-3.0 >= $gtk3_req cairo >= $cairo_req)
+         AC_SUBST(DEPS_CFLAGS)
+         AC_SUBST(DEPS_LIBS)
+        ],
+      [test "x$with_gtk" = x2],
+        [PKG_CHECK_MODULES(DEPS, glib-2.0 >= $glib_req gtk+-2.0 >= $gtk_req cairo >= $cairo_req)
+         AC_SUBST(DEPS_CFLAGS)
+         AC_SUBST(DEPS_LIBS)
+        ],
+      [AC_MSG_FAILURE([Value for --with-gtk was neither 2 nor 3])]
+)
+AM_CONDITIONAL(USE_GTK3, [test "x$with_gtk" = x3])
 
 # Debug flags
 

=== modified file 'data/81overlay-scrollbar.in'
--- data/81overlay-scrollbar.in	2011-04-21 14:33:22 +0000
+++ data/81overlay-scrollbar.in	2011-06-08 15:38:03 +0000
@@ -2,3 +2,8 @@
 then
 	export LIBOVERLAY_SCROLLBAR=1
 fi
+
+if [ -f @libdir@/liboverlay-scrollbar3-@OS_MAJORMINOR@.so.@OS_LT_CURRENT@ ]
+then
+	export LIBOVERLAY_SCROLLBAR=1
+fi

=== modified file 'misc/Makefile.am'
--- misc/Makefile.am	2011-05-18 21:15:16 +0000
+++ misc/Makefile.am	2011-06-08 15:38:03 +0000
@@ -1,3 +1,6 @@
 EXTRA_DIST = \
 	gtk+-2.0-maverick-use-overlay-scrollbar-from-module.patch \
-	gtk+-2.0-oneiric-use-overlay-scrollbar-from-module.patch
+	gtk+-2.0-oneiric-use-overlay-scrollbar-from-module.patch \
+	gtk+-fix-upstream-bug-652102.patch \
+	gtk+-3.0-right-filter-window-for-XI2-events.patch \
+	gtk+-3.0-use-overlay-form-module.patch

=== removed file 'misc/gtk+-2.0-maverick-use-overlay-scrollbar-from-module.patch'
--- misc/gtk+-2.0-maverick-use-overlay-scrollbar-from-module.patch	2011-03-03 10:54:18 +0000
+++ misc/gtk+-2.0-maverick-use-overlay-scrollbar-from-module.patch	1970-01-01 00:00:00 +0000
@@ -1,150 +0,0 @@
-=== modified file 'gtk/gtkmain.c'
---- old/gtk/gtkmain.c	2010-08-18 17:15:22 +0000
-+++ new/gtk/gtkmain.c	2011-03-01 17:17:23 +0000
-@@ -740,6 +740,7 @@
- 
-   _gtk_accel_map_init ();
-   _gtk_rc_init ();
-+  _gtk_scrolled_window_init ();
- 
-   /* Set the 'initialized' flag.
-    */
-
-=== modified file 'gtk/gtkscrolledwindow.c'
---- old/gtk/gtkscrolledwindow.c	2010-05-18 12:35:39 +0000
-+++ new/gtk/gtkscrolledwindow.c	2011-03-03 10:53:04 +0000
-@@ -144,6 +144,9 @@
- 
- static guint signals[LAST_SIGNAL] = {0};
- 
-+static GtkWidget* (*os_scrollbar_new) (GtkOrientation, GtkAdjustment*) = NULL;
-+static gboolean use_overlay_scrollbar = FALSE;
-+
- G_DEFINE_TYPE (GtkScrolledWindow, gtk_scrolled_window, GTK_TYPE_BIN)
- 
- static void
-@@ -434,7 +437,12 @@
-   if (!scrolled_window->hscrollbar)
-     {
-       gtk_widget_push_composite_child ();
--      scrolled_window->hscrollbar = gtk_hscrollbar_new (hadjustment);
-+
-+      if (use_overlay_scrollbar == FALSE)
-+        scrolled_window->hscrollbar = gtk_hscrollbar_new (hadjustment);
-+      else
-+        scrolled_window->hscrollbar = os_scrollbar_new (GTK_ORIENTATION_HORIZONTAL, hadjustment);
-+
-       gtk_widget_set_composite_name (scrolled_window->hscrollbar, "hscrollbar");
-       gtk_widget_pop_composite_child ();
- 
-@@ -495,7 +503,12 @@
-   if (!scrolled_window->vscrollbar)
-     {
-       gtk_widget_push_composite_child ();
--      scrolled_window->vscrollbar = gtk_vscrollbar_new (vadjustment);
-+
-+      if (use_overlay_scrollbar == FALSE)
-+        scrolled_window->vscrollbar = gtk_vscrollbar_new (vadjustment);
-+      else
-+        scrolled_window->vscrollbar = os_scrollbar_new (GTK_ORIENTATION_VERTICAL, vadjustment);
-+
-       gtk_widget_set_composite_name (scrolled_window->vscrollbar, "vscrollbar");
-       gtk_widget_pop_composite_child ();
- 
-@@ -1366,7 +1379,10 @@
- 	    priv->real_window_placement == GTK_CORNER_BOTTOM_LEFT)))
- 	allocation->x += (vscrollbar_requisition.width +  scrollbar_spacing);
- 
--      allocation->width = MAX (1, allocation->width - (vscrollbar_requisition.width + scrollbar_spacing));
-+      if (use_overlay_scrollbar == FALSE)
-+        allocation->width = MAX (1, allocation->width - (vscrollbar_requisition.width + scrollbar_spacing));
-+      else
-+        allocation->width = MAX (1, allocation->width);
-     }
-   if (scrolled_window->hscrollbar_visible)
-     {
-@@ -1378,7 +1394,10 @@
- 	  priv->real_window_placement == GTK_CORNER_BOTTOM_RIGHT)
- 	allocation->y += (hscrollbar_requisition.height + scrollbar_spacing);
- 
--      allocation->height = MAX (1, allocation->height - (hscrollbar_requisition.height + scrollbar_spacing));
-+      if (use_overlay_scrollbar == FALSE)
-+        allocation->height = MAX (1, allocation->height - (hscrollbar_requisition.height + scrollbar_spacing));
-+      else
-+        allocation->height = MAX (1, allocation->height);
-     }
- }
- 
-@@ -1764,6 +1783,59 @@
- }
- 
- /*
-+ * _gtk_scrolled_window_init:
-+ *
-+ * Initialize local use of the overlay-scrollbar library.
-+ *
-+ * In order to be activated for an application, the LIBOVERLAY_SCROLLBAR
-+ * environment variable must be set and the liboverlay-scrollbar shared library
-+ * must be installed. If it's installed locally, a custom path to
-+ * liboverlay-scrollbar can be set using the LIBOVERLAY_SCROLLBAR_PATH
-+ * environment variable. liboverlay-scrollbar is loaded at run-time so that it
-+ * can be installed separately.
-+ *
-+ * NOTE: This is a beta feature meant for demonstration and early adopters only.
-+ */
-+void
-+_gtk_scrolled_window_init (void)
-+{
-+  static gboolean init_once = FALSE;
-+
-+  if (init_once == FALSE)
-+    {
-+      if (g_getenv ("LIBOVERLAY_SCROLLBAR") != NULL)
-+        {
-+          GModule *module = NULL;
-+          gpointer symbol = NULL;
-+          gchar *path;
-+
-+          path = (gchar*) g_getenv ("LIBOVERLAY_SCROLLBAR_PATH");
-+          if (path == NULL)
-+            path = "/usr/lib/liboverlay-scrollbar-0.1.so.0";
-+
-+          module = g_module_open (path, G_MODULE_BIND_LOCAL);
-+          if (module != NULL)
-+            {
-+              if (g_module_symbol (module, "os_utils_is_blacklisted", &symbol))
-+                {
-+                  gboolean (*os_utils_is_blacklisted) (const gchar*) = symbol;
-+                  if (os_utils_is_blacklisted (g_get_prgname ()) == FALSE)
-+                    {
-+                      if (g_module_symbol (module, "os_scrollbar_new", &symbol))
-+                        {
-+                          os_scrollbar_new = symbol;
-+                          use_overlay_scrollbar = TRUE;
-+                        }
-+                    }
-+                }
-+            }
-+        }
-+
-+      init_once = TRUE;
-+    }
-+}
-+
-+/*
-  * _gtk_scrolled_window_get_spacing:
-  * @scrolled_window: a scrolled window
-  * 
-
-=== modified file 'gtk/gtkscrolledwindow.h'
---- old/gtk/gtkscrolledwindow.h	2009-09-05 07:16:24 +0000
-+++ new/gtk/gtkscrolledwindow.h	2011-03-01 17:18:02 +0000
-@@ -127,6 +127,7 @@
- void	       gtk_scrolled_window_add_with_viewport (GtkScrolledWindow *scrolled_window,
- 						      GtkWidget		*child);
- 
-+void _gtk_scrolled_window_init                  (void);
- gint _gtk_scrolled_window_get_scrollbar_spacing (GtkScrolledWindow *scrolled_window);
- 
- 
-

=== added file 'misc/gtk+-3.0-right-filter-window-for-XI2-events.patch'
--- misc/gtk+-3.0-right-filter-window-for-XI2-events.patch	1970-01-01 00:00:00 +0000
+++ misc/gtk+-3.0-right-filter-window-for-XI2-events.patch	2011-06-08 15:38:03 +0000
@@ -0,0 +1,331 @@
+Index: gtk+-3.0.9/gdk/gdkwindow.c
+===================================================================
+--- gtk+-3.0.9.orig/gdk/gdkwindow.c	2011-06-07 08:29:40.860881065 +0200
++++ gtk+-3.0.9/gdk/gdkwindow.c	2011-06-07 08:30:21.297081582 +0200
+@@ -2410,6 +2410,10 @@
+  *
+  * See gdk_display_add_client_message_filter() if you are interested
+  * in X ClientMessage events.
++ *
++ * If you are interested in X GenericEvents, bear in mind that
++ * XGetEventData() has been already called on the event, and
++ * XFreeEventData() must not be called within @function.
+  **/
+ void
+ gdk_window_add_filter (GdkWindow     *window,
+Index: gtk+-3.0.9/gdk/x11/gdkdevicemanager-xi2.c
+===================================================================
+--- gtk+-3.0.9.orig/gdk/x11/gdkdevicemanager-xi2.c	2011-06-07 08:15:02.136197362 +0200
++++ gtk+-3.0.9/gdk/x11/gdkdevicemanager-xi2.c	2011-06-07 08:29:18.380769587 +0200
+@@ -91,7 +91,8 @@
+ static void         gdk_x11_device_manager_xi2_select_window_events (GdkEventTranslator *translator,
+                                                                      Window              window,
+                                                                      GdkEventMask        event_mask);
+-
++static GdkWindow *  gdk_x11_device_manager_xi2_get_window           (GdkEventTranslator *translator,
++                                                                     XEvent             *xevent);
+ 
+ enum {
+   PROP_0,
+@@ -561,6 +562,7 @@
+   iface->translate_event = gdk_x11_device_manager_xi2_translate_event;
+   iface->get_handled_events = gdk_x11_device_manager_xi2_get_handled_events;
+   iface->select_window_events = gdk_x11_device_manager_xi2_select_window_events;
++  iface->get_window = gdk_x11_device_manager_xi2_get_window;
+ }
+ 
+ static void
+@@ -1007,43 +1009,27 @@
+   gboolean return_val = TRUE;
+   GdkWindow *window;
+   XIEvent *ev;
+-  Display *dpy;
+ 
+-  dpy = GDK_DISPLAY_XDISPLAY (display);
+   device_manager = (GdkX11DeviceManagerXI2 *) translator;
+   cookie = &xevent->xcookie;
+ 
+   if (xevent->type != GenericEvent)
+     return gdk_x11_device_manager_xi2_translate_core_event (translator, display, event, xevent);
+-
+-  if (!XGetEventData (dpy, cookie))
++  else if (cookie->extension != device_manager->opcode)
+     return FALSE;
+ 
+-  if (cookie->type != GenericEvent ||
+-      cookie->extension != device_manager->opcode)
+-    {
+-      XFreeEventData (dpy, cookie);
+-      return FALSE;
+-    }
+-
+   ev = (XIEvent *) cookie->data;
+ 
+   window = get_event_window (translator, ev);
+ 
+   if (window && GDK_WINDOW_DESTROYED (window))
+-    {
+-      XFreeEventData (dpy, cookie);
+-      return FALSE;
+-    }
++    return FALSE;
+ 
+   if (ev->evtype == XI_Motion ||
+       ev->evtype == XI_ButtonRelease)
+     {
+       if (_gdk_x11_moveresize_handle_event (xevent))
+-        {
+-          XFreeEventData (dpy, cookie);
+-          return FALSE;
+-        }
++        return FALSE;
+     }
+ 
+   switch (ev->evtype)
+@@ -1325,8 +1311,6 @@
+       event->any.type = GDK_NOTHING;
+     }
+ 
+-  XFreeEventData (dpy, cookie);
+-
+   return return_val;
+ }
+ 
+@@ -1366,6 +1350,24 @@
+   g_free (event_mask.mask);
+ }
+ 
++static GdkWindow *
++gdk_x11_device_manager_xi2_get_window (GdkEventTranslator *translator,
++                                       XEvent             *xevent)
++{
++  GdkX11DeviceManagerXI2 *device_manager;
++  XIEvent *ev;
++
++  device_manager = (GdkX11DeviceManagerXI2 *) translator;
++
++  if (xevent->type != GenericEvent ||
++      xevent->xcookie.extension != device_manager->opcode)
++    return NULL;
++
++  ev = (XIEvent *) xevent->xcookie.data;
++
++  return get_event_window (translator, ev);
++}
++
+ #else /* XINPUT_2 */
+ 
+ static void
+Index: gtk+-3.0.9/gdk/x11/gdkeventsource.c
+===================================================================
+--- gtk+-3.0.9.orig/gdk/x11/gdkeventsource.c	2011-06-07 08:15:11.743439030 +0200
++++ gtk+-3.0.9/gdk/x11/gdkeventsource.c	2011-06-07 08:25:06.887522506 +0200
+@@ -97,11 +97,30 @@
+ }
+ 
+ static GdkWindow *
+-gdk_event_source_get_filter_window (GdkEventSource *event_source,
+-                                    XEvent         *xevent)
++gdk_event_source_get_filter_window (GdkEventSource      *event_source,
++                                    XEvent              *xevent,
++                                    GdkEventTranslator **event_translator)
+ {
++  GList *list = event_source->translators;
+   GdkWindow *window;
+ 
++  *event_translator = NULL;
++
++  while (list)
++    {
++      GdkEventTranslator *translator = list->data;
++
++      list = list->next;
++      window = _gdk_x11_event_translator_get_window (translator,
++                                                     event_source->display,
++                                                     xevent);
++      if (window)
++        {
++          *event_translator = translator;
++          return window;
++        }
++    }
++
+   window = gdk_x11_window_lookup_for_display (event_source->display,
+                                               xevent->xany.window);
+ 
+@@ -151,11 +170,21 @@
+                                   XEvent         *xevent)
+ {
+   GdkEvent *event = gdk_event_new (GDK_NOTHING);
+-  GList *list = event_source->translators;
+-  GdkFilterReturn result;
++  GdkFilterReturn result = GDK_FILTER_CONTINUE;
++  GdkEventTranslator *event_translator;
+   GdkWindow *filter_window;
++  Display *dpy;
++
++  dpy = GDK_DISPLAY_XDISPLAY (event_source->display);
++
++  /* Get cookie data here so it's available
++   * to every event translator and event filter.
++   */
++  if (xevent->type == GenericEvent)
++    XGetEventData (dpy, &xevent->xcookie);
+ 
+-  filter_window = gdk_event_source_get_filter_window (event_source, xevent);
++  filter_window = gdk_event_source_get_filter_window (event_source, xevent,
++                                                      &event_translator);
+   if (filter_window)
+     event->any.window = g_object_ref (filter_window);
+ 
+@@ -165,48 +194,53 @@
+       /* Apply global filters */
+ 
+       result = gdk_event_apply_filters (xevent, event, NULL);
++    }
++
++  if (result == GDK_FILTER_CONTINUE &&
++      filter_window && filter_window->filters)
++    {
++      /* Apply per-window filters */
++      result = gdk_event_apply_filters (xevent, event, filter_window);
++    }
++
++  if (result != GDK_FILTER_CONTINUE)
++    {
++      if (xevent->type == GenericEvent)
++        XFreeEventData (dpy, &xevent->xcookie);
+ 
+       if (result == GDK_FILTER_REMOVE)
+         {
+           gdk_event_free (event);
+           return NULL;
+         }
+-      else if (result == GDK_FILTER_TRANSLATE)
++      else /* GDK_FILTER_TRANSLATE */
+         return event;
+     }
+ 
+-  if (filter_window)
+-    {
+-      /* Apply per-window filters */
+-      GdkFilterReturn result;
+-
+-      if (filter_window->filters)
+-	{
+-	  result = gdk_event_apply_filters (xevent, event,
+-					    filter_window);
+-
+-          if (result == GDK_FILTER_REMOVE)
+-            {
+-              gdk_event_free (event);
+-              return NULL;
+-            }
+-          else if (result == GDK_FILTER_TRANSLATE)
+-            return event;
+-        }
+-    }
+-
+   gdk_event_free (event);
+   event = NULL;
+ 
+-  while (list && !event)
++  if (event_translator)
+     {
+-      GdkEventTranslator *translator = list->data;
+-
+-      list = list->next;
+-      event = _gdk_x11_event_translator_translate (translator,
++      /* Event translator was gotten before in get_filter_window() */
++      event = _gdk_x11_event_translator_translate (event_translator,   
+                                                    event_source->display,
+                                                    xevent);
+     }
++  else
++    {
++      GList *list = event_source->translators;
++
++      while (list && !event)
++        {
++          GdkEventTranslator *translator = list->data;
++
++          list = list->next;
++          event = _gdk_x11_event_translator_translate (translator,
++                                                       event_source->display,
++                                                       xevent);
++        }
++    }
+ 
+   if (event &&
+       (event->type == GDK_ENTER_NOTIFY ||
+@@ -217,6 +251,9 @@
+       handle_focus_change (&event->crossing);
+     }
+ 
++  if (xevent->type == GenericEvent)
++    XFreeEventData (dpy, &xevent->xcookie);
++
+   return event;
+ }
+ 
+Index: gtk+-3.0.9/gdk/x11/gdkeventtranslator.c
+===================================================================
+--- gtk+-3.0.9.orig/gdk/x11/gdkeventtranslator.c	2011-06-07 08:21:29.734445694 +0200
++++ gtk+-3.0.9/gdk/x11/gdkeventtranslator.c	2011-06-07 08:26:13.543853032 +0200
+@@ -20,7 +20,7 @@
+ #include "config.h"
+ 
+ #include "gdkeventtranslator.h"
+-
++#include "gdkwindow-x11.h"
+ 
+ typedef GdkEventTranslatorIface GdkEventTranslatorInterface;
+ G_DEFINE_INTERFACE (GdkEventTranslator, _gdk_x11_event_translator, G_TYPE_OBJECT);
+@@ -87,3 +87,24 @@
+   if (iface->select_window_events)
+     iface->select_window_events (translator, window, event_mask);
+ }
++
++GdkWindow *
++_gdk_x11_event_translator_get_window (GdkEventTranslator *translator,
++                                      GdkDisplay         *display,
++                                      XEvent             *xevent)
++{
++  GdkEventTranslatorIface *iface;
++  GdkWindow *window = NULL;
++
++  g_return_val_if_fail (GDK_IS_EVENT_TRANSLATOR (translator), NULL);
++
++  iface = GDK_EVENT_TRANSLATOR_GET_IFACE (translator);
++
++  if (iface->get_window)
++    window = iface->get_window (translator, xevent);
++
++  if (!window)
++    window = gdk_x11_window_lookup_for_display (display, xevent->xany.window);
++
++  return window;
++}
+Index: gtk+-3.0.9/gdk/x11/gdkeventtranslator.h
+===================================================================
+--- gtk+-3.0.9.orig/gdk/x11/gdkeventtranslator.h	2011-06-07 08:21:31.894456415 +0200
++++ gtk+-3.0.9/gdk/x11/gdkeventtranslator.h	2011-06-07 08:26:57.220069609 +0200
+@@ -49,6 +49,8 @@
+   void         (* select_window_events) (GdkEventTranslator *translator,
+                                          Window              window,
+                                          GdkEventMask        event_mask);
++  GdkWindow *  (* get_window)           (GdkEventTranslator *translator,
++                                         XEvent             *xevent);
+ };
+ 
+ GType      _gdk_x11_event_translator_get_type (void) G_GNUC_CONST;
+@@ -60,6 +62,9 @@
+ void         _gdk_x11_event_translator_select_window_events (GdkEventTranslator *translator,
+                                                              Window              window,
+                                                              GdkEventMask        event_mask);
++GdkWindow *  _gdk_x11_event_translator_get_window           (GdkEventTranslator *translator,
++                                                             GdkDisplay         *display,
++                                                             XEvent             *xevent);
+ 
+ G_END_DECLS
+ 

=== added file 'misc/gtk+-3.0-use-overlay-form-module.patch'
--- misc/gtk+-3.0-use-overlay-form-module.patch	1970-01-01 00:00:00 +0000
+++ misc/gtk+-3.0-use-overlay-form-module.patch	2011-06-08 15:38:03 +0000
@@ -0,0 +1,418 @@
+Index: gtk+-3.0.9/gtk/gtkhscrollbar.c
+===================================================================
+--- gtk+-3.0.9.orig/gtk/gtkhscrollbar.c	2011-06-06 22:01:31.455723443 +0200
++++ gtk+-3.0.9/gtk/gtkhscrollbar.c	2011-06-06 19:54:05.177807603 +0200
+@@ -31,6 +31,8 @@
+ #include "gtkorientable.h"
+ #include "gtkintl.h"
+ 
++static GtkWidget* (*os_scrollbar_new) (GtkOrientation, GtkAdjustment*) = NULL;
++static gboolean use_overlay_scrollbar = FALSE;
+ 
+ G_DEFINE_TYPE (GtkHScrollbar, gtk_hscrollbar, GTK_TYPE_SCROLLBAR)
+ 
+@@ -61,7 +63,67 @@
+   g_return_val_if_fail (adjustment == NULL || GTK_IS_ADJUSTMENT (adjustment),
+                         NULL);
+ 
++  if (use_overlay_scrollbar)
++    return os_scrollbar_new (GTK_ORIENTATION_HORIZONTAL, adjustment);
++
+   return g_object_new (GTK_TYPE_HSCROLLBAR,
+                        "adjustment", adjustment,
+                        NULL);
+ }
++
++/*
++ * ubuntu_gtk_hscrollbar_init:
++ *
++ * Initialize local use of the overlay-scrollbar module.
++ * 
++ * If the module is installed, this code checks both a whitelist
++ * and a blacklist to decide whether to activate the remplacement
++ * scrollbars.
++ *
++ * It is possible to force the feature to be disabled by setting
++ * the LIBOVERLAY_SCROLLBAR environment variable to either '0' or an
++ * empty value.
++ */
++void
++ubuntu_gtk_hscrollbar_init (void)
++{
++  static gboolean init_once = FALSE;
++
++  if (init_once == FALSE)
++    {
++      GModule *module = NULL;
++      gpointer symbol = NULL;
++
++      gchar *flag = (gchar*) g_getenv ("LIBOVERLAY_SCROLLBAR");
++
++      /* check if LIBOVERLAY_SCROLLBAR is set to 0 or an empty value
++         and disable the feature in this case */
++      if (flag != NULL && (*flag == '\0' || *flag == '0'))
++        goto skip_loading;
++
++      /* default extension library to use for this release */
++      gchar *path = "/usr/lib/liboverlay-scrollbar3-0.2.so.0";
++
++      module = g_module_open (path, G_MODULE_BIND_LOCAL);
++      if (module == NULL)
++        goto skip_loading;
++
++      /* check the blacklist, in all cases */
++      if (g_module_symbol (module, "os_utils_is_blacklisted", &symbol))
++        {
++          gboolean (*os_utils_is_blacklisted) (const gchar*) = symbol;
++          if (os_utils_is_blacklisted (g_get_prgname ()) == TRUE)
++            goto skip_loading;
++        }
++
++      /* all controls are positive: the feature can be activated now */
++      if (g_module_symbol (module, "os_scrollbar_new", &symbol))
++        {
++          os_scrollbar_new = symbol;
++          use_overlay_scrollbar = TRUE;
++        }
++
++skip_loading:
++      init_once = TRUE;
++    }
++}
+Index: gtk+-3.0.9/gtk/gtkhscrollbar.h
+===================================================================
+--- gtk+-3.0.9.orig/gtk/gtkhscrollbar.h	2011-06-06 22:01:31.479723561 +0200
++++ gtk+-3.0.9/gtk/gtkhscrollbar.h	2011-06-06 19:54:26.889915270 +0200
+@@ -62,6 +62,7 @@
+ 
+ GType      gtk_hscrollbar_get_type (void) G_GNUC_CONST;
+ GtkWidget* gtk_hscrollbar_new      (GtkAdjustment *adjustment);
++void       ubuntu_gtk_hscrollbar_init (void);
+ 
+ 
+ G_END_DECLS
+Index: gtk+-3.0.9/gtk/gtkmain.c
+===================================================================
+--- gtk+-3.0.9.orig/gtk/gtkmain.c	2011-06-06 22:01:31.435723345 +0200
++++ gtk+-3.0.9/gtk/gtkmain.c	2011-06-06 19:55:18.630171830 +0200
+@@ -855,6 +855,11 @@
+ 
+   _gtk_accel_map_init ();
+ 
++  ubuntu_gtk_scrolled_window_init ();
++  ubuntu_gtk_scrollbar_init ();
++  ubuntu_gtk_hscrollbar_init ();
++  ubuntu_gtk_vscrollbar_init ();
++
+   /* Set the 'initialized' flag.
+    */
+   gtk_initialized = TRUE;
+Index: gtk+-3.0.9/gtk/gtkscrollbar.c
+===================================================================
+--- gtk+-3.0.9.orig/gtk/gtkscrollbar.c	2011-06-06 22:01:31.579724063 +0200
++++ gtk+-3.0.9/gtk/gtkscrollbar.c	2011-06-06 19:57:52.322933951 +0200
+@@ -58,6 +58,9 @@
+ 
+ static void gtk_scrollbar_style_updated (GtkWidget *widget);
+ 
++static GtkWidget* (*os_scrollbar_new) (GtkOrientation, GtkAdjustment*) = NULL;
++static gboolean use_overlay_scrollbar = FALSE;
++
+ G_DEFINE_TYPE (GtkScrollbar, gtk_scrollbar, GTK_TYPE_RANGE)
+ 
+ static void
+@@ -164,8 +167,68 @@
+   g_return_val_if_fail (adjustment == NULL || GTK_IS_ADJUSTMENT (adjustment),
+                         NULL);
+ 
++  if (use_overlay_scrollbar)
++    return os_scrollbar_new (orientation, adjustment);
++
+   return g_object_new (GTK_TYPE_SCROLLBAR,
+                        "orientation", orientation,
+                        "adjustment",  adjustment,
+                        NULL);
+ }
++
++/*
++ * ubuntu_gtk_scrollbar_init:
++ *
++ * Initialize local use of the overlay-scrollbar module.
++ * 
++ * If the module is installed, this code checks both a whitelist
++ * and a blacklist to decide whether to activate the remplacement
++ * scrollbars.
++ *
++ * It is possible to force the feature to be disabled by setting
++ * the LIBOVERLAY_SCROLLBAR environment variable to either '0' or an
++ * empty value.
++ */
++void
++ubuntu_gtk_scrollbar_init (void)
++{
++  static gboolean init_once = FALSE;
++
++  if (init_once == FALSE)
++    {
++      GModule *module = NULL;
++      gpointer symbol = NULL;
++
++      gchar *flag = (gchar*) g_getenv ("LIBOVERLAY_SCROLLBAR");
++
++      /* check if LIBOVERLAY_SCROLLBAR is set to 0 or an empty value
++         and disable the feature in this case */
++      if (flag != NULL && (*flag == '\0' || *flag == '0'))
++        goto skip_loading;
++
++      /* default extension library to use for this release */
++      gchar *path = "/usr/lib/liboverlay-scrollbar3-0.2.so.0";
++
++      module = g_module_open (path, G_MODULE_BIND_LOCAL);
++      if (module == NULL)
++        goto skip_loading;
++
++      /* check the blacklist, in all cases */
++      if (g_module_symbol (module, "os_utils_is_blacklisted", &symbol))
++        {
++          gboolean (*os_utils_is_blacklisted) (const gchar*) = symbol;
++          if (os_utils_is_blacklisted (g_get_prgname ()) == TRUE)
++            goto skip_loading;
++        }
++
++      /* all controls are positive: the feature can be activated now */
++      if (g_module_symbol (module, "os_scrollbar_new", &symbol))
++        {
++          os_scrollbar_new = symbol;
++          use_overlay_scrollbar = TRUE;
++        }
++
++skip_loading:
++      init_once = TRUE;
++    }
++}
+Index: gtk+-3.0.9/gtk/gtkscrollbar.h
+===================================================================
+--- gtk+-3.0.9.orig/gtk/gtkscrollbar.h	2011-06-06 22:01:31.619724258 +0200
++++ gtk+-3.0.9/gtk/gtkscrollbar.h	2011-06-06 19:58:12.079031917 +0200
+@@ -68,6 +68,7 @@
+ GType       gtk_scrollbar_get_type (void) G_GNUC_CONST;
+ GtkWidget * gtk_scrollbar_new      (GtkOrientation  orientation,
+                                     GtkAdjustment  *adjustment);
++void        ubuntu_gtk_scrollbar_init (void);
+ 
+ G_END_DECLS
+ 
+Index: gtk+-3.0.9/gtk/gtkscrolledwindow.c
+===================================================================
+--- gtk+-3.0.9.orig/gtk/gtkscrolledwindow.c	2011-06-06 22:01:31.659724455 +0200
++++ gtk+-3.0.9/gtk/gtkscrolledwindow.c	2011-06-06 20:02:19.400258318 +0200
+@@ -220,6 +220,8 @@
+ 
+ static guint signals[LAST_SIGNAL] = {0};
+ 
++static gboolean use_overlay_scrollbar = FALSE;
++
+ G_DEFINE_TYPE (GtkScrolledWindow, gtk_scrolled_window, GTK_TYPE_BIN)
+ 
+ 
+@@ -1210,7 +1212,7 @@
+ 
+       gtk_widget_style_get (widget, "scrollbars-within-bevel", &scrollbars_within_bevel, NULL);
+ 
+-      if (!scrollbars_within_bevel)
++      if (!scrollbars_within_bevel && !use_overlay_scrollbar)
+         {
+           GtkStateFlags state;
+           GtkBorder padding, border;
+@@ -1766,7 +1768,7 @@
+ 
+       if (priv->shadow_type != GTK_SHADOW_NONE)
+ 	{
+-          if (!scrollbars_within_bevel)
++          if (!scrollbars_within_bevel && !use_overlay_scrollbar)
+             {
+               child_allocation.x -= padding.left + border.left;
+               child_allocation.width += padding.left + padding.right + border.left + border.right;
+@@ -1814,7 +1816,7 @@
+ 
+       if (priv->shadow_type != GTK_SHADOW_NONE)
+ 	{
+-          if (!scrollbars_within_bevel)
++          if (!scrollbars_within_bevel && !use_overlay_scrollbar)
+             {
+               child_allocation.y -= padding.top + border.top;
+ 	      child_allocation.height += padding.top + padding.bottom + border.top + border.bottom;
+@@ -2055,6 +2057,58 @@
+ }
+ 
+ /*
++ * ubuntu_gtk_scrolled_window_init:
++ *
++ * Initialize local use of the overlay-scrollbar module.
++ * 
++ * If the module is installed, this code checks both a whitelist
++ * and a blacklist to decide whether to activate the remplacement
++ * scrollbars.
++ *
++ * It is possible to force the feature to be disabled by setting
++ * the LIBOVERLAY_SCROLLBAR environment variable to either '0' or an
++ * empty value.
++ */
++void
++ubuntu_gtk_scrolled_window_init (void)
++{
++  static gboolean init_once = FALSE;
++
++  if (init_once == FALSE)
++    {
++      GModule *module = NULL;
++      gpointer symbol = NULL;
++
++      gchar *flag = (gchar*) g_getenv ("LIBOVERLAY_SCROLLBAR");
++
++      /* check if LIBOVERLAY_SCROLLBAR is set to 0 or an empty value
++         and disable the feature in this case */
++      if (flag != NULL && (*flag == '\0' || *flag == '0'))
++        goto skip_loading;
++
++      /* default extension library to use for this release */
++      gchar *path = "/usr/lib/liboverlay-scrollbar3-0.2.so.0";
++
++      module = g_module_open (path, G_MODULE_BIND_LOCAL);
++      if (module == NULL)
++        goto skip_loading;
++
++      /* check the blacklist, in all cases */
++      if (g_module_symbol (module, "os_utils_is_blacklisted", &symbol))
++        {
++          gboolean (*os_utils_is_blacklisted) (const gchar*) = symbol;
++          if (os_utils_is_blacklisted (g_get_prgname ()) == TRUE)
++            goto skip_loading;
++        }
++
++      use_overlay_scrollbar = TRUE;
++
++skip_loading:
++      init_once = TRUE;
++    }
++}
++
++/*
+  * _gtk_scrolled_window_get_spacing:
+  * @scrolled_window: a scrolled window
+  * 
+@@ -2070,6 +2124,9 @@
+     
+   g_return_val_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window), 0);
+ 
++  if (use_overlay_scrollbar)
++    return 0;
++
+   class = GTK_SCROLLED_WINDOW_GET_CLASS (scrolled_window);
+ 
+   if (class->scrollbar_spacing >= 0)
+Index: gtk+-3.0.9/gtk/gtkscrolledwindow.h
+===================================================================
+--- gtk+-3.0.9.orig/gtk/gtkscrolledwindow.h	2011-06-06 22:01:31.679724552 +0200
++++ gtk+-3.0.9/gtk/gtkscrolledwindow.h	2011-06-06 20:02:52.764423758 +0200
+@@ -123,6 +123,7 @@
+                                                            gint               height);
+ 
+ gint _gtk_scrolled_window_get_scrollbar_spacing (GtkScrolledWindow *scrolled_window);
++void ubuntu_gtk_scrolled_window_init            (void);
+ 
+ 
+ G_END_DECLS
+Index: gtk+-3.0.9/gtk/gtkvscrollbar.c
+===================================================================
+--- gtk+-3.0.9.orig/gtk/gtkvscrollbar.c	2011-06-06 22:01:31.507723704 +0200
++++ gtk+-3.0.9/gtk/gtkvscrollbar.c	2011-06-06 20:05:06.117085008 +0200
+@@ -31,6 +31,8 @@
+ #include "gtkvscrollbar.h"
+ #include "gtkintl.h"
+ 
++static GtkWidget* (*os_scrollbar_new) (GtkOrientation, GtkAdjustment*) = NULL;
++static gboolean use_overlay_scrollbar = FALSE;
+ 
+ /**
+  * SECTION:gtkvscrollbar
+@@ -75,7 +77,67 @@
+   g_return_val_if_fail (adjustment == NULL || GTK_IS_ADJUSTMENT (adjustment),
+                         NULL);
+ 
++  if (use_overlay_scrollbar)
++    return os_scrollbar_new (GTK_ORIENTATION_VERTICAL, adjustment);
++
+   return g_object_new (GTK_TYPE_VSCROLLBAR,
+                        "adjustment", adjustment,
+                        NULL);
+ }
++
++/*
++ * ubuntu_gtk_vscrollbar_init:
++ *
++ * Initialize local use of the overlay-scrollbar module.
++ * 
++ * If the module is installed, this code checks both a whitelist
++ * and a blacklist to decide whether to activate the remplacement
++ * scrollbars.
++ *
++ * It is possible to force the feature to be disabled by setting
++ * the LIBOVERLAY_SCROLLBAR environment variable to either '0' or an
++ * empty value.
++ */
++void
++ubuntu_gtk_vscrollbar_init (void)
++{
++  static gboolean init_once = FALSE;
++
++  if (init_once == FALSE)
++    {
++      GModule *module = NULL;
++      gpointer symbol = NULL;
++
++      gchar *flag = (gchar*) g_getenv ("LIBOVERLAY_SCROLLBAR");
++
++      /* check if LIBOVERLAY_SCROLLBAR is set to 0 or an empty value
++         and disable the feature in this case */
++      if (flag != NULL && (*flag == '\0' || *flag == '0'))
++        goto skip_loading;
++
++      /* default extension library to use for this release */
++      gchar *path = "/usr/lib/liboverlay-scrollbar3-0.2.so.0";
++
++      module = g_module_open (path, G_MODULE_BIND_LOCAL);
++      if (module == NULL)
++        goto skip_loading;
++
++      /* check the blacklist, in all cases */
++      if (g_module_symbol (module, "os_utils_is_blacklisted", &symbol))
++        {
++          gboolean (*os_utils_is_blacklisted) (const gchar*) = symbol;
++          if (os_utils_is_blacklisted (g_get_prgname ()) == TRUE)
++            goto skip_loading;
++        }
++
++      /* all controls are positive: the feature can be activated now */
++      if (g_module_symbol (module, "os_scrollbar_new", &symbol))
++        {
++          os_scrollbar_new = symbol;
++          use_overlay_scrollbar = TRUE;
++        }
++
++skip_loading:
++      init_once = TRUE;
++    }
++}
+Index: gtk+-3.0.9/gtk/gtkvscrollbar.h
+===================================================================
+--- gtk+-3.0.9.orig/gtk/gtkvscrollbar.h	2011-06-06 22:01:31.543723883 +0200
++++ gtk+-3.0.9/gtk/gtkvscrollbar.h	2011-06-06 20:08:59.662243113 +0200
+@@ -68,6 +68,7 @@
+ 
+ GType      gtk_vscrollbar_get_type (void) G_GNUC_CONST;
+ GtkWidget* gtk_vscrollbar_new      (GtkAdjustment *adjustment);
++void       ubuntu_gtk_vscrollbar_init (void);
+ 
+ 
+ G_END_DECLS

=== added file 'misc/gtk+-fix-upstream-bug-652102.patch'
--- misc/gtk+-fix-upstream-bug-652102.patch	1970-01-01 00:00:00 +0000
+++ misc/gtk+-fix-upstream-bug-652102.patch	2011-06-08 15:38:03 +0000
@@ -0,0 +1,13 @@
+diff --git a/gdk/gdkwindow.c b/gdk/gdkwindow.c
+index 0be4656..a643619 100644
+--- a/gdk/gdkwindow.c
++++ b/gdk/gdkwindow.c
+@@ -6546,6 +6546,8 @@ gdk_window_set_background_pattern (GdkWindow *window,
+       GdkWindowImplClass *impl_class = GDK_WINDOW_IMPL_GET_CLASS (window->impl);
+       impl_class->set_background (window, pattern);
+     }
++  else
++    gdk_window_invalidate_rect_full (window, NULL, TRUE, CLEAR_BG_ALL);
+ }
+
+ /**

=== modified file 'os/Makefile.am'
--- os/Makefile.am	2011-04-01 16:55:19 +0000
+++ os/Makefile.am	2011-06-08 15:38:03 +0000
@@ -1,3 +1,11 @@
+if USE_GTK3
+VER=3
+lib_LTLIBRARIES = liboverlay-scrollbar3-@OS_MAJORMINOR@.la
+else
+VER=
+lib_LTLIBRARIES = liboverlay-scrollbar-@OS_MAJORMINOR@.la
+endif
+
 noinst_HEADERS = \
 	os-private.h
 
@@ -13,14 +21,12 @@
 	$(srcdir)/os-pager.c \
 	$(srcdir)/os-thumb.c \
 	$(srcdir)/os-scrollbar.c
-
-osincludedir = $(includedir)/overlay-scrollbar-@OS_MAJORMINOR@/os
+	
+osincludedir = $(includedir)/overlay-scrollbar$(VER)-@OS_MAJORMINOR@/os
 osinclude_HEADERS = $(source_h)
 
 liboverlay_scrollbar_@OS_MAJORMINOR@_la_SOURCES = $(source_c)
 
-lib_LTLIBRARIES = liboverlay-scrollbar-@OS_MAJORMINOR@.la
-
 liboverlay_scrollbar_@OS_MAJORMINOR@_la_CFLAGS = $(OS_CFLAGS)
 
 liboverlay_scrollbar_@OS_MAJORMINOR@_la_LIBADD = $(OS_LIBADD)
@@ -28,12 +34,28 @@
 liboverlay_scrollbar_@OS_MAJORMINOR@_la_LDFLAGS = $(OS_LDFLAGS)
 
 liboverlay_scrollbar_@OS_MAJORMINOR@_includedir = \
-	$(includedir)/overlay-scrollbar-@OS_MAJORMINOR@/os
+	$(includedir)/overlay-scrollbar$(VER)-@OS_MAJORMINOR@/os
 
 liboverlay_scrollbar_@OS_MAJORMINOR@_include_HEADERS = \
 	$(source_h) \
 	os-version.h
 
+# We duplicate these here because Automake won't let us use $(VER) on the left hand side.
+# Since we carefully use $(VER) in the right hand side above, we can assign the same values.
+# Only one version of the library is every compiled at the same time, so it is safe to reuse
+# the right hand sides like this.
+os3includedir = $(osincludedir)
+os3include_HEADERS = $(osinclude_HEADERS)
+liboverlay_scrollbar3_@OS_MAJORMINOR@_la_SOURCES =  $(source_c)
+liboverlay_scrollbar3_@OS_MAJORMINOR@_la_CFLAGS = $(OS_CFLAGS) \
+  -DUSE_GTK3
+liboverlay_scrollbar3_@OS_MAJORMINOR@_la_LIBADD = $(OS_LIBADD)
+liboverlay_scrollbar3_@OS_MAJORMINOR@_la_LDFLAGS = $(OS_LDFLAGS)
+liboverlay_scrollbar3_@OS_MAJORMINOR@_includedir = $(includedir)/overlay-scrollbar$(VER)-@OS_MAJORMINOR@/os
+liboverlay_scrollbar3_@OS_MAJORMINOR@_include_HEADERS = \
+	$(source_h) \
+	os-version.h
+
 EXTRA_DIST = \
 	os-version.h.in
 

=== modified file 'os/os-pager.c'
--- os/os-pager.c	2011-05-18 18:25:13 +0000
+++ os/os-pager.c	2011-06-08 15:38:03 +0000
@@ -37,6 +37,12 @@
 /* Duration of the fade-out */
 #define DURATION_FADE_OUT 400
 
+#ifdef USE_GTK3
+#define SHAPE_REGION(x) (cairo_region_create_rectangle (x))
+#else
+#define SHAPE_REGION(x) (gdk_region_rectangle (x))
+#endif
+
 struct _OsPagerPrivate {
   GdkWindow *pager_window;
   GdkWindow *connection_window;
@@ -71,12 +77,12 @@
   color.green = 65535 * 0.6;
   color.blue  = 65535 * 0.6;
 
+#ifndef USE_GTK3
   gdk_colormap_alloc_color (gdk_drawable_get_colormap (priv->connection_window), &color, FALSE, TRUE);
+#endif
 
   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);
 }
 
@@ -110,12 +116,12 @@
   color.green = weight * c1.green + (1.0 - weight) * c2.green;
   color.blue  = weight * c1.blue  + (1.0 - weight) * c2.blue;
 
+#ifndef USE_GTK3
   gdk_colormap_alloc_color (gdk_drawable_get_colormap (priv->pager_window), &color, FALSE, TRUE);
+#endif
 
   gdk_window_set_background (priv->pager_window, &color);
 
-  gdk_window_clear (priv->pager_window);
-
   gdk_window_invalidate_rect (gtk_widget_get_window (priv->parent), &priv->allocation, TRUE);
 }
 
@@ -307,10 +313,8 @@
   priv = pager->priv;
 
   gdk_window_shape_combine_region (priv->connection_window,
-                                   gdk_region_rectangle (&priv->connection_mask),
+                                   SHAPE_REGION(&priv->connection_mask),
                                    0, 0);
-
-  gdk_window_clear (priv->connection_window);
 }
 
 /**
@@ -377,10 +381,8 @@
   priv = pager->priv;
 
   gdk_window_shape_combine_region (priv->pager_window,
-                                   gdk_region_rectangle (&priv->mask),
+                                   SHAPE_REGION(&priv->mask),
                                    0, 0);
-
-  gdk_window_clear (priv->pager_window);
 }
 
 /**
@@ -481,8 +483,7 @@
       if (priv->detached)
         {
           gdk_window_show (priv->connection_window);
-
-          gdk_window_clear (priv->connection_window);
+          gdk_window_raise (priv->pager_window);
         }
       else
         gdk_window_hide (priv->connection_window);
@@ -529,40 +530,60 @@
       priv->pager_window = NULL;
     }
 
+  attributes.event_mask = 0;
   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);
+#ifndef USE_GTK3
   attributes.colormap = gtk_widget_get_colormap (priv->parent);
+#endif
 
   /* connection_window */
   priv->connection_window = gdk_window_new (gtk_widget_get_window (priv->parent),
                                             &attributes,
+#ifdef USE_GTK3
+                                            GDK_WA_VISUAL);
+#else
                                             GDK_WA_VISUAL | GDK_WA_COLORMAP);
+#endif
 
   g_object_ref_sink (priv->connection_window);
 
   gdk_window_set_transient_for (priv->connection_window,
                                 gtk_widget_get_window (priv->parent));
 
+  /* FIXME(Cimi) maybe this is not required with 0 as event mask */
   gdk_window_input_shape_combine_region (priv->connection_window,
+#ifdef USE_GTK3
+                                         cairo_region_create (),
+#else
                                          gdk_region_new (),
+#endif
                                          0, 0);
 
   /* pager_window */
   priv->pager_window = gdk_window_new (gtk_widget_get_window (priv->parent),
                                        &attributes,
+#ifdef USE_GTK3
+                                       GDK_WA_VISUAL);
+#else
                                        GDK_WA_VISUAL | GDK_WA_COLORMAP);
+#endif 
 
   g_object_ref_sink (priv->pager_window);
 
-  /* stay above the connection_window */
   gdk_window_set_transient_for (priv->pager_window,
-                                priv->connection_window);
+                                gtk_widget_get_window (priv->parent));
 
+  /* FIXME(Cimi) maybe this is not required with 0 as event mask */
   gdk_window_input_shape_combine_region (priv->pager_window,
+#ifdef USE_GTK3
+                                         cairo_region_create (),
+#else
                                          gdk_region_new (),
+#endif
                                          0, 0);
 }
 
@@ -620,8 +641,6 @@
       if (priv->visible)
         {
           gdk_window_show (priv->pager_window);
-
-          gdk_window_clear (priv->pager_window);
         }
     }
 }
@@ -647,8 +666,6 @@
     return;
 
   gdk_window_show (priv->pager_window);
-
-  gdk_window_clear (priv->pager_window);
 }
 
 /**

=== modified file 'os/os-scrollbar.c'
--- os/os-scrollbar.c	2011-06-03 15:47:48 +0000
+++ os/os-scrollbar.c	2011-06-08 15:38:03 +0000
@@ -27,6 +27,7 @@
 #include "os-scrollbar.h"
 #include "os-private.h"
 #include <gdk/gdkx.h>
+#include <X11/extensions/XInput2.h>
 #include "math.h"
 
 /* Default size of the pager in pixels. */
@@ -99,8 +100,14 @@
 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);
+
+#ifdef USE_GTK3
+static gboolean os_scrollbar_draw (GtkWidget *widget, cairo_t *cr);
+static void os_scrollbar_get_preferred_width (GtkWidget *widget, gint *minimal_width, gint *natural_width);
+static void os_scrollbar_get_preferred_height (GtkWidget *widget, gint *minimal_height, gint *natural_height);
+#else
 static gboolean os_scrollbar_expose_event (GtkWidget *widget, GdkEventExpose *event);
-
+#endif
 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);
@@ -889,7 +896,11 @@
 
   gdk_flush ();
 
+#ifdef USE_GTK3
+  gdk_error_trap_pop_ignored ();
+#else
   gdk_error_trap_pop ();
+#endif
 }
 
 /* present a Gdk window */
@@ -1117,7 +1128,11 @@
 
       gdk_flush ();
 
+#ifdef USE_GTK3
+      gdk_error_trap_pop_ignored ();
+#else
       gdk_error_trap_pop ();
+#endif
     }
 }
 
@@ -1441,6 +1456,257 @@
 }
 
 /* filter function applied to the toplevel window */
+#ifdef USE_GTK3
+static GdkFilterReturn
+toplevel_filter_func (GdkXEvent *gdkxevent,
+                      GdkEvent  *event,
+                      gpointer   user_data)
+{
+  OsScrollbar *scrollbar;
+  OsScrollbarPrivate *priv;
+  XEvent *xev;
+
+  g_return_val_if_fail (OS_SCROLLBAR (user_data), GDK_FILTER_CONTINUE);
+
+  scrollbar = OS_SCROLLBAR (user_data);
+
+  priv = scrollbar->priv;
+  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 (xev->type == GenericEvent)
+        {
+          XIDeviceEvent *xiev;
+
+          xiev = xev->xcookie.data;
+
+          if (xiev->evtype == XI_ButtonPress)
+            {
+              priv->toplevel_button_press = TRUE;
+              gtk_widget_hide (priv->thumb);
+            }
+
+          if (priv->toplevel_button_press && xiev->evtype == XI_ButtonRelease)
+            {
+              priv->toplevel_button_press = FALSE;
+
+              /* proximity area */
+              if (priv->orientation == GTK_ORIENTATION_VERTICAL)
+                {
+                  if ((priv->thumb_all.x - xiev->event_x <= PROXIMITY_WIDTH &&
+                       priv->thumb_all.x - xiev->event_x >= 0) &&
+                      (xiev->event_y >= priv->thumb_all.y + priv->overlay.y &&
+                       xiev->event_y <= priv->thumb_all.y + priv->overlay.y + priv->overlay.height))
+                    {
+                      priv->can_hide = FALSE;
+
+                      if (priv->lock_position)
+                        return GDK_FILTER_CONTINUE;
+
+                      if (priv->overlay.height > priv->slider.height)
+                        {
+                          gint x, y, x_pos, y_pos;
+
+                          gdk_window_get_origin (gtk_widget_get_window (GTK_WIDGET (scrollbar)), &x_pos, &y_pos);
+
+                          x = priv->thumb_all.x;
+                          y = CLAMP (xiev->event_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);
+
+                          move_thumb (scrollbar, x_pos + x, y_pos + y);
+                        }
+                      else
+                        {
+                          move_thumb (scrollbar, priv->win_x, priv->win_y + priv->slider.y);
+                        }
+
+                      gtk_widget_show (GTK_WIDGET (priv->thumb));
+                    }
+                }
+              else
+                {
+                  if ((priv->thumb_all.y - xiev->event_y <= PROXIMITY_WIDTH &&
+                       priv->thumb_all.y - xiev->event_y >= 0) &&
+                      (xiev->event_x >= priv->thumb_all.x + priv->overlay.x &&
+                       xiev->event_x <= priv->thumb_all.x + priv->overlay.x + priv->overlay.width))
+                    {
+                      priv->can_hide = FALSE;
+
+                      if (priv->lock_position)
+                        return GDK_FILTER_CONTINUE;
+
+                      if (priv->overlay.width > priv->slider.width)
+                        {
+                          gint x, y, x_pos, y_pos;
+
+                          gdk_window_get_origin (gtk_widget_get_window (GTK_WIDGET (scrollbar)), &x_pos, &y_pos);
+
+                          x = CLAMP (xiev->event_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;
+
+                          move_thumb (scrollbar, x_pos + x, y_pos + y);
+                        }
+                      else
+                        {
+                          move_thumb (scrollbar, priv->win_x, priv->win_y + priv->slider.y);
+                        }
+
+                      gtk_widget_show (GTK_WIDGET (priv->thumb));
+                    }
+                }
+            }
+
+          /* after a scroll-event, without motion,
+           * pager becomes inactive because the timeout in
+           * leave-notify-event starts,
+           * this call checks the pointer after the scroll-event,
+           * since it enters the window,
+           * then sets the state accordingly. */
+          if (!priv->active_window && xiev->evtype == XI_Enter)
+            {
+              XIEnterEvent *xiee = xev->xcookie.data;
+
+              pager_set_state_from_pointer (scrollbar, xiee->event_x, xiee->event_y);
+            }
+
+          if (xiev->evtype == XI_Leave)
+            {
+              /* never deactivate the pager in an active window. */
+              if (!priv->active_window)
+                {
+                  priv->can_deactivate_pager = TRUE;
+
+                  if (priv->source_deactivate_pager_id != 0)
+                    g_source_remove (priv->source_deactivate_pager_id);
+
+                  priv->source_deactivate_pager_id = g_timeout_add (TIMEOUT_TOPLEVEL_HIDE,
+                                                                    deactivate_pager_cb,
+                                                                    scrollbar);
+                }
+
+              priv->toplevel_button_press = FALSE;
+              priv->can_hide = TRUE;
+
+              if (priv->source_hide_thumb_id != 0)
+                g_source_remove (priv->source_hide_thumb_id);
+
+              priv->source_hide_thumb_id = g_timeout_add (TIMEOUT_TOPLEVEL_HIDE,
+                                                          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,
+                                                            unlock_thumb_cb,
+                                                            scrollbar);
+            }
+
+          /* get the motion_notify_event trough XEvent */
+          if (!priv->toplevel_button_press && xiev->evtype == XI_Motion)
+            {
+              /* react to motion_notify_event
+               * and set the state accordingly. */
+              if (!priv->active_window)
+                pager_set_state_from_pointer (scrollbar, xiev->event_x, xiev->event_y);
+
+              /* proximity area */
+              if (priv->orientation == GTK_ORIENTATION_VERTICAL)
+                {
+                  if ((priv->thumb_all.x - xiev->event_x <= PROXIMITY_WIDTH &&
+                       priv->thumb_all.x - xiev->event_x >= 0) &&
+                      (xiev->event_y >= priv->thumb_all.y + priv->overlay.y &&
+                       xiev->event_y <= priv->thumb_all.y + priv->overlay.y + priv->overlay.height))
+                    {
+                      priv->can_hide = FALSE;
+
+                      if (priv->lock_position)
+                        return GDK_FILTER_CONTINUE;
+
+                      if (priv->overlay.height > priv->slider.height)
+                        {
+                          gint x, y, x_pos, y_pos;
+
+                          gdk_window_get_origin (gtk_widget_get_window (GTK_WIDGET (scrollbar)), &x_pos, &y_pos);
+
+                          x = priv->thumb_all.x;
+                          y = CLAMP (xiev->event_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);
+
+                          move_thumb (scrollbar, x_pos + x, y_pos + y);
+                        }
+                      else
+                        {
+                          move_thumb (scrollbar, priv->win_x, priv->win_y + priv->slider.y);
+                        }
+
+                      os_pager_set_detached (OS_PAGER (priv->pager), FALSE);
+                      os_thumb_set_detached (OS_THUMB (priv->thumb), FALSE);
+                      gtk_widget_show (GTK_WIDGET (priv->thumb));
+                    }
+                  else
+                    {
+                      priv->can_hide = TRUE;
+                      priv->lock_position = FALSE;
+                      hide_thumb (scrollbar);
+                    }
+                }
+              else
+                {
+                  if ((priv->thumb_all.y - xiev->event_y <= PROXIMITY_WIDTH &&
+                       priv->thumb_all.y - xiev->event_y >= 0) &&
+                      (xiev->event_x >= priv->thumb_all.x + priv->overlay.x &&
+                       xiev->event_x <= priv->thumb_all.x + priv->overlay.x + priv->overlay.width))
+                    {
+                      priv->can_hide = FALSE;
+
+                      if (priv->lock_position)
+                        return GDK_FILTER_CONTINUE;
+
+                      if (priv->overlay.width > priv->slider.width)
+                        {
+                          gint x, y, x_pos, y_pos;
+
+                          gdk_window_get_origin (gtk_widget_get_window (GTK_WIDGET (scrollbar)), &x_pos, &y_pos);
+
+                          x = CLAMP (xiev->event_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;
+
+                          move_thumb (scrollbar, x_pos + x, y_pos + y);
+                        }
+                      else
+                        {
+                          move_thumb (scrollbar, priv->win_x + priv->slider.x, priv->win_y);
+                        }
+
+                      os_pager_set_detached (OS_PAGER (priv->pager), FALSE);
+                      os_thumb_set_detached (OS_THUMB (priv->thumb), FALSE);
+                      gtk_widget_show (GTK_WIDGET (priv->thumb));
+                    }
+                  else
+                    {
+                      priv->can_hide = TRUE;
+                      priv->lock_position = FALSE;
+                      hide_thumb (scrollbar);
+                    }
+                }
+            }
+        }
+    }
+
+  return GDK_FILTER_CONTINUE;
+}
+#else
 static GdkFilterReturn
 toplevel_filter_func (GdkXEvent *gdkxevent,
                       GdkEvent  *event,
@@ -1679,6 +1945,7 @@
 
   return GDK_FILTER_CONTINUE;
 }
+#endif
 
 G_DEFINE_TYPE (OsScrollbar, os_scrollbar, GTK_TYPE_SCROLLBAR);
 
@@ -1691,16 +1958,24 @@
   gobject_class = G_OBJECT_CLASS (class);
   widget_class = GTK_WIDGET_CLASS (class);
 
-  widget_class->expose_event  = os_scrollbar_expose_event;
-  widget_class->grab_notify   = os_scrollbar_grab_notify;
-  widget_class->hide          = os_scrollbar_hide;
-  widget_class->map           = os_scrollbar_map;
-  widget_class->realize       = os_scrollbar_realize;
-  widget_class->show          = os_scrollbar_show;
-  widget_class->size_allocate = os_scrollbar_size_allocate;
-  widget_class->size_request  = os_scrollbar_size_request;
-  widget_class->unmap         = os_scrollbar_unmap;
-  widget_class->unrealize     = os_scrollbar_unrealize;
+#ifdef USE_GTK3
+  widget_class->draw                 = os_scrollbar_draw;
+  widget_class->get_preferred_width  = os_scrollbar_get_preferred_width;
+  widget_class->get_preferred_height = os_scrollbar_get_preferred_height;
+#else
+  widget_class->expose_event         = os_scrollbar_expose_event;
+#endif
+  widget_class->grab_notify          = os_scrollbar_grab_notify;
+  widget_class->hide                 = os_scrollbar_hide;
+  widget_class->map                  = os_scrollbar_map;
+  widget_class->realize              = os_scrollbar_realize;
+  widget_class->show                 = os_scrollbar_show;
+  widget_class->size_allocate        = os_scrollbar_size_allocate;
+#ifndef USE_GTK3
+  widget_class->size_request         = os_scrollbar_size_request;
+#endif
+  widget_class->unmap                = os_scrollbar_unmap;
+  widget_class->unrealize            = os_scrollbar_unrealize;
 
   gobject_class->dispose  = os_scrollbar_dispose;
   gobject_class->finalize = os_scrollbar_finalize;
@@ -1828,12 +2103,47 @@
   G_OBJECT_CLASS (os_scrollbar_parent_class)->finalize (object);
 }
 
+#ifdef USE_GTK3
+static gboolean
+os_scrollbar_draw (GtkWidget      *widget,
+                   cairo_t        *cr)
+{
+  return TRUE;
+}
+#else
 static gboolean
 os_scrollbar_expose_event (GtkWidget      *widget,
                            GdkEventExpose *event)
 {
   return TRUE;
 }
+#endif
+
+#if USE_GTK3
+static void
+os_scrollbar_get_preferred_width (GtkWidget *widget,
+                                  gint      *minimal_width,
+                                  gint      *natural_width)
+{
+  GtkRequisition requisition;
+
+  os_scrollbar_size_request (widget, &requisition);
+
+  *minimal_width = *natural_width = requisition.width;
+}
+
+static void
+os_scrollbar_get_preferred_height (GtkWidget *widget,
+                                   gint      *minimal_height,
+                                   gint      *natural_height)
+{
+  GtkRequisition requisition;
+
+  os_scrollbar_size_request (widget, &requisition);
+
+  *minimal_height = *natural_height = requisition.height;
+}
+#endif
 
 static void
 os_scrollbar_grab_notify (GtkWidget *widget,
@@ -1981,7 +2291,7 @@
     {
       priv->slider.width = DEFAULT_THUMB_HEIGHT;
       priv->slider.height = DEFAULT_THUMB_WIDTH;
-      priv->overlay_all.y = allocation->y - DEFAULT_PAGER_WIDTH ;
+      priv->overlay_all.y = allocation->y - DEFAULT_PAGER_WIDTH;
       priv->thumb_all.y = allocation->y + THUMB_ALLOCATION_SHIFT;
 
       rect.x = priv->overlay_all.x;
@@ -2023,7 +2333,9 @@
   else
     requisition->height = 0;
 
+#ifndef USE_GTK3
   widget->requisition = *requisition;
+#endif
 }
 
 static void

=== modified file 'os/os-thumb.c'
--- os/os-thumb.c	2011-05-19 13:19:14 +0000
+++ os/os-thumb.c	2011-06-08 15:38:03 +0000
@@ -66,7 +66,11 @@
 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);
+#ifdef USE_GTK3
+static gboolean os_thumb_draw (GtkWidget *widget, cairo_t *cr);
+#else
 static gboolean os_thumb_expose (GtkWidget *widget, GdkEventExpose *event);
+#endif
 static gboolean os_thumb_leave_notify_event (GtkWidget *widget, GdkEventCrossing *event);
 static gboolean os_thumb_motion_notify_event (GtkWidget *widget, GdkEventMotion *event);
 static void os_thumb_map (GtkWidget *widget);
@@ -127,7 +131,11 @@
   widget_class->button_press_event   = os_thumb_button_press_event;
   widget_class->button_release_event = os_thumb_button_release_event;
   widget_class->composited_changed   = os_thumb_composited_changed;
+#if USE_GTK3
+  widget_class->draw                 = os_thumb_draw;
+#else
   widget_class->expose_event         = os_thumb_expose;
+#endif
   widget_class->leave_notify_event   = os_thumb_leave_notify_event;
   widget_class->map                  = os_thumb_map;
   widget_class->motion_notify_event  = os_thumb_motion_notify_event;
@@ -343,16 +351,22 @@
 }
 
 static gboolean
+#ifdef USE_GTK3
+os_thumb_draw (GtkWidget *widget,
+               cairo_t   *cr)
+{
+#else
 os_thumb_expose (GtkWidget      *widget,
                  GdkEventExpose *event)
 {
   GtkAllocation allocation;
+  cairo_t *cr;
+#endif
   GtkStyle *style;
   OsThumb *thumb;
   OsThumbPrivate *priv;
   cairo_pattern_t *pat;
-  cairo_t *cr;
-  gint x, y, width, height;
+  gint width, height;
   gint radius;
 
   style = gtk_widget_get_style (widget);
@@ -360,15 +374,19 @@
   thumb = OS_THUMB (widget);
   priv = thumb->priv;
 
+  radius = priv->can_rgba ? THUMB_RADIUS : 0;
+
+#if USE_GTK3
+  width = gtk_widget_get_allocated_width (widget);
+  height = gtk_widget_get_allocated_height (widget);
+#else
   gtk_widget_get_allocation (widget, &allocation);
-
-  x = 0;
-  y = 0;
+ 
   width = allocation.width;
   height = allocation.height;
-  radius = priv->can_rgba ? THUMB_RADIUS : 0;
 
   cr = gdk_cairo_create (gtk_widget_get_window (widget));
+#endif
 
   cairo_save (cr);
 
@@ -384,12 +402,12 @@
   cairo_set_line_width (cr, 1);
   cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
 
-  draw_round_rect (cr, x, y, width, height, radius);
+  draw_round_rect (cr, 0, 0, width, height, radius);
 
   if (priv->orientation == GTK_ORIENTATION_VERTICAL)
-    pat = cairo_pattern_create_linear (x, y, width + x, y);
+    pat = cairo_pattern_create_linear (0, 0, width, 0);
   else
-    pat = cairo_pattern_create_linear (x, y, x, height + y);
+    pat = cairo_pattern_create_linear (0, 0, 0, height);
 
   cairo_pattern_add_color_stop_rgba (pat, 0.0, 0.95, 0.95, 0.95, 1.0);
   cairo_pattern_add_color_stop_rgba (pat, 1.0, 0.8, 0.8, 0.8, 1.0);
@@ -397,12 +415,12 @@
   cairo_pattern_destroy (pat);
   cairo_fill (cr);
 
-  draw_round_rect (cr, x, y, width, height, radius);
+  draw_round_rect (cr, 0, 0, width, height, radius);
 
   if (priv->orientation == GTK_ORIENTATION_VERTICAL)
-    pat = cairo_pattern_create_linear (x, y, x, height + y);
+    pat = cairo_pattern_create_linear (0, 0, 0, height);
   else
-    pat = cairo_pattern_create_linear (x, y, width + x, y);
+    pat = cairo_pattern_create_linear (0, 0, width, 0);
 
   if (priv->button_press_event && !priv->motion_notify_event)
     {
@@ -442,7 +460,7 @@
     cairo_fill (cr);
 
   cairo_set_line_width (cr, 2.0);
-  draw_round_rect (cr, x + 0.5, y + 0.5, width - 1, height - 1, radius - 1);
+  draw_round_rect (cr, 0.5, 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,
@@ -452,39 +470,39 @@
   cairo_stroke (cr);
 
   cairo_set_line_width (cr, 1.0);
-  draw_round_rect (cr, x + 1, y + 1, width - 2, height - 2, radius - 1);
+  draw_round_rect (cr, 1, 1, width - 2, height - 2, radius - 1);
   cairo_set_source_rgba (cr, 0.1, 0.1, 0.1, 0.1);
   cairo_stroke (cr);
 
-  draw_round_rect (cr, x + 2, y + 2, width - 4, height - 4, radius - 3);
+  draw_round_rect (cr, 2, 2, width - 4, height - 4, radius - 3);
   cairo_set_source_rgba (cr, 0.6, 0.6, 0.6, 0.5);
   cairo_stroke (cr);
 
-  draw_round_rect (cr, x + 3, y + 3, width - 6, height - 6, radius - 4);
+  draw_round_rect (cr, 3, 3, width - 6, height - 6, radius - 4);
   cairo_set_source_rgba (cr, 1, 1, 1, 0.2);
   cairo_stroke (cr);
 
   if (priv->orientation == GTK_ORIENTATION_VERTICAL)
     {
-      cairo_move_to (cr, x + 2.5, y - 1 + height / 2);
-      cairo_line_to (cr, width - 2.5, y - 1 + height / 2);
+      cairo_move_to (cr, 2.5, - 1 + height / 2);
+      cairo_line_to (cr, width - 2.5, - 1 + height / 2);
       cairo_set_source_rgba (cr, 0.6, 0.6, 0.6, 0.4);
       cairo_stroke (cr);
 
-      cairo_move_to (cr, x + 2.5, y + height / 2);
-      cairo_line_to (cr, width - 2.5, y + height / 2);
+      cairo_move_to (cr, 2.5, height / 2);
+      cairo_line_to (cr, width - 2.5, height / 2);
       cairo_set_source_rgba (cr, 1, 1, 1, 0.5);
       cairo_stroke (cr);
     }
   else
     {
-      cairo_move_to (cr, x - 1 + width / 2, y + 2.5);
-      cairo_line_to (cr, x - 1 + width / 2, height - 2.5);
+      cairo_move_to (cr, 1 + width / 2, 2.5);
+      cairo_line_to (cr, 1 + width / 2, height - 2.5);
       cairo_set_source_rgba (cr, 0.6, 0.6, 0.6, 0.4);
       cairo_stroke (cr);
 
-      cairo_move_to (cr, x + width / 2, y + 2.5);
-      cairo_line_to (cr, x + width / 2, height - 2.5);
+      cairo_move_to (cr, width / 2, 2.5);
+      cairo_line_to (cr, width / 2, height - 2.5);
       cairo_set_source_rgba (cr, 1, 1, 1, 0.5);
       cairo_stroke (cr);
     }
@@ -526,7 +544,9 @@
 
   cairo_restore (cr);
 
+#ifndef USE_GTK3
   cairo_destroy (cr);
+#endif
 
   return FALSE;
 }
@@ -635,10 +655,21 @@
   return FALSE;
 }
 
+
 static void
 os_thumb_screen_changed (GtkWidget *widget,
                          GdkScreen *old_screen)
 {
+#if USE_GTK3
+  GdkScreen *screen;
+  GdkVisual *visual;
+
+  screen = gtk_widget_get_screen (widget);
+  visual = gdk_screen_get_rgba_visual (screen);
+
+ if (visual)
+   gtk_widget_set_visual (widget, visual);
+#else
   GdkScreen *screen;
   GdkColormap *colormap;
 
@@ -647,6 +678,7 @@
 
   if (colormap)
     gtk_widget_set_colormap (widget, colormap);
+#endif
 }
 
 static gboolean

=== modified file 'pkgconfig/Makefile.am'
--- pkgconfig/Makefile.am	2011-03-01 02:39:50 +0000
+++ pkgconfig/Makefile.am	2011-06-08 15:38:03 +0000
@@ -1,13 +1,19 @@
-pcfiles = overlay-scrollbar-@OS_MAJORMINOR@.pc
+if USE_GTK3
+VER=3
+else
+VER=
+endif
+
+pcfiles = overlay-scrollbar$(VER)-@OS_MAJORMINOR@.pc
 
 all-local: $(pcfiles)
 
-%-@OS_MAJORMINOR@.pc: %.pc
+%$(VER)-@OS_MAJORMINOR@.pc: %.pc
 	cp $< $@
 
 pkgconfigdir = $(libdir)/pkgconfig
 pkgconfig_DATA = $(pcfiles)
 
-EXTRA_DIST = overlay-scrollbar.pc.in
+EXTRA_DIST = overlay-scrollbar$(VER).pc.in
 
 CLEANFILES = $(pcfiles)

=== modified file 'tests/Makefile.am'
--- tests/Makefile.am	2011-03-02 16:15:54 +0000
+++ tests/Makefile.am	2011-06-08 15:38:03 +0000
@@ -1,3 +1,9 @@
+if USE_GTK3
+VER=3
+else
+VER=
+endif
+
 EXTRA_DIST = \
 	test-os-pager.c \
 	test-os-pixmap.c \
@@ -11,7 +17,7 @@
 	-I$(top_srcdir) \
 	$(OS_CFLAGS)
 test_os_LDFLAGS = \
-	$(top_builddir)/os/liboverlay-scrollbar-@OS_MAJORMINOR@.la \
+	$(top_builddir)/os/liboverlay-scrollbar$(VER)-@OS_MAJORMINOR@.la \
 	$(OS_LIBADD)
 
 # FIXME(loicm): Figure out what tests must be compiled and add them here.