File byzanz-gnome3.patch of Package byzanz

Overview Repositories Revisions Requests Users Attributes Meta

File byzanz-gnome3.patch of Package byzanz (Revision ed1ecd798ba9346f4fcd378c9fea6a48)

Currently displaying revision ed1ecd798ba9346f4fcd378c9fea6a48 , Show latest

diff --git a/configure.ac b/configure.ac
index 5df4496..a6f1135 100644
--- a/configure.ac
+++ b/configure.ac
@@ -5,7 +5,7 @@ dnl need to do this here so intltool-update doesn't die a slow but awful death
 PACKAGE=byzanz
 dnl when going to/from release please set the nano (fourth number) right !
 dnl releases only do Wall, cvs and prerelease does Werror too
-AS_VERSION($PACKAGE, TOOLS_VERSION, 0, 2, 3, 0, BYZANZ_CVS="no", BYZANZ_CVS="yes")
+AS_VERSION($PACKAGE, TOOLS_VERSION, 0, 3, 0, 1, BYZANZ_CVS="no", BYZANZ_CVS="yes")
 
 dnl AM_MAINTAINER_MODE only provides the option to configure to enable it
 AM_MAINTAINER_MODE
@@ -63,18 +63,21 @@ AC_DEFINE_DIR(DATADIR, "${datadir}", [datadir])
 dnl Check for essential libraries first:
 dnl ====================================
 
-CAIRO_REQ="1.8.0"
-GTK_REQ="2.17.10"
+CAIRO_REQ="1.10"
+GTK_REQ="3.0.0"
 GTHREAD_REQ="2.6.0"
-APPLET_REQ="2.10.0"
+APPLET_REQ="2.91.91"
 XDAMAGE_REQ="1.0"
 GST_REQ="0.10.24"
 
-PKG_CHECK_MODULES(GTK, cairo >= $CAIRO_REQ gtk+-2.0 >= $GTK_REQ x11 gio-2.0)
+PKG_CHECK_MODULES(GTK, cairo >= $CAIRO_REQ gtk+-3.0 >= $GTK_REQ x11 gio-2.0)
 
 PKG_CHECK_MODULES(GTHREAD, xdamage >= $XDAMAGE_REQ gthread-2.0 >= $GTHREAD_REQ)
 
-PKG_CHECK_MODULES(APPLET, libpanelapplet-2.0 >= $APPLET_REQ)
+LIBPANEL_APPLET="libpanelapplet-4.0"
+PKG_CHECK_MODULES(APPLET, $LIBPANEL_APPLET >= $APPLET_REQ)
+appletdir=`$PKG_CONFIG --variable=libpanel_applet_dir $LIBPANEL_APPLET`
+AC_SUBST(appletdir)
 
 PKG_CHECK_MODULES(GST, gstreamer-app-0.10 >= $GST_REQ gstreamer-0.10 >= $GST_REQ)
 
diff --git a/gifenc/gifenc.c b/gifenc/gifenc.c
index 07c20b5..50c98d5 100644
--- a/gifenc/gifenc.c
+++ b/gifenc/gifenc.c
@@ -530,14 +530,14 @@ gboolean
 gifenc_dither_rgb_with_full_image (guint8 *target, guint target_rowstride, 
     guint8 *full, guint full_rowstride,
     const GifencPalette *palette, const guint8 *data, guint width, guint height, 
-    guint rowstride, GdkRectangle *rect_out)
+    guint rowstride, cairo_rectangle_int_t *rect_out)
 {
   int x, y, c;
   gint *this_error, *next_error;
   guint8 this[3], alpha;
   gint err[3] = { 0, 0, 0 };
   guint32 pixel;
-  GdkRectangle area = { width, height, 0, 0 };
+  cairo_rectangle_int_t area = { width, height, 0, 0 };
   
   g_return_val_if_fail (palette != NULL, FALSE);
   g_return_val_if_fail (palette->alpha, FALSE);
diff --git a/gifenc/gifenc.h b/gifenc/gifenc.h
index 531e1e6..b24b2a2 100644
--- a/gifenc/gifenc.h
+++ b/gifenc/gifenc.h
@@ -99,16 +99,16 @@ void		gifenc_dither_rgb	(guint8 *		target,
 					 guint			height,
 					 guint			rowstride);
 gboolean	gifenc_dither_rgb_with_full_image
-					(guint8 *		target,
-					 guint			target_rowstride,
-					 guint8 *		full,
-					 guint			full_rowstride,
-					 const GifencPalette *	palette,
-					 const guint8 *		data,
-					 guint			width,
-					 guint			height,
-					 guint			rowstride,
-					 GdkRectangle *		rect_out);
+					(guint8 *		 target,
+					 guint			 target_rowstride,
+					 guint8 *		 full,
+					 guint			 full_rowstride,
+					 const GifencPalette *	 palette,
+					 const guint8 *		 data,
+					 guint			 width,
+					 guint			 height,
+					 guint			 rowstride,
+					 cairo_rectangle_int_t * rect_out);
 
 /* from quantize.c */
 void		gifenc_palette_free	(GifencPalette *	palette);
diff --git a/src/ByzanzApplet.server.in.in b/src/ByzanzApplet.server.in.in
deleted file mode 100644
index 04a8964..0000000
--- a/src/ByzanzApplet.server.in.in
+++ /dev/null
@@ -1,36 +0,0 @@
-<oaf_info>
-
-<oaf_server iid="OAFIID:ByzanzApplet_Factory"
-	    type="exe"
-	    location="@LIBEXECDIR@/byzanz-applet">
-
-	<oaf_attribute name="repo_ids" type="stringv">
-		<item value="IDL:Bonobo/GenericFactory:1.0"/>
-		<item value="IDL:Bonobo/Unknown:1.0"/>
-	</oaf_attribute>
-	<oaf_attribute name="name" type="string" _value="Byzanz Factory"/>
-	<oaf_attribute name="description" type="string" _value="Byzanz Factory"/>
-
-</oaf_server>
-
-<oaf_server iid="OAFIID:ByzanzApplet"
-	    type="factory" 
-	    location="OAFIID:ByzanzApplet_Factory">
-
-	<oaf_attribute name="repo_ids" type="stringv">
-		<item value="IDL:GNOME/Vertigo/PanelAppletShell:1.0"/>
-		<item value="IDL:Bonobo/Control:1.0"/>
-		<item value="IDL:Bonobo/Unknown:1.0"/>
-	</oaf_attribute>
-	<oaf_attribute name="name" type="string" _value="Desktop Recorder"/>
-	<oaf_attribute name="description" type="string" _value="Record what's happening on your desktop"/>
-	<oaf_attribute name="panel:icon" type="string" value="byzanz-record-desktop.png"/>
-	<oaf_attribute name="bugzilla:bugzilla" type="string" value="GNOME"/>
-        <oaf_attribute name="bugzilla:product" type="string" value="byzanz"/>
-        <oaf_attribute name="bugzilla:component" type="string" value="applet"/>
-        <oaf_attribute name="bugzilla:other_binaries" type="string" value="byzanz-applet"/>
-
-
-</oaf_server>
-
-</oaf_info>
diff --git a/src/Makefile.am b/src/Makefile.am
index 1f6f87f..1f3e991 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -70,7 +70,7 @@ byzanz_applet_SOURCES = \
 	paneltogglebutton.c \
 	screenshot-utils.c
 
-byzanz_applet_CFLAGS = $(APPLET_CFLAGS)
+byzanz_applet_CFLAGS = -DBYZANZ_MENU_UI_DIR=\""$(uidir)"\" $(APPLET_CFLAGS)
 byzanz_applet_LDADD = $(APPLET_LIBS) ./libbyzanz.la
 
 
@@ -93,24 +93,36 @@ install-data-local:
 	GCONF_CONFIG_SOURCE=$(GCONF_SCHEMA_CONFIG_SOURCE) $(GCONFTOOL) --makefile-install-rule $(schemas_DATA) ;
 endif
 
-serverdir       = $(libdir)/bonobo/servers
-server_in_files = ByzanzApplet.server.in
-server_DATA     = $(server_in_files:.server.in=.server)
+applet_in_files = org.gnome.ByzanzApplet.panel-applet.in
+applet_DATA     = $(applet_in_files:.panel-applet.in=.panel-applet)
 
-$(server_in_files): $(server_in_files:.server.in=.server.in.in)
-	sed -e "s|\@LIBEXECDIR\@|$(libexecdir)|" $< > $@
+$(applet_in_files): $(applet_in_files).in Makefile
+	sed \
+            -e "s|\@LIBEXECDIR\@|$(libexecdir)|" \
+            -e "s|\@VERSION\@|$(PACKAGE_VERSION)|" \
+            $< > $@
+
+%.panel-applet: %.panel-applet.in $(INTLTOOL_MERGE) $(wildcard $(top_srcdir)/po/*po) ; $(INTLTOOL_MERGE) $(top_srcdir)/po $< $@ -d -u -c $(top_builddir)/po/.intltool-merge-cache
+
+servicedir       = $(datadir)/dbus-1/services
+service_in_files = org.gnome.panel.applet.ByzanzAppletFactory.service.in
+service_DATA     = $(service_in_files:.service.in=.service)
+
+org.gnome.panel.applet.ByzanzAppletFactory.service: $(service_in_files)
+	sed \
+	    -e "s|\@LIBEXECDIR\@|$(libexecdir)|" \
+	    $< > $@
 
 uidir = $(datadir)/gnome-2.0/ui
 ui_DATA = byzanzapplet.xml
 
-CLEANFILES = $(server_in_files) $(server_DATA) $(schemas_DATA) $(BUILT_SOURCES)
+CLEANFILES = $(applet_DATA) $(applet_DATA).in $(service_DATA) $(schemas_DATA) $(BUILT_SOURCES)
 
 EXTRA_DIST = \
 	byzanzmarshal.list \
-	ByzanzApplet.server.in.in \
+	org.gnome.ByzanzApplet.panel-applet.in.in \
 	$(man_MANS) \
 	$(ui_DATA) \
 	$(schemas_in_files)
 
 
-@INTLTOOL_SERVER_RULE@
diff --git a/src/byzanzapplet.c b/src/byzanzapplet.c
index 2041a35..6c094b9 100644
--- a/src/byzanzapplet.c
+++ b/src/byzanzapplet.c
@@ -41,7 +41,6 @@ typedef struct {
 
   GtkWidget *		button;		/* recording button */
   GtkWidget *		image;		/* image displayed in button */
-  GtkTooltips *		tooltips;	/* our tooltips */
   GtkWidget *           dialog;         /* file chooser */
   GFile *               file;           /* file selected for recording */
   GType                 encoder_type;   /* last selected encoder type or 0 if none */
@@ -137,8 +136,7 @@ byzanz_applet_update (gpointer data)
 
   gtk_image_set_from_icon_name (GTK_IMAGE (priv->image), 
       state_info[state].stock_icon, GTK_ICON_SIZE_LARGE_TOOLBAR);
-  gtk_tooltips_set_tip (priv->tooltips, priv->button,
-      _(state_info[state].tooltip), NULL);
+  gtk_widget_set_tooltip_text (priv->button, _(state_info[state].tooltip));
   
   return TRUE;
 }
@@ -182,7 +180,7 @@ byzanz_applet_session_notify (AppletPrivate *priv)
 static int method_response_codes[] = { GTK_RESPONSE_ACCEPT, GTK_RESPONSE_APPLY, GTK_RESPONSE_OK, GTK_RESPONSE_YES };
 
 static void
-byzanz_applet_select_done (GdkWindow *window, const GdkRectangle *area, gpointer data)
+byzanz_applet_select_done (GdkWindow *window, const cairo_rectangle_int_t *area, gpointer data)
 {
   AppletPrivate *priv = data;
 
@@ -357,7 +355,7 @@ destroy_applet (GtkWidget *widget, AppletPrivate *priv)
 }
 
 static void 
-byzanz_about_cb (BonoboUIComponent *uic, AppletPrivate *priv, const char *verb)
+byzanz_about_cb (GtkAction *action, AppletPrivate *priv)
 {
   const gchar *authors[] = {
     "Benjamin Otte <otte@gnome.org>", 
@@ -374,15 +372,18 @@ byzanz_about_cb (BonoboUIComponent *uic, AppletPrivate *priv, const char *verb)
     NULL );
 }
 
-static const BonoboUIVerb byzanz_menu_verbs [] = {
-	BONOBO_UI_UNSAFE_VERB ("ByzanzAbout",      byzanz_about_cb),
-        BONOBO_UI_VERB_END
+static const GtkActionEntry byzanz_menu_actions [] = {
+  { "ByzanzAbout", GTK_STOCK_ABOUT, N_("_About"),
+    NULL, NULL,
+    G_CALLBACK (byzanz_about_cb) }
 };
 
 static gboolean
 byzanz_applet_fill (PanelApplet *applet, const gchar *iid, gpointer data)
 {
   AppletPrivate *priv;
+  GtkActionGroup *action_group;
+  char *ui_path;
   char *method;
   
   if (!index_quark)
@@ -401,10 +402,19 @@ byzanz_applet_fill (PanelApplet *applet, const gchar *iid, gpointer data)
   panel_applet_add_preferences (applet, "/schemas/apps/byzanz-applet/prefs",
       NULL);
   panel_applet_set_flags (applet, PANEL_APPLET_EXPAND_MINOR);
-  panel_applet_setup_menu_from_file (PANEL_APPLET (applet), 
-      DATADIR, "byzanzapplet.xml", NULL, byzanz_menu_verbs, priv);
-
-  priv->tooltips = gtk_tooltips_new ();
+  action_group = gtk_action_group_new ("Byzanz Applet Actions");
+#ifdef GETTEXT_PACKAGE
+  gtk_action_group_set_translation_domain (action_group, GETTEXT_PACKAGE);
+#endif
+  gtk_action_group_add_actions (action_group,
+				byzanz_menu_actions,
+				G_N_ELEMENTS (byzanz_menu_actions),
+				priv);
+  ui_path = g_build_filename (BYZANZ_MENU_UI_DIR, "byzanzapplet.xml", NULL);
+  panel_applet_setup_menu_from_file (PANEL_APPLET (applet),
+				     ui_path, action_group);
+  g_free (ui_path);
+  g_object_unref (action_group);
 
   method = panel_applet_gconf_get_string (priv->applet, "method", NULL);
   priv->method = byzanz_select_method_lookup (method);
@@ -425,7 +435,9 @@ byzanz_applet_fill (PanelApplet *applet, const gchar *iid, gpointer data)
   return TRUE;
 }
 
-PANEL_APPLET_BONOBO_FACTORY ("OAFIID:ByzanzApplet_Factory",
-    PANEL_TYPE_APPLET, "ByzanzApplet", "0",
-    byzanz_applet_fill, NULL);
+PANEL_APPLET_OUT_PROCESS_FACTORY ("ByzanzAppletFactory",
+				  PANEL_TYPE_APPLET,
+				  byzanz_applet_fill,
+				  NULL)
+
 
diff --git a/src/byzanzapplet.xml b/src/byzanzapplet.xml
index c817977..d3a6d6c 100644
--- a/src/byzanzapplet.xml
+++ b/src/byzanzapplet.xml
@@ -1,8 +1,2 @@
-<Root>
-   <popups>
-      <popup name="button3">
-         <menuitem name="Byzanz About Item" verb="ByzanzAbout" _label="_About"
-                   pixtype="stock" pixname="gnome-stock-about"/>
-      </popup>
-   </popups>
-</Root>
+<menuitem name="Byzanz About Item" action="ByzanzAbout"/>
+
diff --git a/src/byzanzencoder.c b/src/byzanzencoder.c
index 7c2c8ed..a2c98f4 100644
--- a/src/byzanzencoder.c
+++ b/src/byzanzencoder.c
@@ -31,7 +31,7 @@ typedef struct _ByzanzEncoderJob ByzanzEncoderJob;
 struct _ByzanzEncoderJob {
   GTimeVal		tv;		/* time this job was enqueued */
   cairo_surface_t *	surface;	/* image to process */
-  GdkRegion *		region;		/* relevant region of image */
+  cairo_region_t *	region;		/* relevant region of image */
 };
 
 static void
@@ -40,7 +40,7 @@ byzanz_encoder_job_free (ByzanzEncoderJob *job)
   if (job->surface)
     cairo_surface_destroy (job->surface);
   if (job->region)
-    gdk_region_destroy (job->region);
+    cairo_region_destroy (job->region);
 
   g_slice_free (ByzanzEncoderJob, job);
 }
@@ -80,7 +80,7 @@ byzanz_encoder_run (ByzanzEncoder * encoder,
   ByzanzEncoderClass *klass = BYZANZ_ENCODER_GET_CLASS (encoder);
   guint width, height;
   cairo_surface_t *surface;
-  GdkRegion *region;
+  cairo_region_t *region;
   guint64 msecs;
   gboolean success;
 
@@ -107,7 +107,7 @@ byzanz_encoder_run (ByzanzEncoder * encoder,
     /* decode */
     success = klass->process (encoder, output, msecs, surface, region, cancellable, error);
     cairo_surface_destroy (surface);
-    gdk_region_destroy (region);
+    cairo_region_destroy (region);
     if (!success)
       return FALSE;
   }
@@ -349,7 +349,7 @@ byzanz_encoder_new (GType           encoder_type,
 void
 byzanz_encoder_process (ByzanzEncoder *	 encoder,
 		        cairo_surface_t *surface,
-			const GdkRegion *region,
+			const cairo_region_t *region,
 			const GTimeVal * total_elapsed)
 {
   ByzanzEncoderJob *job;
@@ -364,7 +364,7 @@ byzanz_encoder_process (ByzanzEncoder *	 encoder,
 
   job = g_slice_new (ByzanzEncoderJob);
   job->surface = cairo_surface_reference (surface);
-  job->region = gdk_region_copy (region);
+  job->region = cairo_region_copy (region);
   job->tv = *total_elapsed;
 
   g_async_queue_push (encoder->jobs, job);
diff --git a/src/byzanzencoder.h b/src/byzanzencoder.h
index 54f816e..f67e978 100644
--- a/src/byzanzencoder.h
+++ b/src/byzanzencoder.h
@@ -76,7 +76,7 @@ struct _ByzanzEncoderClass {
 						 GOutputStream *	stream,
                                                  guint64                msecs,
 						 cairo_surface_t *	surface,
-						 const GdkRegion *	region,
+						 const cairo_region_t *	region,
                                                  GCancellable *         cancellable,
 						 GError **		error);
   gboolean		(* close)		(ByzanzEncoder *	encoder,
@@ -96,7 +96,7 @@ ByzanzEncoder *	byzanz_encoder_new		(GType                  encoder_type,
 /*
 void		byzanz_encoder_process		(ByzanzEncoder *	encoder,
 						 cairo_surface_t *	surface,
-						 const GdkRegion *	region,
+						 const cairo_region_t *	region,
 						 const GTimeVal *	total_elapsed);
 void		byzanz_encoder_close		(ByzanzEncoder *	encoder,
 						 const GTimeVal *	total_elapsed);
diff --git a/src/byzanzencoderbyzanz.c b/src/byzanzencoderbyzanz.c
index 868a45b..0a8b8b8 100644
--- a/src/byzanzencoderbyzanz.c
+++ b/src/byzanzencoderbyzanz.c
@@ -42,13 +42,13 @@ byzanz_encoder_byzanz_setup (ByzanzEncoder * encoder,
 }
 
 static gboolean
-byzanz_encoder_byzanz_process (ByzanzEncoder *   encoder,
-                               GOutputStream *   stream,
-                               guint64           msecs,
-                               cairo_surface_t * surface,
-                               const GdkRegion * region,
-                               GCancellable *    cancellable,
-                               GError **	 error)
+byzanz_encoder_byzanz_process (ByzanzEncoder *        encoder,
+                               GOutputStream *        stream,
+                               guint64                msecs,
+                               cairo_surface_t *      surface,
+                               const cairo_region_t * region,
+                               GCancellable *         cancellable,
+                               GError **	      error)
 {
   return byzanz_serialize (stream, msecs, surface, region, cancellable, error);
 }
diff --git a/src/byzanzencodergif.c b/src/byzanzencodergif.c
index bb80339..07bd2fc 100644
--- a/src/byzanzencodergif.c
+++ b/src/byzanzencodergif.c
@@ -109,16 +109,16 @@ byzanz_encoder_write_image (ByzanzEncoderGif *gif, guint64 msecs, GError **error
 }
 
 static gboolean
-byzanz_encoder_gif_encode_image (ByzanzEncoderGif * gif,
-                                 cairo_surface_t *  surface,
-                                 const GdkRegion *  region,
-                                 GdkRectangle *     area_out)
+byzanz_encoder_gif_encode_image (ByzanzEncoderGif *      gif,
+                                 cairo_surface_t *       surface,
+                                 const cairo_region_t *  region,
+                                 cairo_rectangle_int_t * area_out)
 {
-  GdkRectangle extents, area, *rects;
+  cairo_rectangle_int_t extents, area, rect;
   guint8 transparent;
   guint i, n_rects, stride, width;
 
-  gdk_region_get_clipbox (region, &extents);
+  cairo_region_get_extents (region, &extents);
   transparent = gifenc_palette_get_alpha_index (gif->gifenc->palette);
   stride = cairo_image_surface_get_stride (surface);
   width = gifenc_get_width (gif->gifenc);
@@ -130,32 +130,32 @@ byzanz_encoder_gif_encode_image (ByzanzEncoderGif * gif,
   }
 
   /* render changed parts */
-  gdk_region_get_rectangles (region, &rects, (int *) &n_rects);
-  memset (area_out, 0, sizeof (GdkRectangle));
+  n_rects = cairo_region_num_rectangles (region);
+  memset (area_out, 0, sizeof (cairo_rectangle_int_t));
   for (i = 0; i < n_rects; i++) {
+    cairo_region_get_rectangle (region, i, &rect);
     if (gifenc_dither_rgb_with_full_image (
-          gif->cached_tmp + width * rects[i].y + rects[i].x, width,
-	  gif->image_data + width * rects[i].y + rects[i].x, width, 
+          gif->cached_tmp + width * rect.y + rect.x, width,
+	  gif->image_data + width * rect.y + rect.x, width, 
 	  gif->gifenc->palette, 
-          cairo_image_surface_get_data (surface) + (rects[i].x - extents.x) * 4
-              + (rects[i].y - extents.y) * stride,
-          rects[i].width, rects[i].height, stride, &area)) {
-      area.x += rects[i].x;
-      area.y += rects[i].y;
+          cairo_image_surface_get_data (surface) + (rect.x - extents.x) * 4
+              + (rect.y - extents.y) * stride,
+          rect.width, rect.height, stride, &area)) {
+      area.x += rect.x;
+      area.y += rect.y;
       if (area_out->width > 0 && area_out->height > 0)
-        gdk_rectangle_union (area_out, &area, area_out);
+        gdk_rectangle_union ((const GdkRectangle*)area_out, (const GdkRectangle*) &area, (GdkRectangle*)area_out);
       else
         *area_out = area;
     }
   }
-  g_free (rects);
 
   return area_out->width > 0 && area_out->height > 0;
 }
 
 static void
-byzanz_encoder_swap_image (ByzanzEncoderGif * gif,
-                           GdkRectangle *     area)
+byzanz_encoder_swap_image (ByzanzEncoderGif *      gif,
+                           cairo_rectangle_int_t * area)
 {
   guint8 *swap;
 
@@ -166,16 +166,16 @@ byzanz_encoder_swap_image (ByzanzEncoderGif * gif,
 }
 
 static gboolean
-byzanz_encoder_gif_process (ByzanzEncoder *   encoder,
-                            GOutputStream *   stream,
-                            guint64           msecs,
-                            cairo_surface_t * surface,
-                            const GdkRegion * region,
-                            GCancellable *    cancellable,
-                            GError **	      error)
+byzanz_encoder_gif_process (ByzanzEncoder *        encoder,
+                            GOutputStream *        stream,
+                            guint64                msecs,
+                            cairo_surface_t *      surface,
+                            const cairo_region_t * region,
+                            GCancellable *         cancellable,
+                            GError **	           error)
 {
   ByzanzEncoderGif *gif = BYZANZ_ENCODER_GIF (encoder);
-  GdkRectangle area;
+  cairo_rectangle_int_t area;
 
   if (!gif->has_quantized) {
     if (!byzanz_encoder_gif_quantize (gif, surface, error))
diff --git a/src/byzanzencodergif.h b/src/byzanzencodergif.h
index b4c75f0..02d9dee 100644
--- a/src/byzanzencodergif.h
+++ b/src/byzanzencodergif.h
@@ -41,7 +41,7 @@ struct _ByzanzEncoderGif {
   gboolean              has_quantized;  /* qantization has happened already */
   guint8 *              image_data;     /* width * height of encoded image */
 
-  GdkRectangle          cached_area;    /* area that is saved in cached_data */
+  cairo_rectangle_int_t cached_area;    /* area that is saved in cached_data */
   guint8 *              cached_data;    /* cached_area.{width x height} sized area of image */
   guint64               cached_time;    /* timestamp the cached image corresponds to */
 
diff --git a/src/byzanzencodergstreamer.c b/src/byzanzencodergstreamer.c
index 8802ea5..e8e9cf7 100644
--- a/src/byzanzencodergstreamer.c
+++ b/src/byzanzencodergstreamer.c
@@ -39,9 +39,10 @@ byzanz_encoder_gstreamer_need_data (GstAppSrc *src, guint length, gpointer data)
   GstBuffer *buffer;
   cairo_t *cr;
   cairo_surface_t *surface;
-  GdkRegion *region;
+  cairo_region_t *region;
   GError *error = NULL;
   guint64 msecs;
+  int i, num_rects;
 
   if (!byzanz_deserialize (encoder->input_stream, &msecs, &surface, &region, encoder->cancellable, &error)) {
     gst_element_message_full (GST_ELEMENT (src), GST_MESSAGE_ERROR,
@@ -71,7 +72,15 @@ byzanz_encoder_gstreamer_need_data (GstAppSrc *src, guint length, gpointer data)
   }
   cr = cairo_create (gst->surface);
   cairo_set_source_surface (cr, surface, 0, 0);
-  gdk_cairo_region (cr, region);
+
+  num_rects = cairo_region_num_rectangles (region);
+  for (i = 0; i < num_rects; i++) {
+    cairo_rectangle_int_t rect;
+    cairo_region_get_rectangle (region, i, &rect);
+    cairo_rectangle (cr, rect.x, rect.y,
+                     rect.width, rect.height);
+  }
+
   cairo_fill (cr);
   cairo_destroy (cr);
 
diff --git a/src/byzanzlayer.h b/src/byzanzlayer.h
index 45ff632..518087f 100644
--- a/src/byzanzlayer.h
+++ b/src/byzanzlayer.h
@@ -45,7 +45,7 @@ struct _ByzanzLayerClass {
 
   gboolean              (* event)                       (ByzanzLayer *          layer,
                                                          GdkXEvent *            event);
-  GdkRegion *           (* snapshot)                    (ByzanzLayer *          layer);
+  cairo_region_t *      (* snapshot)                    (ByzanzLayer *          layer);
   void                  (* render)                      (ByzanzLayer *          layer,
                                                          cairo_t *              cr);
 };
diff --git a/src/byzanzlayercursor.c b/src/byzanzlayercursor.c
index 8659a39..8358493 100644
--- a/src/byzanzlayercursor.c
+++ b/src/byzanzlayercursor.c
@@ -30,7 +30,7 @@ G_DEFINE_TYPE (ByzanzLayerCursor, byzanz_layer_cursor, BYZANZ_TYPE_LAYER)
 static void
 byzanz_layer_cursor_read_cursor (ByzanzLayerCursor *clayer)
 {
-  Display *dpy = gdk_x11_drawable_get_xdisplay (BYZANZ_LAYER (clayer)->recorder->window);
+  Display *dpy = GDK_DISPLAY_XDISPLAY (gdk_window_get_display (BYZANZ_LAYER (clayer)->recorder->window));
 
   clayer->cursor_next = XFixesGetCursorImage (dpy);
   if (clayer->cursor_next)
@@ -86,9 +86,9 @@ byzanz_layer_cursor_setup_poll (ByzanzLayerCursor *clayer)
 }
 
 static void
-byzanz_recorder_invalidate_cursor (GdkRegion *region, XFixesCursorImage *cursor, int x, int y)
+byzanz_recorder_invalidate_cursor (cairo_region_t *region, XFixesCursorImage *cursor, int x, int y)
 {
-  GdkRectangle cursor_rect;
+  cairo_rectangle_int_t cursor_rect;
 
   if (cursor == NULL)
     return;
@@ -98,14 +98,14 @@ byzanz_recorder_invalidate_cursor (GdkRegion *region, XFixesCursorImage *cursor,
   cursor_rect.width = cursor->width;
   cursor_rect.height = cursor->height;
 
-  gdk_region_union_with_rect (region, &cursor_rect);
+  cairo_region_union_rectangle (region, &cursor_rect);
 }
 
-static GdkRegion *
+static cairo_region_t *
 byzanz_layer_cursor_snapshot (ByzanzLayer *layer)
 {
   ByzanzLayerCursor *clayer = BYZANZ_LAYER_CURSOR (layer);
-  GdkRegion *region, *area;
+  cairo_region_t *region, *area;
   int x, y;
   
   gdk_window_get_pointer (layer->recorder->window, &x, &y, NULL);
@@ -114,12 +114,12 @@ byzanz_layer_cursor_snapshot (ByzanzLayer *layer)
       clayer->cursor_next == clayer->cursor)
     return NULL;
 
-  region = gdk_region_new ();
+  region = cairo_region_create ();
   byzanz_recorder_invalidate_cursor (region, clayer->cursor, clayer->cursor_x, clayer->cursor_y);
   byzanz_recorder_invalidate_cursor (region, clayer->cursor_next, x, y);
-  area = gdk_region_rectangle (&layer->recorder->area);
-  gdk_region_intersect (region, area);
-  gdk_region_destroy (area);
+  area = cairo_region_create_rectangle (&layer->recorder->area);
+  cairo_region_intersect (region, area);
+  cairo_region_destroy (area);
 
   clayer->cursor = clayer->cursor_next;
   clayer->cursor_x = x;
@@ -168,9 +168,9 @@ byzanz_layer_cursor_finalize (GObject *object)
 {
   ByzanzLayerCursor *clayer = BYZANZ_LAYER_CURSOR (object);
   GdkWindow *window = BYZANZ_LAYER (object)->recorder->window;
-  Display *dpy = gdk_x11_drawable_get_xdisplay (window);
+  Display *dpy = GDK_DISPLAY_XDISPLAY (gdk_window_get_display (window));
 
-  XFixesSelectCursorInput (dpy, gdk_x11_drawable_get_xid (window), 0);
+  XFixesSelectCursorInput (dpy, GDK_WINDOW_XID (window), 0);
 
   g_hash_table_destroy (clayer->cursors);
 
@@ -186,9 +186,9 @@ byzanz_layer_cursor_constructed (GObject *object)
 {
   ByzanzLayerCursor *clayer = BYZANZ_LAYER_CURSOR (object);
   GdkWindow *window = BYZANZ_LAYER (object)->recorder->window;
-  Display *dpy = gdk_x11_drawable_get_xdisplay (window);
+  Display *dpy = GDK_DISPLAY_XDISPLAY (gdk_window_get_display (window));
 
-  XFixesSelectCursorInput (dpy, gdk_x11_drawable_get_xid (window), XFixesDisplayCursorNotifyMask);
+  XFixesSelectCursorInput (dpy, GDK_WINDOW_XID (window), XFixesDisplayCursorNotifyMask);
   byzanz_layer_cursor_read_cursor (clayer);
   byzanz_layer_cursor_setup_poll (clayer);
 
diff --git a/src/byzanzlayerwindow.c b/src/byzanzlayerwindow.c
index e8737e8..c2d095b 100644
--- a/src/byzanzlayerwindow.c
+++ b/src/byzanzlayerwindow.c
@@ -23,7 +23,6 @@
 
 #include "byzanzlayerwindow.h"
 
-#include <math.h>
 #include <gdk/gdkx.h>
 
 G_DEFINE_TYPE (ByzanzLayerWindow, byzanz_layer_window, BYZANZ_TYPE_LAYER)
@@ -37,14 +36,16 @@ byzanz_layer_window_event (ByzanzLayer * layer,
 
   if (event->type == layer->recorder->damage_event_base + XDamageNotify && 
       event->damage == wlayer->damage) {
-    GdkRectangle rect;
+    cairo_rectangle_int_t rect;
 
     rect.x = event->area.x;
     rect.y = event->area.y;
     rect.width = event->area.width;
     rect.height = event->area.height;
-    if (gdk_rectangle_intersect (&rect, &layer->recorder->area, &rect)) {
-      gdk_region_union_with_rect (wlayer->invalid, &rect);
+    if (gdk_rectangle_intersect ((GdkRectangle*) &rect,
+                                 (GdkRectangle*) &layer->recorder->area,
+                                 (GdkRectangle*) &rect)) {
+      cairo_region_union_rectangle (wlayer->invalid, &rect);
       byzanz_layer_invalidate (layer);
     }
     return TRUE;
@@ -54,38 +55,38 @@ byzanz_layer_window_event (ByzanzLayer * layer,
 }
 
 static XserverRegion
-byzanz_server_region_from_gdk (Display *dpy, GdkRegion *source)
+byzanz_server_region_from_gdk (Display *dpy, cairo_region_t *source)
 {
   XserverRegion dest;
   XRectangle *dest_rects;
-  GdkRectangle *source_rects;
+  cairo_rectangle_int_t source_rect;
   int n_rectangles, i;
 
-  gdk_region_get_rectangles (source, &source_rects, &n_rectangles);
+  n_rectangles = cairo_region_num_rectangles (source);
   g_assert (n_rectangles);
   dest_rects = g_new (XRectangle, n_rectangles);
   for (i = 0; i < n_rectangles; i++) {
-    dest_rects[i].x = source_rects[i].x;
-    dest_rects[i].y = source_rects[i].y;
-    dest_rects[i].width = source_rects[i].width;
-    dest_rects[i].height = source_rects[i].height;
+    cairo_region_get_rectangle (source, i, &source_rect);
+    dest_rects[i].x = source_rect.x;
+    dest_rects[i].y = source_rect.y;
+    dest_rects[i].width = source_rect.width;
+    dest_rects[i].height = source_rect.height;
   }
   dest = XFixesCreateRegion (dpy, dest_rects, n_rectangles);
   g_free (dest_rects);
-  g_free (source_rects);
 
   return dest;
 }
 
-static GdkRegion *
+static cairo_region_t *
 byzanz_layer_window_snapshot (ByzanzLayer *layer)
 {
-  Display *dpy = gdk_x11_drawable_get_xdisplay (layer->recorder->window);
+  Display *dpy = GDK_DISPLAY_XDISPLAY (gdk_window_get_display (layer->recorder->window));
   ByzanzLayerWindow *wlayer = BYZANZ_LAYER_WINDOW (layer);
   XserverRegion reg;
-  GdkRegion *region;
+  cairo_region_t *region;
 
-  if (gdk_region_empty (wlayer->invalid))
+  if (cairo_region_is_empty (wlayer->invalid))
     return NULL;
 
   reg = byzanz_server_region_from_gdk (dpy, wlayer->invalid);
@@ -93,66 +94,18 @@ byzanz_layer_window_snapshot (ByzanzLayer *layer)
   XFixesDestroyRegion (dpy, reg);
 
   region = wlayer->invalid;
-  wlayer->invalid = gdk_region_new ();
+  wlayer->invalid = cairo_region_create ();
   return region;
 }
 
-#if CAIRO_VERSION < CAIRO_VERSION_ENCODE (1, 8, 8)
-  /* This fix is for RHEL6 only */
-static void
-byzanz_layer_window_render (ByzanzLayer *layer,
-                            cairo_t *    cr)
-{
-  cairo_t *tmp;
-
-  byzanz_cairo_set_source_window (cr, layer->recorder->window, 0, 0);
-  cairo_paint (cr);
-}
-#else
 static void
 byzanz_cairo_set_source_window (cairo_t *cr, GdkWindow *window, double x, double y)
 {
-#if CAIRO_VERSION < CAIRO_VERSION_ENCODE (1, 80, 10)
-  /* This fix is for RHEL6 only */
-  {
-    static const cairo_user_data_key_t key;
-    double x1, y1_, x2, y2;
-    int w, h;
-    GdkPixmap *pixmap;
-    GdkGC *gc;
-    
-    cairo_clip_extents (cr, &x1, &y1_, &x2, &y2);
-    gdk_drawable_get_size (window, &w, &h);
-    
-    x1 = floor (x1);
-    y1_ = floor (y1_);
-    x2 = floor (x2);
-    y2 = floor (y2);
-    x1 = MAX (x1, 0);
-    y1_ = MAX (y1_, 0);
-    x2 = MIN (x2, w);
-    y2 = MIN (y2, h);
-
-    pixmap = gdk_pixmap_new (window, x2 - x1, y2 - y1_, -1);
-    gc = gdk_gc_new (pixmap);
-    gdk_gc_set_subwindow (gc, GDK_INCLUDE_INFERIORS);
-
-    gdk_draw_drawable (pixmap, gc, window,
-                       x1, y1_,
-                       0, 0,
-                       x2 - x1, y2 - y1_);
-    gdk_cairo_set_source_pixmap (cr, pixmap, x1, y1_);
-
-    g_object_unref (gc);
-    cairo_set_user_data (cr, &key, pixmap, g_object_unref);
-  }
-#else
   cairo_t *tmp;
 
   tmp = gdk_cairo_create (window);
   cairo_set_source_surface (cr, cairo_get_target (tmp), x, y);
   cairo_destroy (tmp);
-#endif
 }
 
 static void
@@ -162,16 +115,15 @@ byzanz_layer_window_render (ByzanzLayer *layer,
   byzanz_cairo_set_source_window (cr, layer->recorder->window, 0, 0);
   cairo_paint (cr);
 }
-#endif
 
 static void
 byzanz_layer_window_finalize (GObject *object)
 {
-  Display *dpy = gdk_x11_drawable_get_xdisplay (BYZANZ_LAYER (object)->recorder->window);
+  Display *dpy = GDK_DISPLAY_XDISPLAY (gdk_window_get_display (BYZANZ_LAYER (object)->recorder->window));
   ByzanzLayerWindow *wlayer = BYZANZ_LAYER_WINDOW (object);
 
   XDamageDestroy (dpy, wlayer->damage);
-  gdk_region_destroy (wlayer->invalid);
+  cairo_region_destroy (wlayer->invalid);
 
   G_OBJECT_CLASS (byzanz_layer_window_parent_class)->finalize (object);
 }
@@ -181,11 +133,11 @@ byzanz_layer_window_constructed (GObject *object)
 {
   ByzanzLayer *layer = BYZANZ_LAYER (object);
   GdkWindow *window = layer->recorder->window;
-  Display *dpy = gdk_x11_drawable_get_xdisplay (window);
+  Display *dpy = GDK_DISPLAY_XDISPLAY (gdk_window_get_display (window));
   ByzanzLayerWindow *wlayer = BYZANZ_LAYER_WINDOW (object);
 
-  wlayer->damage = XDamageCreate (dpy, gdk_x11_drawable_get_xid (window), XDamageReportDeltaRectangles);
-  gdk_region_union_with_rect (wlayer->invalid, &layer->recorder->area);
+  wlayer->damage = XDamageCreate (dpy, gdk_x11_window_get_xid (window), XDamageReportDeltaRectangles);
+  cairo_region_union_rectangle (wlayer->invalid, &layer->recorder->area);
 
   G_OBJECT_CLASS (byzanz_layer_window_parent_class)->constructed (object);
 }
@@ -207,6 +159,6 @@ byzanz_layer_window_class_init (ByzanzLayerWindowClass *klass)
 static void
 byzanz_layer_window_init (ByzanzLayerWindow *wlayer)
 {
-  wlayer->invalid = gdk_region_new ();
+  wlayer->invalid = cairo_region_create ();
 }
 
diff --git a/src/byzanzlayerwindow.h b/src/byzanzlayerwindow.h
index c93fa2d..70a7d2c 100644
--- a/src/byzanzlayerwindow.h
+++ b/src/byzanzlayerwindow.h
@@ -38,7 +38,7 @@ typedef struct _ByzanzLayerWindowClass ByzanzLayerWindowClass;
 struct _ByzanzLayerWindow {
   ByzanzLayer           layer;
 
-  GdkRegion *           invalid;                /* TRUE if we need to repaint */
+  cairo_region_t *      invalid;                /* TRUE if we need to repaint */
   Damage		damage;		        /* the Damage object */
 };
 
diff --git a/src/byzanzrecorder.c b/src/byzanzrecorder.c
index 31675ec..25666ad 100644
--- a/src/byzanzrecorder.c
+++ b/src/byzanzrecorder.c
@@ -48,13 +48,13 @@ enum {
 G_DEFINE_TYPE (ByzanzRecorder, byzanz_recorder, G_TYPE_OBJECT)
 static guint signals[LAST_SIGNAL] = { 0, };
 
-static GdkRegion *
+static cairo_region_t *
 byzanz_recorder_get_invalid_region (ByzanzRecorder *recorder)
 {
-  GdkRegion *invalid, *layer_invalid;
+  cairo_region_t *invalid, *layer_invalid;
   GSequenceIter *iter;
 
-  invalid = gdk_region_new ();
+  invalid = cairo_region_create ();
   for (iter = g_sequence_get_begin_iter (recorder->layers);
        !g_sequence_iter_is_end (iter);
        iter = g_sequence_iter_next (iter)) {
@@ -63,8 +63,8 @@ byzanz_recorder_get_invalid_region (ByzanzRecorder *recorder)
 
     layer_invalid = klass->snapshot (layer);
     if (layer_invalid) {
-      gdk_region_union (invalid, layer_invalid);
-      gdk_region_destroy (layer_invalid);
+      cairo_region_union (invalid, layer_invalid);
+      cairo_region_destroy (layer_invalid);
     }
   }
 
@@ -72,23 +72,32 @@ byzanz_recorder_get_invalid_region (ByzanzRecorder *recorder)
 }
 
 static cairo_surface_t *
-ensure_image_surface (cairo_surface_t *surface, const GdkRegion *region)
+ensure_image_surface (cairo_surface_t *surface, const cairo_region_t *region)
 {
-  GdkRectangle extents;
+  cairo_rectangle_int_t extents;
   cairo_surface_t *image;
   cairo_t *cr;
+  int i, num_rects;
 
   if (cairo_surface_get_type (surface) == CAIRO_SURFACE_TYPE_IMAGE)
     return surface;
 
-  gdk_region_get_clipbox (region, &extents);
+  cairo_region_get_extents (region, &extents);
   image = cairo_image_surface_create (CAIRO_FORMAT_RGB24, extents.width, extents.height);
   cairo_surface_set_device_offset (image, -extents.x, -extents.y);
 
   cr = cairo_create (image);
   cairo_set_source_surface (cr, surface, 0, 0);
   cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
-  gdk_cairo_region (cr, region);
+
+  num_rects = cairo_region_num_rectangles (region);
+  for (i = 0; i < num_rects; i++) {
+    cairo_rectangle_int_t rect;
+    cairo_region_get_rectangle (region, i, &rect);
+    cairo_rectangle (cr, rect.x, rect.y,
+                     rect.width, rect.height);
+  }
+
   cairo_fill (cr);
   cairo_destroy (cr);
 
@@ -97,14 +106,15 @@ ensure_image_surface (cairo_surface_t *surface, const GdkRegion *region)
 }
 
 static cairo_surface_t *
-byzanz_recorder_create_snapshot (ByzanzRecorder *recorder, const GdkRegion *invalid)
+byzanz_recorder_create_snapshot (ByzanzRecorder *recorder, const cairo_region_t *invalid)
 {
-  GdkRectangle extents;
+  cairo_rectangle_int_t extents;
   cairo_surface_t *surface;
   cairo_t *cr;
   GSequenceIter *iter;
+  int i, num_rects;
   
-  gdk_region_get_clipbox (invalid, &extents);
+  cairo_region_get_extents (invalid, &extents);
   cr = gdk_cairo_create (recorder->window);
   surface = cairo_surface_create_similar (cairo_get_target (cr), CAIRO_CONTENT_COLOR,
       extents.width, extents.height);
@@ -112,7 +122,15 @@ byzanz_recorder_create_snapshot (ByzanzRecorder *recorder, const GdkRegion *inva
   cairo_surface_set_device_offset (surface, -extents.x, -extents.y);
 
   cr = cairo_create (surface);
-  gdk_cairo_region (cr, invalid);
+
+  num_rects = cairo_region_num_rectangles (invalid);
+  for (i = 0; i < num_rects; i++) {
+    cairo_rectangle_int_t rect;
+    cairo_region_get_rectangle (invalid, i, &rect);
+    cairo_rectangle (cr, rect.x, rect.y,
+                     rect.width, rect.height);
+  }
+
   cairo_clip (cr);
 
   for (iter = g_sequence_get_begin_iter (recorder->layers);
@@ -157,7 +175,7 @@ static gboolean
 byzanz_recorder_snapshot (ByzanzRecorder *recorder)
 {
   cairo_surface_t *surface;
-  GdkRegion *invalid;
+  cairo_region_t *invalid;
   GTimeVal tv;
 
   if (!recorder->recording)
@@ -167,19 +185,19 @@ byzanz_recorder_snapshot (ByzanzRecorder *recorder)
     return FALSE;
 
   invalid = byzanz_recorder_get_invalid_region (recorder);
-  if (gdk_region_empty (invalid)) {
-    gdk_region_destroy (invalid);
+  if (cairo_region_is_empty (invalid)) {
+    cairo_region_destroy (invalid);
     return FALSE;
   }
 
   surface = byzanz_recorder_create_snapshot (recorder, invalid);
   g_get_current_time (&tv);
-  gdk_region_offset (invalid, -recorder->area.x, -recorder->area.y);
+  cairo_region_translate (invalid, -recorder->area.x, -recorder->area.y);
 
   g_signal_emit (recorder, signals[IMAGE], 0, surface, invalid, &tv);
 
   cairo_surface_destroy (surface);
-  gdk_region_destroy (invalid);
+  cairo_region_destroy (invalid);
 
   recorder->next_image_source = gdk_threads_add_timeout_full (G_PRIORITY_HIGH_IDLE,
       BYZANZ_RECORDER_FRAME_RATE_MS, byzanz_recorder_next_image, recorder, NULL);
@@ -254,7 +272,7 @@ byzanz_recorder_set_property (GObject *object, guint param_id, const GValue *val
       byzanz_recorder_set_window (recorder, g_value_get_object (value));
       break;
     case PROP_AREA:
-      recorder->area = *(GdkRectangle *) g_value_get_boxed (value);
+      recorder->area = *(cairo_rectangle_int_t *) g_value_get_boxed (value);
       break;
     case PROP_RECORDING:
       byzanz_recorder_set_recording (recorder, g_value_get_boolean (value));
@@ -362,7 +380,7 @@ byzanz_recorder_init (ByzanzRecorder *recorder)
 }
 
 ByzanzRecorder *
-byzanz_recorder_new (GdkWindow *window, GdkRectangle *area)
+byzanz_recorder_new (GdkWindow *window, cairo_rectangle_int_t *area)
 {
   g_return_val_if_fail (GDK_IS_WINDOW (window), NULL);
   g_return_val_if_fail (area != NULL, NULL);
diff --git a/src/byzanzrecorder.h b/src/byzanzrecorder.h
index 1a4be56..b88ff32 100644
--- a/src/byzanzrecorder.h
+++ b/src/byzanzrecorder.h
@@ -39,7 +39,7 @@ struct _ByzanzRecorder {
   GObject		object;
 
   GdkWindow *           window;                 /* window we are recording from */
-  GdkRectangle          area;                   /* area of window that we record */
+  cairo_rectangle_int_t area;                   /* area of window that we record */
   gboolean              recording;              /* wether we should be recording now */
 
   int                   damage_event_base;      /* base event for Damage extension */
@@ -55,16 +55,16 @@ struct _ByzanzRecorder {
 struct _ByzanzRecorderClass {
   GObjectClass		object_class;
 
-  void                  (* image)                       (ByzanzRecorder *       recorder,
-                                                         cairo_surface_t *      surface,
-                                                         const GdkRegion *      region,
-                                                         const GTimeVal *       tv);
+  void                  (* image)                       (ByzanzRecorder *        recorder,
+                                                         cairo_surface_t *       surface,
+                                                         const cairo_surface_t * region,
+                                                         const GTimeVal *        tv);
 };
 
 GType		        byzanz_recorder_get_type	(void) G_GNUC_CONST;
 
-ByzanzRecorder *	byzanz_recorder_new		(GdkWindow *		window,
-							 GdkRectangle *		area);
+ByzanzRecorder *	byzanz_recorder_new		(GdkWindow *		 window,
+							 cairo_rectangle_int_t * area);
 
 void                    byzanz_recorder_set_recording   (ByzanzRecorder *       recorder,
                                                          gboolean               recording);
diff --git a/src/byzanzselect.c b/src/byzanzselect.c
index abf0f25..c74b1ef 100644
--- a/src/byzanzselect.c
+++ b/src/byzanzselect.c
@@ -28,7 +28,7 @@
 #include "screenshot-utils.h"
 
 static void
-rectangle_sanitize (GdkRectangle *dest, const GdkRectangle *src)
+rectangle_sanitize (cairo_rectangle_int_t *dest, const cairo_rectangle_int_t *src)
 {
   *dest = *src;
   if (dest->width < 0) {
@@ -48,7 +48,7 @@ struct _ByzanzSelectData {
 
   /* results */
   GdkWindow *           result;         /* window that was selected */
-  GdkRectangle          area;           /* the area to select */
+  cairo_rectangle_int_t area;           /* the area to select */
 
   /* method data */
   GtkWidget *           window;         /* window we created to do selecting or NULL */
@@ -91,7 +91,7 @@ byzanz_select_done (ByzanzSelectData *data, GdkWindow *window)
 
   if (window) {
     /* stupid hack to get around a session recording the selection window */
-    gdk_display_sync (gdk_drawable_get_display (GDK_DRAWABLE (window)));
+    gdk_display_sync (gdk_window_get_display (window));
     data->result = g_object_ref (window);
     gdk_threads_add_timeout (1000, byzanz_select_really_done, data);
   } else {
@@ -113,7 +113,7 @@ expose_cb (GtkWidget *widget, GdkEventExpose *event, gpointer datap)
   static double dashes[] = { 1.0, 2.0 };
 #endif
 
-  cr = gdk_cairo_create (widget->window);
+  cr = gdk_cairo_create (gtk_widget_get_window (widget));
   cairo_rectangle (cr, event->area.x, event->area.y, event->area.width, event->area.height);
   cairo_clip (cr);
 
@@ -140,11 +140,11 @@ expose_cb (GtkWidget *widget, GdkEventExpose *event, gpointer datap)
   cairo_stroke (cr);
 #endif
   if (data->area.x >= 0 && data->area.width != 0 && data->area.height != 0) {
-    GdkRectangle rect = data->area;
+    cairo_rectangle_int_t rect = data->area;
     rectangle_sanitize (&rect, &data->area);
     cairo_set_source_rgba (cr, 0.0, 0.0, 0.5, 0.2);
     cairo_set_dash (cr, NULL, 0, 0.0);
-    gdk_cairo_rectangle (cr, &rect);
+    gdk_cairo_rectangle (cr, (GdkRectangle *) &rect);
     cairo_fill (cr);
     cairo_set_source_rgba (cr, 0.0, 0.0, 0.5, 0.5);
     cairo_rectangle (cr, rect.x + 0.5, rect.y + 0.5, rect.width - 1, rect.height - 1);
@@ -199,7 +199,7 @@ motion_notify_cb (GtkWidget *widget, GdkEventMotion *event, gpointer datap)
   gtk_widget_queue_draw (widget);
 #else
   if (data->area.x >= 0) {
-    GdkRectangle rect;
+    cairo_rectangle_int_t rect;
     rectangle_sanitize (&rect, &data->area);
     gtk_widget_queue_draw_area (widget, rect.x, rect.y, rect.width, rect.height);
   }
@@ -207,7 +207,7 @@ motion_notify_cb (GtkWidget *widget, GdkEventMotion *event, gpointer datap)
   data->area.width = event->x - data->area.x;
   data->area.height = event->y - data->area.y;
   if (data->area.x >= 0) {
-    GdkRectangle rect;
+    cairo_rectangle_int_t rect;
     rectangle_sanitize (&rect, &data->area);
     gtk_widget_queue_draw_area (widget, rect.x, rect.y, rect.width, rect.height);
   }
@@ -218,7 +218,7 @@ motion_notify_cb (GtkWidget *widget, GdkEventMotion *event, gpointer datap)
 static void
 realize_cb (GtkWidget *widget, gpointer datap)
 {
-  GdkWindow *window = widget->window;
+  GdkWindow *window = gtk_widget_get_window (widget);
   GdkCursor *cursor;
 
   gdk_window_set_events (window, gdk_window_get_events (window) |
@@ -228,7 +228,7 @@ realize_cb (GtkWidget *widget, gpointer datap)
   cursor = gdk_cursor_new (GDK_CROSSHAIR);
   gdk_window_set_cursor (window, cursor);
   gdk_cursor_unref (cursor);
-  gdk_window_set_back_pixmap (window, NULL, FALSE);
+  gdk_window_set_background_pattern (window, NULL);
 }
 
 static void
@@ -247,21 +247,22 @@ active_cb (GtkWindow *window, GParamSpec *pspec, ByzanzSelectData *data)
 static void
 byzanz_select_area (ByzanzSelectData *data)
 {
-  GdkColormap *rgba;
+  GdkVisual *visual;
   
   data->window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
   data->area.x = -1;
   data->area.y = -1;
 
-  rgba = gdk_screen_get_rgba_colormap (gdk_screen_get_default ());
-  if (rgba && gdk_screen_is_composited (gdk_screen_get_default ())) {
-    gtk_widget_set_colormap (data->window, rgba);
+  visual = gdk_screen_get_rgba_visual (gdk_screen_get_default ());
+  if (visual && gdk_screen_is_composited (gdk_screen_get_default ())) {
+    gtk_widget_set_visual (data->window, visual);
   } else {
     GdkWindow *root = gdk_get_default_root_window ();
     cairo_t *cr;
     cairo_surface_t *root_surface;
     gint width, height;
-    gdk_drawable_get_size (root, &width, &height);
+    width = gdk_window_get_width (root);
+    height = gdk_window_get_height (root);
 
     cr = gdk_cairo_create (root);
     root_surface = cairo_surface_reference (cairo_get_target (cr));
@@ -294,7 +295,8 @@ byzanz_select_screen (ByzanzSelectData *data)
   GdkWindow *root;
   
   root = gdk_get_default_root_window ();
-  gdk_drawable_get_size (root, &data->area.width, &data->area.height);
+  data->area.width = gdk_window_get_width (root);
+  data->area.height = gdk_window_get_height (root);
   byzanz_select_done (data, root);
 }
 
@@ -312,12 +314,13 @@ select_window_button_pressed_cb (GtkWidget *widget, GdkEventButton *event, gpoin
 
     w = screenshot_find_current_window (TRUE);
     if (w != None)
-      window = gdk_window_foreign_new (w);
+      window = gdk_x11_window_foreign_new_for_display (gdk_display_get_default (), w);
     else
       window = gdk_get_default_root_window ();
 
     gdk_window_get_root_origin (window, &data->area.x, &data->area.y);
-    gdk_drawable_get_size (window, &data->area.width, &data->area.height);
+    data->area.width = gdk_window_get_width (window);
+    data->area.height = gdk_window_get_height (window);
     g_object_unref (window);
 
     window = gdk_get_default_root_window ();
@@ -338,7 +341,7 @@ byzanz_select_window (ByzanzSelectData *data)
   g_signal_connect (data->window, "button-press-event", 
       G_CALLBACK (select_window_button_pressed_cb), data);
   gtk_widget_show (data->window);
-  gdk_pointer_grab (data->window->window, FALSE, GDK_BUTTON_PRESS_MASK, NULL, cursor, GDK_CURRENT_TIME);
+  gdk_pointer_grab (gtk_widget_get_window (data->window), FALSE, GDK_BUTTON_PRESS_MASK, NULL, cursor, GDK_CURRENT_TIME);
   gdk_cursor_unref (cursor);
 }
   
diff --git a/src/byzanzselect.h b/src/byzanzselect.h
index e7f04e2..188fe0e 100644
--- a/src/byzanzselect.h
+++ b/src/byzanzselect.h
@@ -30,7 +30,7 @@ const char *		byzanz_select_method_get_icon_name      (guint	                met
 const char *		byzanz_select_method_get_name	        (guint		        method);
 int			byzanz_select_method_lookup	        (const char *	        name);
 
-typedef void (* ByzanzSelectFunc) (GdkWindow *window, const GdkRectangle *area, gpointer data);
+typedef void (* ByzanzSelectFunc) (GdkWindow *window, const cairo_rectangle_int_t *area, gpointer data);
 void    		byzanz_select_method_select	        (guint		        method,
                                                                  ByzanzSelectFunc       func,
                                                                  gpointer               data);
diff --git a/src/byzanzserialize.c b/src/byzanzserialize.c
index ad1232b..308a46a 100644
--- a/src/byzanzserialize.c
+++ b/src/byzanzserialize.c
@@ -106,22 +106,22 @@ byzanz_deserialize_header (GInputStream * stream,
 } 
 
 gboolean
-byzanz_serialize (GOutputStream *   stream,
-                  guint64           msecs,
-                  cairo_surface_t * surface,
-                  const GdkRegion * region,
-                  GCancellable *    cancellable,
-                  GError **         error)
+byzanz_serialize (GOutputStream *        stream,
+                  guint64                msecs,
+                  cairo_surface_t *      surface,
+                  const cairo_region_t * region,
+                  GCancellable *         cancellable,
+                  GError **              error)
 {
   guint i, stride;
-  GdkRectangle *rects, extents;
+  cairo_rectangle_int_t rect, extents;
   guchar *data;
   guint32 n;
   int y, n_rects;
 
   g_return_val_if_fail (G_IS_OUTPUT_STREAM (stream), FALSE);
   g_return_val_if_fail ((surface == NULL) == (region == NULL), FALSE);
-  g_return_val_if_fail (region == NULL || !gdk_region_empty (region), FALSE);
+  g_return_val_if_fail (region == NULL || !cairo_region_is_empty (region), FALSE);
 
   if (!g_output_stream_write_all (stream, &msecs, sizeof (guint64), NULL, cancellable, error))
     return FALSE;
@@ -131,51 +131,48 @@ byzanz_serialize (GOutputStream *   stream,
     return g_output_stream_write_all (stream, &n, sizeof (guint32), NULL, cancellable, error);
   }
 
-  gdk_region_get_rectangles (region, &rects, &n_rects);
-  n = n_rects;
+  n = n_rects = cairo_region_num_rectangles (region);
   if (!g_output_stream_write_all (stream, &n, sizeof (guint32), NULL, cancellable, error))
-    goto fail;
+    return FALSE;
   for (i = 0; i < n; i++) {
-    gint32 ints[4] = { rects[i].x, rects[i].y, rects[i].width, rects[i].height };
+    gint32 ints[4];
+    cairo_region_get_rectangle (region, i, &rect);
+    ints[0] = rect.x, ints[1] = rect.y, ints[2] = rect.width, ints[3] = rect.height;
 
     g_assert (sizeof (ints) == 16);
     if (!g_output_stream_write_all (stream, ints, sizeof (ints), NULL, cancellable, error))
-      goto fail;
+      return FALSE;
   }
 
   stride = cairo_image_surface_get_stride (surface);
-  gdk_region_get_clipbox (region, &extents);
+  cairo_region_get_extents (region, &extents);
   for (i = 0; i < n; i++) {
+    cairo_region_get_rectangle (region, i, &rect);
     data = cairo_image_surface_get_data (surface) 
-      + stride * (rects[i].y - extents.y) 
-      + sizeof (guint32) * (rects[i].x - extents.x);
-    for (y = 0; y < rects[i].height; y++) {
+      + stride * (rect.y - extents.y) 
+      + sizeof (guint32) * (rect.x - extents.x);
+    for (y = 0; y < rect.height; y++) {
       if (!g_output_stream_write_all (G_OUTPUT_STREAM (stream), data, 
-            rects[i].width * sizeof (guint32), NULL, cancellable, error))
-        goto fail;
+            rect.width * sizeof (guint32), NULL, cancellable, error))
+        return FALSE;
       data += stride;
     }
   }
 
-  g_free (rects);
   return TRUE;
-
-fail:
-  g_free (rects);
-  return FALSE;
 }
 
 gboolean
 byzanz_deserialize (GInputStream *     stream,
                     guint64 *          msecs_out,
                     cairo_surface_t ** surface_out,
-                    GdkRegion **       region_out,
+                    cairo_region_t **  region_out,
                     GCancellable *     cancellable,
                     GError **          error)
 {
   guint i, stride;
-  GdkRectangle extents, *rects;
-  GdkRegion *region;
+  cairo_rectangle_int_t extents, *rects;
+  cairo_region_t *region;
   cairo_surface_t *surface;
   guchar *data;
   guint32 n;
@@ -197,8 +194,8 @@ byzanz_deserialize (GInputStream *     stream,
     return TRUE;
   }
 
-  region = gdk_region_new ();
-  rects = g_new (GdkRectangle, n);
+  region = cairo_region_create ();
+  rects = g_new (cairo_rectangle_int_t, n);
   surface = NULL;
   for (i = 0; i < n; i++) {
     gint ints[4];
@@ -209,10 +206,10 @@ byzanz_deserialize (GInputStream *     stream,
     rects[i].y = ints[1];
     rects[i].width = ints[2];
     rects[i].height = ints[3];
-    gdk_region_union_with_rect (region, &rects[i]);
+    cairo_region_union_rectangle (region, &rects[i]);
   }
 
-  gdk_region_get_clipbox (region, &extents);
+  cairo_region_get_extents (region, &extents);
   surface = cairo_image_surface_create (CAIRO_FORMAT_RGB24, extents.width, extents.height);
   cairo_surface_set_device_offset (surface, -extents.x, -extents.y);
   stride = cairo_image_surface_get_stride (surface);
@@ -236,7 +233,7 @@ byzanz_deserialize (GInputStream *     stream,
 fail:
   if (surface)
     cairo_surface_destroy (surface);
-  gdk_region_destroy (region);
+  cairo_region_destroy (region);
   g_free (rects);
   return FALSE;
 }
diff --git a/src/byzanzserialize.h b/src/byzanzserialize.h
index 8ab5881..6f8f4bf 100644
--- a/src/byzanzserialize.h
+++ b/src/byzanzserialize.h
@@ -30,12 +30,12 @@ gboolean                byzanz_serialize_header         (GOutputStream *
                                                          guint                  height,
                                                          GCancellable *         cancellable,
                                                          GError **              error);
-gboolean                byzanz_serialize                (GOutputStream *        stream,
-                                                         guint64                msecs,
-                                                         cairo_surface_t *      surface,
-                                                         const GdkRegion *      region,
-                                                         GCancellable *         cancellable,
-                                                         GError **              error);
+gboolean                byzanz_serialize                (GOutputStream *         stream,
+                                                         guint64                 msecs,
+                                                         cairo_surface_t *       surface,
+                                                         const cairo_region_t * region,
+                                                         GCancellable *          cancellable,
+                                                         GError **               error);
 
 gboolean                byzanz_deserialize_header       (GInputStream *         stream,
                                                          guint *                width,
@@ -45,7 +45,7 @@ gboolean                byzanz_deserialize_header       (GInputStream *
 gboolean                byzanz_deserialize              (GInputStream *         stream,
                                                          guint64 *              msecs_out,
                                                          cairo_surface_t **     surface_out,
-                                                         GdkRegion **           region_out,
+                                                         cairo_region_t **      region_out,
                                                          GCancellable *         cancellable,
                                                          GError **              error);
 
diff --git a/src/byzanzsession.c b/src/byzanzsession.c
index df36c62..0cd7c67 100644
--- a/src/byzanzsession.c
+++ b/src/byzanzsession.c
@@ -105,7 +105,7 @@ byzanz_session_set_property (GObject *object, guint param_id, const GValue *valu
       session->file = g_value_dup_object (value);
       break;
     case PROP_AREA:
-      session->area = *(GdkRectangle *) g_value_get_boxed (value);
+      session->area = *(cairo_rectangle_int_t *) g_value_get_boxed (value);
       break;
     case PROP_WINDOW:
       session->window = g_value_dup_object (value);
@@ -185,11 +185,11 @@ byzanz_session_elapsed (ByzanzSession *session, const GTimeVal *tv)
 }
 
 static void
-byzanz_session_recorder_image_cb (ByzanzRecorder *  recorder,
-                                  cairo_surface_t * surface,
-                                  const GdkRegion * region,
-                                  const GTimeVal *  tv,
-                                  ByzanzSession *   session)
+byzanz_session_recorder_image_cb (ByzanzRecorder *       recorder,
+                                  cairo_surface_t *      surface,
+                                  const cairo_region_t * region,
+                                  const GTimeVal *       tv,
+                                  ByzanzSession *        session)
 {
   GOutputStream *stream;
   GError *error = NULL;
@@ -328,7 +328,7 @@ byzanz_session_init (ByzanzSession *session)
  **/
 ByzanzSession *
 byzanz_session_new (GFile *file, GType encoder_type, 
-    GdkWindow *window, const GdkRectangle *area, gboolean record_cursor,
+    GdkWindow *window, const cairo_rectangle_int_t *area, gboolean record_cursor,
     gboolean record_audio)
 {
   g_return_val_if_fail (G_IS_FILE (file), NULL);
diff --git a/src/byzanzsession.h b/src/byzanzsession.h
index ed6c32d..7362da6 100644
--- a/src/byzanzsession.h
+++ b/src/byzanzsession.h
@@ -43,7 +43,7 @@ struct _ByzanzSession {
   /*< private >*/
   /* properties */
   GFile *               file;           /* file we're saving to */
-  GdkRectangle          area;           /* area of window to record */
+  cairo_rectangle_int_t area;           /* area of window to record */
   GdkWindow *           window;         /* window to record */
   gboolean              record_audio;   /* TRUE to record audio */
   GType                 encoder_type;   /* type of encoder to use */
@@ -64,12 +64,12 @@ struct _ByzanzSessionClass {
 GType		        byzanz_session_get_type		(void) G_GNUC_CONST;
 
 
-ByzanzSession * 	byzanz_session_new		(GFile *                file,
-                                                         GType                  encoder_type,
-							 GdkWindow *		window,
-							 const GdkRectangle *	area,
-							 gboolean		record_cursor,
-                                                         gboolean               record_audio);
+ByzanzSession * 	byzanz_session_new		(GFile *                        file,
+                                                         GType                          encoder_type,
+							 GdkWindow *		        window,
+							 const cairo_rectangle_int_t *	area,
+							 gboolean		        record_cursor,
+                                                         gboolean                       record_audio);
 void			byzanz_session_start		(ByzanzSession *	session);
 void			byzanz_session_stop		(ByzanzSession *	session);
 void			byzanz_session_abort            (ByzanzSession *	session);
diff --git a/src/org.gnome.ByzanzApplet.panel-applet.in.in b/src/org.gnome.ByzanzApplet.panel-applet.in.in
new file mode 100644
index 0000000..bc611c9
--- /dev/null
+++ b/src/org.gnome.ByzanzApplet.panel-applet.in.in
@@ -0,0 +1,16 @@
+[Applet Factory]
+Id=ByzanzAppletFactory
+Location=@LIBEXECDIR@/byzanz-applet
+_Name=Byzanz Factory
+_Description=Byzanz Factory
+
+[ByzanzApplet]
+_Name=Desktop Recorder
+_Description=Record what's happening on your desktop
+Icon=byzanz-record-desktop.png
+BonoboId=OAFIID:ByzanzApplet
+X-GNOME-Bugzilla-Bugzilla=GNOME
+X-GNOME-Bugzilla-Product=byzanz
+X-GNOME-Bugzilla-Component=applet
+X-GNOME-Bugzilla-Version=@VERSION@
+X-GNOME-Bugzilla-OtherBinaries=byzanz-applet
diff --git a/src/org.gnome.panel.applet.ByzanzAppletFactory.service.in b/src/org.gnome.panel.applet.ByzanzAppletFactory.service.in
new file mode 100644
index 0000000..492be10
--- /dev/null
+++ b/src/org.gnome.panel.applet.ByzanzAppletFactory.service.in
@@ -0,0 +1,3 @@
+[D-BUS Service]
+Name=org.gnome.panel.applet.ByzanzAppletFactory
+Exec=@LIBEXECDIR@/byzanz-applet
diff --git a/src/paneltogglebutton.c b/src/paneltogglebutton.c
index 245f0d8..2a76e28 100644
--- a/src/paneltogglebutton.c
+++ b/src/paneltogglebutton.c
@@ -32,7 +32,7 @@ panel_toggle_button_size_request (GtkWidget *widget,
 {
   GtkWidget *child;
   
-  child = GTK_BIN (widget)->child;
+  child = gtk_bin_get_child (GTK_BIN (widget));
 
   if (child) {
     gtk_widget_size_request (child, requisition);
@@ -42,53 +42,77 @@ panel_toggle_button_size_request (GtkWidget *widget,
 }
 
 static void
+panel_toggle_button_get_preferred_width (GtkWidget *widget,
+                                         gint      *minimal_width,
+                                         gint      *natural_width)
+{
+  GtkRequisition requisition;
+
+  panel_toggle_button_size_request (widget, &requisition);
+
+  *minimal_width = *natural_width = requisition.width;
+}
+
+static void
+panel_toggle_button_get_preferred_height (GtkWidget *widget,
+                                          gint      *minimal_height,
+                                          gint      *natural_height)
+{
+  GtkRequisition requisition;
+
+  panel_toggle_button_size_request (widget, &requisition);
+
+  *minimal_height = *natural_height = requisition.height;
+}
+
+static void
 panel_toggle_button_size_allocate (GtkWidget *widget,
     GtkAllocation *allocation)
 {
   GtkWidget *child;
   
-  child = GTK_BIN (widget)->child;
+  child = gtk_bin_get_child (GTK_BIN (widget));
 
-  widget->allocation = *allocation;
+  gtk_widget_set_allocation (widget, allocation);
   
-  if (GTK_WIDGET_REALIZED (widget))
-    gdk_window_move_resize (GTK_BUTTON (widget)->event_window, 
-	widget->allocation.x, widget->allocation.y,
-	widget->allocation.width, widget->allocation.height);
+  if (gtk_widget_get_realized (widget))
+    gdk_window_move_resize (gtk_button_get_event_window (GTK_BUTTON(widget)), 
+	allocation->x, allocation->y,
+	allocation->width, allocation->height); 
   
   if (child)
     gtk_widget_size_allocate (child, allocation);
 }
 
 static gboolean
-panel_toggle_button_expose (GtkWidget *widget, GdkEventExpose *event)
+panel_toggle_button_draw (GtkWidget *widget, cairo_t *cr)
 {
-  if (GTK_WIDGET_DRAWABLE (widget)) {
-    GtkWidget *child = GTK_BIN (widget)->child;
-    GtkStateType state_type;
-    GtkShadowType shadow_type;
+  GtkWidget *child = gtk_bin_get_child (GTK_BIN (widget));
+  GtkStateType state_type;
+  GtkShadowType shadow_type;
+  GtkAllocation allocation;
 
-    state_type = GTK_WIDGET_STATE (widget);
+  state_type = gtk_widget_get_state (widget);
     
-    /* FIXME: someone make this layout work nicely for all themes
-     * Currently I'm trying to imitate the volume applet's widget */
-    if (GTK_TOGGLE_BUTTON (widget)->inconsistent) {
-      if (state_type == GTK_STATE_ACTIVE)
-	state_type = GTK_STATE_NORMAL;
-      shadow_type = GTK_SHADOW_ETCHED_IN;
-    } else {
-      shadow_type = GTK_BUTTON (widget)->depressed ? GTK_SHADOW_IN : GTK_SHADOW_OUT;
-    }
-    if (GTK_BUTTON (widget)->depressed)
-      state_type = GTK_STATE_SELECTED;
-    /* FIXME: better detail? */
-    gtk_paint_flat_box (widget->style, widget->window, state_type, shadow_type,
-	&event->area, widget, "togglebutton", widget->allocation.x,
-	widget->allocation.y, widget->allocation.width, widget->allocation.height);
-      
-    if (child)
-      gtk_container_propagate_expose (GTK_CONTAINER (widget), child, event);
+  /* FIXME: someone make this layout work nicely for all themes
+   * Currently I'm trying to imitate the volume applet's widget */
+  if (gtk_toggle_button_get_inconsistent (GTK_TOGGLE_BUTTON (widget))) {
+    if (state_type == GTK_STATE_ACTIVE)
+      state_type = GTK_STATE_NORMAL;
+    shadow_type = GTK_SHADOW_ETCHED_IN;
+  } else {
+    shadow_type = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)) ? GTK_SHADOW_IN : GTK_SHADOW_OUT;
   }
+  if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)))
+    state_type = GTK_STATE_SELECTED;
+  /* FIXME: better detail? */
+  gtk_widget_get_allocation (widget, &allocation);
+  gtk_paint_flat_box (gtk_widget_get_style (widget), cr, state_type, shadow_type,
+                      widget, "togglebutton", allocation.x,
+                      allocation.y, allocation.width, allocation.height);
+
+  if (child)
+    gtk_container_propagate_draw (GTK_CONTAINER (widget), child, cr);
   
   return FALSE;
 }
@@ -118,9 +142,10 @@ panel_toggle_button_class_init (PanelToggleButtonClass *class)
 
   parent_class = g_type_class_peek_parent (class);
 
-  widget_class->size_request = panel_toggle_button_size_request;
+  widget_class->get_preferred_width = panel_toggle_button_get_preferred_width;
+  widget_class->get_preferred_height = panel_toggle_button_get_preferred_height;
   widget_class->size_allocate = panel_toggle_button_size_allocate;
-  widget_class->expose_event = panel_toggle_button_expose;
+  widget_class->draw = panel_toggle_button_draw;
   widget_class->button_press_event = panel_toggle_button_button_press;
   widget_class->button_release_event = panel_toggle_button_button_release;
 }
diff --git a/src/paneltogglebutton.h b/src/paneltogglebutton.h
index fb5bdbd..35f85b4 100644
--- a/src/paneltogglebutton.h
+++ b/src/paneltogglebutton.h
@@ -22,7 +22,7 @@
 #ifndef __PANEL_TOGGLE_BUTTON_H__
 #define __PANEL_TOGGLE_BUTTON_H__
 
-#include <gtk/gtktogglebutton.h>
+#include <gtk/gtk.h>
 
 G_BEGIN_DECLS
 
diff --git a/src/record.c b/src/record.c
index fa29397..e0871c8 100644
--- a/src/record.c
+++ b/src/record.c
@@ -30,7 +30,7 @@ static int delay = 1;
 static gboolean cursor = FALSE;
 static gboolean audio = FALSE;
 static gboolean verbose = FALSE;
-static GdkRectangle area = { 0, 0, G_MAXINT / 2, G_MAXINT / 2 };
+static cairo_rectangle_int_t area = { 0, 0, G_MAXINT / 2, G_MAXINT / 2 };
 
 static GOptionEntry entries[] = 
 {
@@ -105,12 +105,15 @@ start_recording (gpointer session)
 }
 
 static gboolean
-clamp_to_window (GdkRectangle *out, GdkWindow *window, GdkRectangle *in)
+clamp_to_window (cairo_rectangle_int_t *out, GdkWindow *window, cairo_rectangle_int_t *in)
 {
-  GdkRectangle window_area = { 0, };
+  cairo_rectangle_int_t window_area = { 0, };
 
-  gdk_drawable_get_size (GDK_DRAWABLE (window), &window_area.width, &window_area.height);
-  return gdk_rectangle_intersect (in, &window_area, in);
+  window_area.width = gdk_window_get_width (window);
+  window_area.height = gdk_window_get_height (window);
+  return gdk_rectangle_intersect ((GdkRectangle *) in,
+                                  (GdkRectangle *) &window_area,
+                                  (GdkRectangle *) in);
 }
 
 int
diff --git a/src/screenshot-utils.c b/src/screenshot-utils.c
index bd29061..5f02849 100644
--- a/src/screenshot-utils.c
+++ b/src/screenshot-utils.c
@@ -23,7 +23,7 @@ get_atom_property (Window  xwindow,
   
   gdk_error_trap_push ();
   type = None;
-  result = XGetWindowProperty (gdk_display,
+  result = XGetWindowProperty (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()),
 			       xwindow,
 			       atom,
 			       0, G_MAXLONG,
@@ -56,7 +56,7 @@ find_toplevel_window (Window xid)
 
   do
     {
-      if (XQueryTree (GDK_DISPLAY (), xid, &root,
+      if (XQueryTree (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), xid, &root,
 		      &parent, &children, &nchildren) == 0)
 	{
 	  g_warning ("Couldn't find window manager window");
@@ -79,7 +79,8 @@ screenshot_window_is_desktop (Window xid)
   if (xid == root_window)
     return TRUE;
 
-  if (gdk_net_wm_supports (gdk_atom_intern ("_NET_WM_WINDOW_TYPE", FALSE)))
+  if (gdk_x11_screen_supports_net_wm_hint (gdk_screen_get_default (),
+                                           gdk_atom_intern ("_NET_WM_WINDOW_TYPE", FALSE)))
     {
       gboolean retval;
       Atom property;
@@ -106,7 +107,7 @@ screenshot_find_pointer_window (void)
 
   root_window = GDK_ROOT_WINDOW ();
 
-  XQueryPointer (GDK_DISPLAY (), root_window,
+  XQueryPointer (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), root_window,
 		 &root_return, &child, &unused,
 		 &unused, &unused, &unused, &mask);
 
@@ -128,7 +129,8 @@ look_for_hint_helper (Window    xid,
   Window root, parent, *children, window;
   guint nchildren, i;
 
-  if (XGetWindowProperty (GDK_DISPLAY (), xid, property, 0, 1,
+  if (XGetWindowProperty (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()),
+                          xid, property, 0, 1,
 			  False, AnyPropertyType, &actual_type,
 			  &actual_format, &nitems, &bytes_after,
 			  (gpointer) &prop) == Success
@@ -144,7 +146,7 @@ look_for_hint_helper (Window    xid,
 
   if (depth < MAXIMUM_WM_REPARENTING_DEPTH)
     {
-      if (XQueryTree (GDK_DISPLAY (), xid, &root,
+      if (XQueryTree (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), xid, &root,
 		      &parent, &children, &nchildren) != 0)
 	{
 	  window = None;

Places

File byzanz-gnome3.patch of Package byzanz (Revision ed1ecd798ba9346f4fcd378c9fea6a48)

Places