wip: initial dbus portbonobo-less

15 files changed, 2420 insertions, 4036 deletions

diff --git a/INSTALL b/INSTALL
index 2550dab..7d1c323 100644
--- a/INSTALL
+++ b/INSTALL
@@ -4,8 +4,10 @@ Installation Instructions
 Copyright (C) 1994, 1995, 1996, 1999, 2000, 2001, 2002, 2004, 2005,
 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
 
-   This file is free documentation; the Free Software Foundation gives
-unlimited permission to copy, distribute and modify it.
+   Copying and distribution of this file, with or without modification,
+are permitted in any medium without royalty provided the copyright
+notice and this notice are preserved.  This file is offered as-is,
+without warranty of any kind.
 
 Basic Installation
 ==================
@@ -13,7 +15,11 @@ Basic Installation
    Briefly, the shell commands `./configure; make; make install' should
 configure, build, and install this package.  The following
 more-detailed instructions are generic; see the `README' file for
-instructions specific to this package.
+instructions specific to this package.  Some packages provide this
+`INSTALL' file but do not implement all of the features documented
+below.  The lack of an optional feature in a given package is not
+necessarily a bug.  More recommendations for GNU packages can be found
+in *note Makefile Conventions: (standards)Makefile Conventions.
 
    The `configure' shell script attempts to guess correct values for
 various system-dependent variables used during compilation.  It uses
@@ -42,7 +48,7 @@ may remove or edit it.
 you want to change it or regenerate `configure' using a newer version
 of `autoconf'.
 
-The simplest way to compile this package is:
+   The simplest way to compile this package is:
 
   1. `cd' to the directory containing the package's source code and type
      `./configure' to configure the package for your system.
@@ -53,12 +59,22 @@ The simplest way to compile this package is:
   2. Type `make' to compile the package.
 
   3. Optionally, type `make check' to run any self-tests that come with
-     the package.
+     the package, generally using the just-built uninstalled binaries.
 
   4. Type `make install' to install the programs and any data files and
-     documentation.
-
-  5. You can remove the program binaries and object files from the
+     documentation.  When installing into a prefix owned by root, it is
+     recommended that the package be configured and built as a regular
+     user, and only the `make install' phase executed with root
+     privileges.
+
+  5. Optionally, type `make installcheck' to repeat any self-tests, but
+     this time using the binaries in their final installed location.
+     This target does not install anything.  Running this target as a
+     regular user, particularly if the prior `make install' required
+     root privileges, verifies that the installation completed
+     correctly.
+
+  6. You can remove the program binaries and object files from the
      source code directory by typing `make clean'.  To also remove the
      files that `configure' created (so you can compile the package for
      a different kind of computer), type `make distclean'.  There is
@@ -67,8 +83,15 @@ The simplest way to compile this package is:
      all sorts of other programs in order to regenerate files that came
      with the distribution.
 
-  6. Often, you can also type `make uninstall' to remove the installed
-     files again.
+  7. Often, you can also type `make uninstall' to remove the installed
+     files again.  In practice, not all packages have tested that
+     uninstallation works correctly, even though it is required by the
+     GNU Coding Standards.
+
+  8. Some packages, particularly those that use Automake, provide `make
+     distcheck', which can by used by developers to test that all other
+     targets like `make install' and `make uninstall' work correctly.
+     This target is generally not run by end users.
 
 Compilers and Options
 =====================
@@ -93,7 +116,8 @@ same time, by placing the object files for each architecture in their
 own directory.  To do this, you can use GNU `make'.  `cd' to the
 directory where you want the object files and executables to go and run
 the `configure' script.  `configure' automatically checks for the
-source code in the directory that `configure' is in and in `..'.
+source code in the directory that `configure' is in and in `..'.  This
+is known as a "VPATH" build.
 
    With a non-GNU `make', it is safer to compile the package for one
 architecture at a time in the source code directory.  After you have
@@ -120,7 +144,8 @@ Installation Names
    By default, `make install' installs the package's commands under
 `/usr/local/bin', include files under `/usr/local/include', etc.  You
 can specify an installation prefix other than `/usr/local' by giving
-`configure' the option `--prefix=PREFIX'.
+`configure' the option `--prefix=PREFIX', where PREFIX must be an
+absolute file name.
 
    You can specify separate installation prefixes for
 architecture-specific files and architecture-independent files.  If you
@@ -131,15 +156,46 @@ Documentation and other data files still use the regular prefix.
    In addition, if you use an unusual directory layout you can give
 options like `--bindir=DIR' to specify different values for particular
 kinds of files.  Run `configure --help' for a list of the directories
-you can set and what kinds of files go in them.
+you can set and what kinds of files go in them.  In general, the
+default for these options is expressed in terms of `${prefix}', so that
+specifying just `--prefix' will affect all of the other directory
+specifications that were not explicitly provided.
+
+   The most portable way to affect installation locations is to pass the
+correct locations to `configure'; however, many packages provide one or
+both of the following shortcuts of passing variable assignments to the
+`make install' command line to change installation locations without
+having to reconfigure or recompile.
+
+   The first method involves providing an override variable for each
+affected directory.  For example, `make install
+prefix=/alternate/directory' will choose an alternate location for all
+directory configuration variables that were expressed in terms of
+`${prefix}'.  Any directories that were specified during `configure',
+but not in terms of `${prefix}', must each be overridden at install
+time for the entire installation to be relocated.  The approach of
+makefile variable overrides for each directory variable is required by
+the GNU Coding Standards, and ideally causes no recompilation.
+However, some platforms have known limitations with the semantics of
+shared libraries that end up requiring recompilation when using this
+method, particularly noticeable in packages that use GNU Libtool.
+
+   The second method involves providing the `DESTDIR' variable.  For
+example, `make install DESTDIR=/alternate/directory' will prepend
+`/alternate/directory' before all installation names.  The approach of
+`DESTDIR' overrides is not required by the GNU Coding Standards, and
+does not work on platforms that have drive letters.  On the other hand,
+it does better at avoiding recompilation issues, and works well even
+when some directory options were not specified in terms of `${prefix}'
+at `configure' time.
+
+Optional Features
+=================
 
    If the package supports it, you can cause programs to be installed
 with an extra prefix or suffix on their names by giving `configure' the
 option `--program-prefix=PREFIX' or `--program-suffix=SUFFIX'.
 
-Optional Features
-=================
-
    Some packages pay attention to `--enable-FEATURE' options to
 `configure', where FEATURE indicates an optional part of the package.
 They may also pay attention to `--with-PACKAGE' options, where PACKAGE
@@ -152,6 +208,13 @@ find the X include and library files automatically, but if it doesn't,
 you can use the `configure' options `--x-includes=DIR' and
 `--x-libraries=DIR' to specify their locations.
 
+   Some packages offer the ability to configure how verbose the
+execution of `make' will be.  For these packages, running `./configure
+--enable-silent-rules' sets the default to minimal output, which can be
+overridden with `make V=1'; while running `./configure
+--disable-silent-rules' sets the default to verbose, which can be
+overridden with `make V=0'.
+
 Particular systems
 ==================
 
@@ -288,7 +351,7 @@ operates.
      `configure' can determine that directory automatically.
 
 `--prefix=DIR'
-     Use DIR as the installation prefix.  *Note Installation Names::
+     Use DIR as the installation prefix.  *note Installation Names::
      for more details, including other options available for fine-tuning
      the installation locations.
 
diff --git a/configure.in b/configure.in
index c694474..e6ad6bd 100644
--- a/configure.in
+++ b/configure.in
@@ -1,11 +1,8 @@
 dnl Process this file with autoconf to produce a configure script.
 
 dnl required versions of other tools.
-m4_define([req_ver_glib],	[1.3.11])
-m4_define([req_ver_gtk],	[2.14.0])
-m4_define([req_ver_libbonobo],	[1.107.0])
-m4_define([req_ver_libspi],	[0.12.1])
-m4_define([req_ver_orbit],	[2.3.100])
+m4_define([req_ver_glib],	[2.25.9])
+m4_define([req_ver_gtk],	[2.21.2])
 
 AC_INIT(magnifier/magnifier.c)
 AC_CONFIG_MACRO_DIR([m4])
@@ -236,42 +233,30 @@ AC_PATH_PROG(GCONFTOOL, gconftool-2)
 AM_GCONF_SOURCE_2
 
 PKG_CHECK_MODULES(LIBDEPS, [
-	ORBit-2.0		>= 2.3.100
-	glib-2.0		>= 2.11.1
-	gmodule-2.0		>= 1.3.11
-	gobject-2.0		>= 1.3.11
-	gthread-2.0		>= 1.3.11
+	glib-2.0		>= 2.25.9
+	gmodule-2.0		>= 2.25.9
+	gobject-2.0		>= 2.25.9
+	gthread-2.0		>= 2.25.9
 ])
 AC_SUBST(LIBDEPS_LIBS)
 AC_SUBST(LIBDEPS_CFLAGS)
 
 PKG_CHECK_MODULES(DEPS, [
-	libloginhelper-1.0	>= 1.5.2
-	libbonobo-2.0		>= 1.107.0
-	ORBit-2.0		>= 2.3.100
-	glib-2.0		>= 2.11.1
-	gtk+-2.0		>= 2.14.0
-	gdk-pixbuf-2.0		>= 2.1.0
-	dbus-glib-1
+	glib-2.0		>= 2.25.9
+	gtk+-2.0		>= 2.21.2
+	gdk-pixbuf-2.0		>= 2.21.2
 ])
 AC_SUBST(DEPS_LIBS)
 AC_SUBST(DEPS_CFLAGS)
 
 PKG_CHECK_MODULES(TEST, [
-	libspi-1.0		>= 1.5.0
-	libbonobo-2.0		>= 1.107.0
-	ORBit-2.0		>= 2.3.100
-	glib-2.0		>= 1.3.11
-	gtk+-2.0		>= 2.14.0
-	gdk-pixbuf-2.0		>= 2.1.0
+	glib-2.0		>= 2.25.9
+	gtk+-2.0		>= 2.21.2
+	gdk-pixbuf-2.0		>= 2.21.2
 ])
 AC_SUBST(TEST_LIBS)
 AC_SUBST(TEST_CFLAGS)
 
-PKG_CHECK_MODULES(ORBIT, ORBit-2.0 >= 2.3.100)
-AC_SUBST(ORBIT_CFLAGS)
-AC_SUBST(ORBIT_LIBS)
-
 old_LIBS="$LIBS"
 dnl Checks for inet libraries:
 AC_SEARCH_LIBS(gethostent, nsl)
@@ -284,16 +269,6 @@ AC_SUBST(INET_LIBS)
 LIBS="$old_LIBS"
 
 
-dnl orbit-idl.
-ORBIT_IDL="`$PKG_CONFIG --variable=orbit_idl ORBit-2.0`"
-AC_SUBST(ORBIT_IDL)
-
-dnl Bonobo and Bonobo-Activation idl files
-BONOBO_ACTIVATION_IDL_DIR="`$PKG_CONFIG --variable=idldir bonobo-activation-2.0`"
-LIBBONOBO_IDL_DIR="`$PKG_CONFIG --variable=idldir libbonobo-2.0`"
-AC_SUBST(BONOBO_ACTIVATION_IDL_DIR)
-AC_SUBST(LIBBONOBO_IDL_DIR)
-
 AC_ARG_VAR([DEFAULT_GMAG_INTROSPECTION_PATH],
            [Set the default path for the install of DBus introspection XML
             relative to the pkgdatadir.])
diff --git a/magnifier/GNOME_Magnifier.server.in.in b/magnifier/GNOME_Magnifier.server.in.in
deleted file mode 100644
index 577e153..0000000
--- a/magnifier/GNOME_Magnifier.server.in.in
+++ /dev/null
@@ -1,15 +0,0 @@
-<oaf_info>
-	<oaf_server iid="OAFIID:GNOME_Magnifier_Magnifier:0.9"
-        	    type="exe" location="@BINDIR@/magnifier">
-		<oaf_attribute name="repo_ids" type="stringv">
-			<item value="IDL:Bonobo/Unknown:1.0"/>
-			<item value="IDL:GNOME/Magnifier/Magnifier:0.9"/>
-			<item value="IDL:Accessibility/LoginHelper:1.0"/>
-		</oaf_attribute>
-		<oaf_attribute name="bonobo:environment" type="stringv">
-			<item value="DISPLAY"/>
-		</oaf_attribute>
-		<oaf_attribute name="name" type="string" _value="Magnifier"/>
-		<oaf_attribute name="description" type="string" _value="Simple Screen Magnification Service"/>
-	</oaf_server>
-</oaf_info>
diff --git a/magnifier/Makefile.am b/magnifier/Makefile.am
index 770ade2..4d75820 100644
--- a/magnifier/Makefile.am
+++ b/magnifier/Makefile.am
@@ -1,24 +1,7 @@
 Cursorsdir = $(datadir)/gnome-mag
 
-lib_LTLIBRARIES = libgnome-mag.la
-
 bin_PROGRAMS = magnifier
 
-libgnome_mag_la_SOURCES = \
-	GNOME_Magnifier-common.c \
-	GNOME_Magnifier-stubs.c 
-
-libgnome_mag_la_DEPENDENCIES = \
-	GNOME_Magnifier.h
-
-libgnome_mag_la_LDFLAGS = \
-	$(LT_VERSION_INFO) -no-undefined
-
-libgnome_mag_la_LIBADD = $(LIBDEPS_LIBS)
-
-libgnomemagincludedir=$(includedir)/gnome-mag-1.0/magnifier
-libgnomemaginclude_HEADERS=GNOME_Magnifier.h
-
 AM_CFLAGS = $(CFLAGS) $(DEPS_CFLAGS) $(X_FLAGS)
 
 magnifier_SOURCES = magnifier-main.c \
@@ -29,10 +12,6 @@ magnifier_SOURCES = magnifier-main.c \
 	zoom-region-private.h \
 	magnifier.h \
 	magnifier-private.h \
-	GNOME_Magnifier.h \
-	GNOME_Magnifier-skels.c \
-	GNOME_Magnifier-common.c \
-	magnifier-server.h \
 	$(targetdir)/gmag-graphical-server.c \
 	$(targetdir)/gmag-graphical-server.h \
 	$(targetdir)/gmag-compositor.c \
@@ -52,39 +31,8 @@ INCLUDES = \
 	$(GNOME_MAG_DEBUG_CFLAGS)	       \
 	-DCURSORSDIR=\""$(Cursorsdir)"\"
 
-IDL_OUT = GNOME_Magnifier.h GNOME_Magnifier-skels.c GNOME_Magnifier-stubs.c GNOME_Magnifier-common.c GNOME_Magnifier-imodule.c
-
-IDL = $(top_srcdir)/idl/GNOME_Magnifier.idl
-
-BUILT_SOURCES = $(IDL_OUT)
-CLEANFILES = $(IDL_OUT)
-DISTCLEANFILES = $(IDL_OUT)
-
-magnifier.h : GNOME_Magnifier.h
-
-IDLFLAGS = -I$(BONOBO_ACTIVATION_IDL_DIR) 	\
-	-I$(LIBBONOBO_IDL_DIR)			\
-	-I$(top_srcdir)/idl			\
-	--add-imodule
-
-orbittypelibdir = $(libdir)/orbit-2.0
-orbittypelib_LTLIBRARIES = GNOME_Magnifier_module.la
-GNOME_Magnifier_module_la_LDFLAGS = \
-	-export-dynamic -module -avoid-version -no-undefined
-
-GNOME_Magnifier_module_la_LIBADD = $(ORBIT_LIBS)
-
-GNOME_Magnifier_module_la_SOURCES = \
-	GNOME_Magnifier-imodule.c
-
 # The X_LIBS must NOT be searched first or it breaks the build
-LDADD = libgnome-mag.la $(DEPS_LIBS) $(X_LIBS) $(COLORBLIND_LIBS)
-
-serverinfodir= $(libdir)/bonobo/servers
-$(server_in_files): $(server_in_files).in
-	sed -e "s|\@BINDIR\@|$(bindir)|" $< > $@
-server_in_files = GNOME_Magnifier.server.in
-serverinfo_DATA = $(server_in_files:.server.in=.server)
+LDADD = $(DEPS_LIBS) $(X_LIBS) $(COLORBLIND_LIBS)
 
 servicedir	= $(datadir)/dbus-1/services
 service_in_files= org.freedesktop.gnome.Magnifier.service.in
@@ -92,37 +40,10 @@ service_DATA	= $(service_in_files:.service.in=.service)
 
 $(service_DATA): $(service_in_files) Makefile
 	@sed -e "s|\@BINDIR\@|$(bindir)|" $< > $@
-	
-DISTCLEANFILES += org.freedesktop.gnome.Magnifier.service
-
-@INTLTOOL_SERVER_RULE@
-
-EXTRA_DIST = $(server_in_files).in $(service_in_files)
-
-$(IDL_OUT) : $(IDL) $(ORBIT_IDL)
-	$(ORBIT_IDL) $(IDLFLAGS) $(IDL)
-
-DONT_DIST_SOURCE = $(IDL_OUT)
-
-CLEANFILES += $(server_in_files) $(serverinfo_DATA) $(service_DATA)
-
-BUILT_SOURCES += magnifier-server.h magnifier-client.h zoom-region-server.h zoom-region-client.h
-
-noinst_HEADERS = $(BUILT_SOURCES)
-
-magnifier-server.h: $(top_srcdir)/xml/org.freedesktop.gnome.Magnifier.xml
-	dbus-binding-tool --prefix=impl_dbus_magnifier --mode=glib-server $< > $@
 
-magnifier-client.h: $(top_srcdir)/xml/org.freedesktop.gnome.Magnifier.xml
-	dbus-binding-tool --prefix=impl_dbus_magnifier --mode=glib-client $< > $@
+DISTCLEANFILES = org.freedesktop.gnome.Magnifier.service
 
-zoom-region-server.h: $(top_srcdir)/xml/org.freedesktop.gnome.ZoomRegion.xml
-	dbus-binding-tool --prefix=impl_dbus_zoom_region --mode=glib-server $< > $@
+EXTRA_DIST = $(service_in_files)
 
-zoom-region-client.h: $(top_srcdir)/xml/org.freedesktop.gnome.ZoomRegion.xml
-	dbus-binding-tool --prefix=impl_dbus_zoom_region --mode=glib-client $< > $@
+CLEANFILES =  $(service_DATA)
 
-dist-hook:
-	for file in $(DONT_DIST_SOURCE) ; do \
-	    rm -f $(distdir)/$$file ; \
-	done
diff --git a/magnifier/magnifier-main.c b/magnifier/magnifier-main.c
index 5c41f6b..f09e3c7 100644
--- a/magnifier/magnifier-main.c
+++ b/magnifier/magnifier-main.c
@@ -25,7 +25,6 @@
 #include "magnifier-private.h"
 #include "zoom-region.h"
 #include "gmag-graphical-server.h"
-#include "GNOME_Magnifier.h"
 
 #include <unistd.h>
 
@@ -36,12 +35,11 @@
 #include <gdk/gdk.h>
 #include <gdk/gdkx.h>
 #include <gtk/gtk.h>
-
-#include <libbonobo.h>
+#include <glib/gi18n.h>
 
 #define ENV_STRING_MAX_SIZE 128
 
-GNOME_Magnifier_ZoomRegion zoom_region;
+ZoomRegion *zoom_region;
 
 typedef struct {
 	gchar    *target_display;
@@ -156,7 +154,7 @@ static GOptionEntry magnifier_options [] = {
 };
 
 static void
-init_rect_bounds (GNOME_Magnifier_RectBounds *bounds,
+init_rect_bounds (RectBounds *bounds,
 		  long x1, long y1, long x2, long y2)
 {
 	bounds->x1 = x1;
@@ -176,27 +174,17 @@ magnifier_main_test_image (gpointer data)
 	static int x_direction = 1;
 	static int y_direction = 1;
 	Magnifier *magnifier = (Magnifier *) data;
-	GNOME_Magnifier_ZoomRegionList *zoom_regions;
-	Bonobo_PropertyBag properties;
-	CORBA_Environment ev;
-	GNOME_Magnifier_RectBounds roi;
+	GList *zoom_regions;
+	RectBounds roi;
 	int x_roi, y_roi;
 	
 	/* Only iterate the number of times specified */
 	if (global_options.timing_iterations > 0) {
 		if (timing_counter > global_options.timing_iterations) {
-  			CORBA_exception_init (&ev);
-	  		properties = GNOME_Magnifier_ZoomRegion_getProperties (zoom_region, &ev);
-			if (BONOBO_EX (&ev))
-				fprintf (stderr, "EXCEPTION\n");
-
-	  		bonobo_pbclient_set_boolean (properties, "exit-magnifier",
-				       TRUE, &ev);
+			g_object_set (magnifier, "exit-magnifier", TRUE, NULL);
 		}
 	}
 
-	CORBA_exception_init (&ev);
-
 	x_roi  = global_options.timing_delta_x * timing_x_pos;
 	roi.x1 = x_roi;
 	roi.x2 = (target_width / global_options.zoom_factor) + roi.x1;
@@ -240,15 +228,9 @@ magnifier_main_test_image (gpointer data)
 	magnifier->priv->cursor_x = (roi.x2 + roi.x1) / 2;
 	magnifier->priv->cursor_y = (roi.y2 + roi.y1) / 2;
 
-	zoom_regions =
-		GNOME_Magnifier_Magnifier_getZoomRegions (
-			BONOBO_OBJREF (magnifier),
-			&ev);
-
-	if (zoom_regions && (zoom_regions->_length > 0)) {
-
-		GNOME_Magnifier_ZoomRegion_setROI (
-			zoom_regions->_buffer[0], &roi, &ev);
+	zoom_regions = magnifier->zoom_regions;
+	if (zoom_regions) {
+		zoom_region_set_roi (ZOOM_REGION (zoom_regions->data), &roi);
 	}
 
 	return TRUE;
@@ -260,15 +242,12 @@ static int
 magnifier_main_pan_image (gpointer data)
 {
   Magnifier *magnifier = (Magnifier *) data;
-  GNOME_Magnifier_ZoomRegionList *zoom_regions;
-  GNOME_Magnifier_ZoomRegion zoom_region;
-  CORBA_Environment ev;
-  GNOME_Magnifier_RectBounds roi;
+  GList *zoom_regions;
+  RectBounds roi;
   int mouse_x_return, mouse_y_return;
   int w, h;
   GdkModifierType mask_return;
-
-  CORBA_exception_init (&ev);
+  GList *l;
 
   if (global_options.mouse_follow && IS_MAGNIFIER (magnifier))
   {
@@ -289,26 +268,13 @@ magnifier_main_pan_image (gpointer data)
 		  roi.x2 = roi.x1 + 1;
 		  roi.y2 = roi.y1 + 1;
 		  
-		  zoom_regions =
-			  GNOME_Magnifier_Magnifier_getZoomRegions (
-				  BONOBO_OBJREF (magnifier),
-				  &ev);
-		  if (zoom_regions && (zoom_regions->_length > 0))
+		  zoom_regions = magnifier->zoom_regions;
+		  for (l = zoom_regions; l; l = g_list_next (l))
 		  {
-			  int i;
-			  for (i = 0; i < zoom_regions->_length; ++i)
-			  {
-				  /* fprintf (stderr, "panning region %d\n", i);*/
-				  zoom_region =
-					  CORBA_Object_duplicate (
-						  ( (CORBA_Object *)
-						    (zoom_regions->_buffer))[i], &ev);
-				  if (zoom_region != CORBA_OBJECT_NIL) {
-					  GNOME_Magnifier_ZoomRegion_setROI (zoom_region,
-									     &roi,
-									     &ev);
-				  } else fprintf (stderr, "nil region!\n");
-			  }
+			  zoom_region = (ZoomRegion *)l->data;
+			  if (zoom_region) {
+				  zoom_region_set_roi (zoom_region, &roi);
+			  } else fprintf (stderr, "nil region!\n");
 		  }
 	  }
 	  return TRUE;
@@ -320,46 +286,30 @@ magnifier_main_pan_image (gpointer data)
 static int
 magnifier_main_refresh_all (gpointer data)
 {
-	int i;
 	Magnifier *magnifier = data;
-	CORBA_any *dirty_bounds_any;
-	CORBA_Environment ev;
-	Bonobo_PropertyBag properties;
-	GNOME_Magnifier_RectBounds *dirty_bounds;
-	GNOME_Magnifier_ZoomRegionList *regions;
-	
-	CORBA_exception_init (&ev);
+	RectBounds *dirty_bounds;
+	GList *regions, *l;
 
 	if (!IS_MAGNIFIER (magnifier))
 		return FALSE;
 	
-	regions = GNOME_Magnifier_Magnifier_getZoomRegions (
-		BONOBO_OBJREF (magnifier),
-		&ev);
+	regions = magnifier->zoom_regions;
 
 #ifdef DEBUG_REFRESH
 	fprintf (stderr, "refreshing %d regions\n", regions->_length);
 #endif
 
-	properties = GNOME_Magnifier_Magnifier_getProperties (BONOBO_OBJREF (magnifier), &ev);
+	g_object_get (magnifier, "source-display-bounds", &dirty_bounds, NULL);
 
-	dirty_bounds_any = Bonobo_PropertyBag_getValue (properties, "source-display-bounds", &ev);
-	if (BONOBO_EX (&ev)) {
-		g_warning ("Error getting source-display-bounds");
-		bonobo_main_quit ();
-		return FALSE;
-	}
-
-	dirty_bounds = (GNOME_Magnifier_RectBounds *) dirty_bounds_any->_value;
-
-	  fprintf (stderr, "region to update: %d %d %d %d\n",
+	fprintf (stderr, "region to update: %d %d %d %d\n",
 		 dirty_bounds->x1, dirty_bounds->y1, dirty_bounds->x2, dirty_bounds->y2);
 
-	for (i = 0; i < regions->_length; ++i)
-		GNOME_Magnifier_ZoomRegion_markDirty (
-			regions->_buffer [i], dirty_bounds, &ev);
+	for (l = regions; l; l = g_list_next (l)) {
+		zoom_region = (ZoomRegion *)l->data;
+		zoom_region_mark_dirty (zoom_region, dirty_bounds);
+	}
 
-	bonobo_object_release_unref (properties, NULL);
+	g_free (dirty_bounds);
 
 	return TRUE;
 }
@@ -368,21 +318,12 @@ int
 main (int argc, char** argv)
 {
   GOptionContext *context;
-  GNOME_Magnifier_RectBounds *roi = GNOME_Magnifier_RectBounds__alloc();
-  GNOME_Magnifier_RectBounds *viewport = GNOME_Magnifier_RectBounds__alloc();
-  CORBA_any *viewport_any;
+  RectBounds roi;
+  RectBounds viewport;
   int x = 0, y = 0, src_width, src_height;
   guint pan_handle = 0, refresh_handle = 0;
-  CORBA_Environment ev;
-  Bonobo_PropertyBag properties;
-  
   Magnifier *magnifier;
   
-  if (!bonobo_init (&argc, argv)) {
-    g_error ("Could not initialize Bonobo");
-  }
-  CORBA_exception_init (&ev);
-  
   context = g_option_context_new ("- a screen magnifier for Gnome");
   g_option_context_set_description (context, "Report bugs to http://bugzilla.gnome.org\n");
   g_option_context_add_main_entries (context, magnifier_options, "main options");
@@ -433,42 +374,20 @@ main (int argc, char** argv)
 	  g_setenv ("MAGNIFIER_IGNORE_COMPOSITE", "1", TRUE);
 #endif /* HAVE_COMPOSITE */
 
-  magnifier = magnifier_new (global_options.is_override_redirect);
-  
-  properties = GNOME_Magnifier_Magnifier_getProperties (
-	  BONOBO_OBJREF (magnifier), &ev);
-  if (ev._major != CORBA_NO_EXCEPTION) fprintf (stderr, "EXCEPTION\n");
-  
-  if (global_options.target_display)
-	  bonobo_pbclient_set_string (properties, "target-display-screen",
-				      global_options.target_display, NULL);
-
-  if (global_options.source_display)
-	  bonobo_pbclient_set_string (properties, "source-display-screen",
-				      global_options.source_display, NULL);
-
-  if (global_options.cursor_set)
-	  bonobo_pbclient_set_string (properties, "cursor-set",
-				      global_options.cursor_set, NULL);
-
-  if (global_options.cursor_size)
-	  bonobo_pbclient_set_long (properties, "cursor-size",
-				    global_options.cursor_size, NULL);
-
-  else if (global_options.cursor_scale_factor != 0.0F)
-	  bonobo_pbclient_set_float (properties, "cursor-scale-factor",
-				     global_options.cursor_scale_factor, NULL);
-  else 
-	  bonobo_pbclient_set_float (properties, "cursor-scale-factor",
-				     global_options.zoom_factor, NULL);
-
-  if (global_options.cursor_color)
-	  bonobo_pbclient_set_ulong (properties, "cursor-color",
-				     global_options.cursor_color, 
-				     NULL);
+  magnifier = magnifier_new (global_options.is_override_redirect,
+			     global_options.source_display,
+			     global_options.target_display);
+
+  g_object_set (magnifier,
+		"cursor-set", global_options.cursor_set,
+		"cursor-size", global_options.cursor_size,
+		"cursor-scale-factor", global_options.cursor_scale_factor != 0.0F ?
+		global_options.cursor_scale_factor : global_options.zoom_factor,
+		"cursor-color", global_options.cursor_color,
+		NULL);
 
   if (!global_options.show_crosswires)
-	  bonobo_pbclient_set_long (properties, "crosswire-size", 0, NULL);
+	  g_object_set (magnifier, "crosswire-size", 0, NULL);
 
   src_width = gdk_screen_get_width (gdk_display_get_screen (
 					    magnifier->source_display,
@@ -499,123 +418,77 @@ main (int argc, char** argv)
   
   if (global_options.vertical_split || global_options.horizontal_split ||
       global_options.fullscreen) {
-	  init_rect_bounds (viewport, x, y, x + target_width,
+	  init_rect_bounds (&viewport, x, y, x + target_width,
 			    y + target_height);
-	  viewport_any = bonobo_arg_new_from (TC_GNOME_Magnifier_RectBounds,
-					      viewport);
-  
-	  bonobo_pbclient_set_value (properties, "target-display-bounds",
-				     viewport_any, &ev);
-	  bonobo_arg_release (viewport_any);
+	  g_object_set (magnifier, "source-display-bounds", &viewport, NULL);
   }
 
   if (global_options.vertical_split || global_options.horizontal_split) 
   {
 #ifdef HAVE_COMPOSITE
 	  if (!g_getenv ("MAGNIFIER_IGNORE_COMPOSITE"))
-		  init_rect_bounds (viewport, 0, 0,
+		  init_rect_bounds (&viewport, 0, 0,
 				    src_width, src_height);
 	  else
 #endif /* HAVE_COMPOSITE */
-		  init_rect_bounds (viewport, 0, 0,
+		  init_rect_bounds (&viewport, 0, 0,
 				    src_width-x, src_height-y);
-      viewport_any = bonobo_arg_new_from (TC_GNOME_Magnifier_RectBounds,
-					  viewport);
-      bonobo_pbclient_set_value (properties, "source-display-bounds",
-				 viewport_any,
-				 &ev);
-
-      bonobo_arg_release (viewport_any);
+	  g_object_set (magnifier, "source-display-bounds", &viewport, NULL);
   } else if (global_options.fullscreen) {
-	  init_rect_bounds (viewport, 0, 0, src_width, src_height);
-	  viewport_any = bonobo_arg_new_from (TC_GNOME_Magnifier_RectBounds,
-					      viewport);
-	  bonobo_pbclient_set_value (properties, "source-display-bounds",
-				     viewport_any,
-				     &ev);
-	  bonobo_arg_release (viewport_any);
+	  init_rect_bounds (&viewport, 0, 0, src_width, src_height);
+	  g_object_set (magnifier, "source-display-bounds", &viewport, NULL);
   }
 
-  bonobo_object_release_unref (properties, NULL);
-  properties = NULL;
-
   if (global_options.vertical_split ||
       global_options.horizontal_split ||
       global_options.fullscreen)
   {
 	  int scroll_policy;
 	  
-	  init_rect_bounds (roi, 0, 0,
+	  init_rect_bounds (&roi, 0, 0,
 			    target_width / global_options.zoom_factor,
 			    target_height / global_options.zoom_factor);
-	  init_rect_bounds (viewport, 0, 0, target_width, target_height);
-	  zoom_region =
-		  GNOME_Magnifier_Magnifier_createZoomRegion (
-			  BONOBO_OBJREF (magnifier),
-			  global_options.zoom_factor,
-			  global_options.zoom_factor,
-			  roi,
-			  viewport,
-			  &ev);
-	  
-	  properties = GNOME_Magnifier_ZoomRegion_getProperties (zoom_region, &ev);
-	  if (BONOBO_EX (&ev))
-		  fprintf (stderr, "EXCEPTION\n");
-
-	  scroll_policy = global_options.smooth_scroll ?
-		  GNOME_Magnifier_ZoomRegion_SCROLL_SMOOTHEST :
-		  GNOME_Magnifier_ZoomRegion_SCROLL_FASTEST;
-
-	  bonobo_pbclient_set_long (properties, "timing-iterations",
-				       global_options.timing_iterations, &ev);
-	  bonobo_pbclient_set_boolean (properties, "timing-output",
-				       global_options.timing_output, &ev);
-	  bonobo_pbclient_set_long (properties, "timing-pan-rate",
-				       global_options.timing_pan_rate, &ev);
-	  bonobo_pbclient_set_long    (properties, "border-size",
-				       global_options.border_width, &ev);
-	  bonobo_pbclient_set_long    (properties, "border-color",
-				       global_options.border_color, &ev);
-	  bonobo_pbclient_set_short   (properties, "smooth-scroll-policy",
-				       (short) scroll_policy, &ev);
-	  bonobo_pbclient_set_boolean (properties, "use-test-pattern",
-				       global_options.test_pattern, &ev);
-	  bonobo_pbclient_set_boolean (properties, "draw-cursor",
-				       !global_options.hide_pointer, &ev);
+	  init_rect_bounds (&viewport, 0, 0, target_width, target_height);
+	  zoom_region = magnifier_create_zoom_region (magnifier,
+						      global_options.zoom_factor,
+						      global_options.zoom_factor,
+						      &roi, &viewport);
+
+	  scroll_policy = global_options.smooth_scroll ? SCROLL_SMOOTHEST : SCROLL_FASTEST;
+
+	  g_object_set (zoom_region,
+			"timing-iterations", global_options.timing_iterations,
+			"timing-output", global_options.timing_output,
+			"timing-pan-rate", global_options.timing_pan_rate,
+			"border-size", global_options.border_width,
+			"border-color", global_options.border_color,
+			"smooth-scroll-policy", scroll_policy,
+			"use-test-pattern", global_options.test_pattern,
+			"draw-cursor", !global_options.hide_pointer,
+			"inverse-video", global_options.invert_image,
+			NULL);
 
 	  if (strcmp (global_options.smoothing_type, "none"))
-		  bonobo_pbclient_set_string (properties, "smoothing-type",
-					      global_options.smoothing_type, &ev);
+		  g_object_set (zoom_region,
+				"smoothing-type", global_options.smoothing_type,
+				NULL);
 
-	  if (global_options.invert_image)
-		  bonobo_pbclient_set_boolean (properties, "inverse-video",
-					       global_options.invert_image, NULL);
-
-	  GNOME_Magnifier_Magnifier_addZoomRegion (
-		  BONOBO_OBJREF (magnifier),
-		  zoom_region,
-		  &ev);
-
-	  bonobo_object_release_unref (properties, &ev);
-	  properties = NULL;
+	  magnifier_add_zoom_region (magnifier, zoom_region);
   }
 
   if (global_options.timing_pan_rate)
   {
-	  GNOME_Magnifier_ZoomRegionList *zoom_regions;
-	  GNOME_Magnifier_RectBounds roi;
+	  GList *zoom_regions;
+	  RectBounds roi;
 	  roi.x1 = 100;
 	  roi.x2 = 100 + (target_width / global_options.zoom_factor);
 	  roi.y1 = 0;
 	  roi.y2 = target_height / global_options.zoom_factor;
 	  
-	  zoom_regions = GNOME_Magnifier_Magnifier_getZoomRegions (
-		  BONOBO_OBJREF (magnifier), &ev);
-	  
-	  if (zoom_regions && (zoom_regions->_length > 0))
+	  zoom_regions = magnifier->zoom_regions;
+	  if (zoom_regions)
 	  {
-		  GNOME_Magnifier_ZoomRegion_setROI (
-			  zoom_regions->_buffer[0], &roi, &ev);
+		  zoom_region_set_roi (ZOOM_REGION (zoom_regions->data), &roi);
 	  }
   }
   else if (global_options.timing_iterations)
@@ -639,7 +512,7 @@ main (int argc, char** argv)
 		  magnifier_main_pan_image, magnifier);
   }
   
-  bonobo_main ();
+  gtk_main ();
   
   if (refresh_handle)
 	  g_source_remove (refresh_handle);
diff --git a/magnifier/magnifier-private.h b/magnifier/magnifier-private.h
index a518975..621beef 100644
--- a/magnifier/magnifier-private.h
+++ b/magnifier/magnifier-private.h
@@ -28,7 +28,6 @@ G_BEGIN_DECLS
 #include <gtk/gtk.h>
 
 struct _MagnifierPrivate {
-	GtkWidget   *w;
 	GtkWidget   *canvas;
 	GdkWindow   *root;
 	GdkWindow   *overlay;
@@ -44,6 +43,7 @@ struct _MagnifierPrivate {
 	int          cursor_hotspot_y;
         gboolean     use_source_cursor;
         GHashTable  *cursorlist;
+	guint        dbus_object_id;
 };
 
 G_END_DECLS
diff --git a/magnifier/magnifier.c b/magnifier/magnifier.c
index ff6faed..d5716cc 100644
--- a/magnifier/magnifier.c
+++ b/magnifier/magnifier.c
@@ -23,26 +23,16 @@
 #include "config.h"
 #include "magnifier.h"
 #include "magnifier-private.h"
-#include "zoom-region.h"
 #include "zoom-region-private.h"
 #include "gmag-cursor.h"
 #include "gmag-graphical-server.h"
-#include "GNOME_Magnifier.h"
-#include "magnifier-server.h"
 
 #include <stdlib.h>
 #include <string.h>
 #include <strings.h>
 
-#include <libbonobo.h>
-#include <login-helper/login-helper.h>
-
-#include <dbus/dbus-glib-bindings.h>
-
 #include <gdk-pixbuf/gdk-pixbuf.h>
 #include <gdk/gdkx.h>
-#include <gdk/gdk.h>
-#include <gtk/gtk.h>
 
 /* if you #define this, don't forget to set MAG_CLIENT_DEBUG env variable */
 #define DEBUG_CLIENT_CALLS
@@ -54,20 +44,8 @@ static gboolean client_debug = FALSE;
 #define DBG(a)
 #endif
 
-typedef struct
-{
-    LoginHelper parent;
-    Magnifier *mag;
-} MagLoginHelper;
-
-typedef struct 
-{
-    LoginHelperClass parent_class;
-} MagLoginHelperClass;
-
-static GObjectClass *parent_class = NULL;
-
 enum {
+	PORP_0,
 	MAGNIFIER_SOURCE_DISPLAY_PROP,
 	MAGNIFIER_TARGET_DISPLAY_PROP,
 	MAGNIFIER_SOURCE_SIZE_PROP,
@@ -82,14 +60,12 @@ enum {
 	MAGNIFIER_CROSSWIRE_LENGTH_PROP,
 	MAGNIFIER_CROSSWIRE_CLIP_PROP,
 	MAGNIFIER_CROSSWIRE_COLOR_PROP
-} PropIdx;
+};
 
 typedef struct
 {
-	GNOME_Magnifier_RectBounds rectbounds;
-	RectBounds dbus_rectbounds;
-	GNOME_Magnifier_RectBounds viewport;
-	RectBounds dbus_viewport;
+	RectBounds rectbounds;
+	RectBounds *viewport;
 	gboolean   is_managed;
 	gint       scroll_policy;
 	gfloat     contrast;
@@ -103,97 +79,25 @@ typedef struct
 	gboolean   inverse;
 } MagnifierZoomRegionSaveProps;
 
-#ifdef DEBUG_CLIENT_CALLS
-gchar* mag_prop_names[MAGNIFIER_CROSSWIRE_COLOR_PROP + 1] = {
-    "SOURCE_DISPLAY",
-    "TARGET_DISPLAY",
-    "SOURCE_SIZE",
-    "TARGET_SIZE",
-    "CURSOR_SET",
-    "CURSOR_SIZE",
-    "CURSOR_ZOOM",
-    "CURSOR_COLOR",
-    "CURSOR_HOTSPOT",
-    "CURSOR_DEFAULT_SIZE",
-    "CROSSWIRE_SIZE",
-    "CROSSWIRE_LENGTH",
-    "CROSSWIRE_CLIP",
-    "CROSSWIRE_COLOR"
-};
-#endif
-
-static Magnifier *_this_magnifier = NULL;
 extern gint       fixes_event_base;
 
 static void magnifier_init_cursor_set (Magnifier *magnifier, gchar *cursor_set);
-static void magnifier_init_window (Magnifier *magnifier, GdkScreen *screen);
 static gboolean magnifier_reset_struts_at_idle (gpointer data);
-static void magnifier_init_window (Magnifier *magnifier, GdkScreen *screen);
 static void magnifier_adjust_source_size (Magnifier *magnifier);
-static gboolean _is_override_redirect = FALSE;
+static void magnifier_init (Magnifier *magnifier);
+static void magnifier_class_init (MagnifierClass *klass);
+static void magnifier_do_dispose (Magnifier *magnifier);
 
+static GDBusConnection *dbus_connection = NULL;
 static GHashTable *zoom_hash = NULL;
 
-static Window*
-mag_login_helper_get_raise_windows (LoginHelper *helper)
-{
-    Window *mainwin = NULL;
-    MagLoginHelper *mag_helper = (MagLoginHelper *) helper;
-    Magnifier *magnifier = MAGNIFIER (mag_helper->mag);
-
-    if (magnifier && magnifier->priv && magnifier->priv->w)
-    {
-	mainwin = g_new0 (Window, 2);
-	mainwin[0] = GDK_WINDOW_XWINDOW (gtk_widget_get_window (magnifier->priv->w));
-	mainwin[1] = None;
-    }
-    return mainwin;
-}
-
-static LoginHelperDeviceReqFlags
-mag_login_helper_get_device_reqs (LoginHelper *helper)
-{
-    /* means "don't grab the xserver or core pointer", 
-       and "we need to raise windows" */
-    return LOGIN_HELPER_GUI_EVENTS | 
-	LOGIN_HELPER_POST_WINDOWS | 
-	LOGIN_HELPER_CORE_POINTER;
-}
-
-static gboolean
-mag_login_helper_set_safe (LoginHelper *helper, gboolean ignored)
-{
-    return TRUE;
-}
-
-static void
-mag_login_helper_class_init (MagLoginHelperClass *klass)
-{
-	LoginHelperClass *login_helper_class = LOGIN_HELPER_CLASS(klass);
-	login_helper_class->get_raise_windows = mag_login_helper_get_raise_windows;
-	login_helper_class->get_device_reqs = mag_login_helper_get_device_reqs;
-	login_helper_class->set_safe = mag_login_helper_set_safe;
-}
-
-static void
-mag_login_helper_init (MagLoginHelper *helper)
-{
-    helper->mag = NULL; /* we set this with mag_login_helper_set_magnifier */
-}
-
-static void
-mag_login_helper_set_magnifier (MagLoginHelper *helper, Magnifier *mag)
-{
-    if (helper) 
-	helper->mag = mag;
-}
+#define MAGNIFIER_GET_PRIVATE(object) \
+	(G_TYPE_INSTANCE_GET_PRIVATE ((object), MAGNIFIER_TYPE, MagnifierPrivate))
 
-BONOBO_TYPE_FUNC (MagLoginHelper, 
-		  LOGIN_HELPER_TYPE,
-		  mag_login_helper)
+G_DEFINE_TYPE (Magnifier, magnifier, GTK_TYPE_WINDOW)
 
 static gboolean
-can_open_display (gchar *display_name)
+can_open_display (const gchar *display_name)
 {
     Display *d;
     if ((d = XOpenDisplay (display_name)))
@@ -241,19 +145,16 @@ magnifier_zoom_regions_update_pointer (Magnifier *magnifier)
 	list = magnifier->zoom_regions;
 	while (list) {
 		/* propagate the expose events to the zoom regions */
-		GNOME_Magnifier_ZoomRegion zoom_region;
-		CORBA_Environment ev;
-		zoom_region = list->data;
-		CORBA_exception_init (&ev);
-		if (zoom_region)
-			GNOME_Magnifier_ZoomRegion_updatePointer (
-				CORBA_Object_duplicate (zoom_region, &ev), &ev);
+		ZoomRegion *zoom_region;
+
+		zoom_region = (ZoomRegion *)list->data;
+		zoom_region_update_cursor (zoom_region, 0, 0, NULL);
 		list = g_list_next (list);
 	}
 }
 
 static void
-magnifier_zoom_regions_mark_dirty (Magnifier *magnifier, GNOME_Magnifier_RectBounds rect_bounds)
+magnifier_zoom_regions_mark_dirty (Magnifier *magnifier, RectBounds rect_bounds)
 {
 	GList *list;
 
@@ -263,14 +164,10 @@ magnifier_zoom_regions_mark_dirty (Magnifier *magnifier, GNOME_Magnifier_RectBou
 	while (list) 
 	{
 		/* propagate the expose events to the zoom regions */
-		GNOME_Magnifier_ZoomRegion zoom_region;
-		CORBA_Environment ev;
-		zoom_region = list->data;
-		CORBA_exception_init (&ev);
-		if (zoom_region)
-			GNOME_Magnifier_ZoomRegion_markDirty (CORBA_Object_duplicate (zoom_region, &ev),
-							      &rect_bounds,
-							      &ev);
+		ZoomRegion *zoom_region;
+
+		zoom_region = (ZoomRegion *)list->data;
+		zoom_region_mark_dirty (zoom_region, &rect_bounds);
 		list = g_list_next (list);
 	}
 }
@@ -282,7 +179,7 @@ magnifier_set_cursor_from_pixbuf (Magnifier *magnifier,
 	GdkPixmap *pixmap, *mask;
 	gint width, height;
 	GdkGC *gc;
-	GdkDrawable *drawable = gtk_widget_get_window (magnifier->priv->w);
+	GdkDrawable *drawable = gtk_widget_get_window (GTK_WIDGET (magnifier));
 
 	if (magnifier->priv->cursor) {
 		g_object_unref (magnifier->priv->cursor);
@@ -365,7 +262,7 @@ magnifier_set_cursor_pixmap_by_name (Magnifier *magnifier,
 void
 magnifier_notify_damage (Magnifier *magnifier, GdkRectangle *rect)
 {
-	GNOME_Magnifier_RectBounds rect_bounds;
+	RectBounds rect_bounds;
 	rect_bounds.x1 = rect->x;
 	rect_bounds.y1 = rect->y;
 	rect_bounds.x2 = rect->x + rect->width;
@@ -386,18 +283,6 @@ magnifier_set_extension_listeners (Magnifier *magnifier, GdkWindow *root)
 	magnifier->source_initialized = TRUE;
 }
 
-static void
-magnifier_size_allocate (GtkWidget *widget)
-{
-	gmag_gs_check_set_struts (_this_magnifier);
-}
-
-static void
-magnifier_realize (GtkWidget *widget)
-{
-	gmag_gs_magnifier_realize (widget);
-}
-
 GdkWindow*
 magnifier_get_root (Magnifier *magnifier)
 {
@@ -410,7 +295,7 @@ magnifier_get_root (Magnifier *magnifier)
 }
 
 static gint
-magnifier_parse_display_name (Magnifier *magnifier, gchar *full_display_string,
+magnifier_parse_display_name (Magnifier *magnifier, const gchar *full_display_string,
 			      gchar **display_name)
 {
 	gchar *screen_ptr;
@@ -431,7 +316,7 @@ magnifier_parse_display_name (Magnifier *magnifier, gchar *full_display_string,
 }
 
 static void
-magnifier_get_display_rect_bounds (Magnifier *magnifier, GNOME_Magnifier_RectBounds *rect_bounds, gboolean is_target)
+magnifier_get_display_rect_bounds (Magnifier *magnifier, RectBounds *rect_bounds, gboolean is_target)
 {
     if (is_target)
     {
@@ -464,7 +349,7 @@ magnifier_full_screen_capable (Magnifier *magnifier)
 {
 	if ((strcmp (magnifier->source_display_name,
 		     magnifier->target_display_name) != 0) ||
-		gmag_gs_use_compositor (magnifier))
+	        gmag_gs_use_compositor (magnifier->source_display_name, magnifier->target_display_name))
 		return TRUE;
 
 	return FALSE;
@@ -473,7 +358,7 @@ magnifier_full_screen_capable (Magnifier *magnifier)
 static void
 magnifier_adjust_source_size (Magnifier *magnifier)
 {
-	GNOME_Magnifier_RectBounds rect_bounds;	
+	RectBounds rect_bounds;
 	gdouble vfract_top, vfract_bottom, hfract_left, hfract_right;
 
 	magnifier_get_display_rect_bounds (magnifier, &rect_bounds, FALSE);
@@ -524,30 +409,45 @@ magnifier_adjust_source_size (Magnifier *magnifier)
 		   magnifier->source_bounds.x2, magnifier->source_bounds.y2);
 }
 
-static void
-magnifier_unref_zoom_region (gpointer data, gpointer user_data)
+ZoomRegion *
+magnifier_create_zoom_region (Magnifier  *magnifier,
+			      gdouble     zx,
+			      gdouble     zy,
+			      RectBounds *roi,
+			      RectBounds *viewport)
 {
-/*	Magnifier *magnifier = user_data; NOT USED */
-	CORBA_Environment ev;
-	GNOME_Magnifier_ZoomRegion zoom_region = data;
-	CORBA_exception_init (&ev);
-	
-	DBG(g_message ("unreffing zoom region"));
+	ZoomRegion *zoom_region = zoom_region_new(dbus_connection, GTK_WIDGET (magnifier));
+
+	DBG (fprintf (stderr, "Create zoom region: \tzoom %f,%f, viewport %d,%d to %d,%d\n", (float) zx, (float) zy, viewport->x1, viewport->y1, viewport->x2, viewport->y2));
+
+	/* FIXME:
+	 * shouldn't do this here, since it causes the region to get
+	 * mapped onto the parent, if if it's not explicitly added!
+	 */
+	DBG(g_message ("creating zoom region with parent %p", magnifier));
+
+	zoom_region_set_mag_factor (zoom_region, zx, zy);
+	g_object_set (zoom_region, "viewport", viewport, NULL);
+	zoom_region_set_roi (zoom_region, roi);
+
+	gtk_widget_set_size_request (magnifier->priv->canvas,
+				     viewport->x2 - viewport->x1,
+				     viewport->y2 - viewport->y1);
+	gtk_widget_show (magnifier->priv->canvas);
+	gtk_widget_show (GTK_WIDGET (magnifier));
 
-	GNOME_Magnifier_ZoomRegion_dispose (zoom_region, &ev);
-	if (!BONOBO_EX (&ev))
-	    Bonobo_Unknown_unref (zoom_region, &ev);
+	g_hash_table_insert (zoom_hash, g_strdup (zoom_region->object_path), zoom_region);
+
+	return zoom_region;
 }
 
-static void
-magnifier_dbus_unref_zoom_region (gpointer data, gpointer user_data)
+void
+magnifier_add_zoom_region (Magnifier  *magnifier,
+			   ZoomRegion *zoom_region)
 {
-/*	Magnifier *magnifier = user_data; NOT USED */
-	ZoomRegion *zoom_region = data;
-	
-	DBG(g_message ("unreffing zoom region"));
-
-	impl_dbus_zoom_region_dispose (zoom_region);
+	magnifier->zoom_regions = g_list_append (magnifier->zoom_regions, g_object_ref (zoom_region));
+	g_hash_table_remove (zoom_hash, zoom_region->object_path);
+	gmag_gs_check_set_struts (magnifier);
 }
 
 static GSList*
@@ -555,6 +455,7 @@ magnifier_zoom_regions_save (Magnifier *magnifier)
 {
     GList *list;
     GSList *save_props = NULL;
+    ZoomRegion *zoom_region;
     
     g_assert (magnifier);
     list = magnifier->zoom_regions;
@@ -563,44 +464,36 @@ magnifier_zoom_regions_save (Magnifier *magnifier)
 
     while (list) 
     {
-	GNOME_Magnifier_ZoomRegion zoom_region;
-	CORBA_Environment ev;
 	zoom_region = list->data;
-	CORBA_exception_init (&ev);
 	if (zoom_region)
 	{
-	    Bonobo_PropertyBag properties;
-	    CORBA_any *value;
-	    MagnifierZoomRegionSaveProps *zoomer_props = g_new0 (MagnifierZoomRegionSaveProps, 1);
-
-	    zoomer_props->rectbounds = GNOME_Magnifier_ZoomRegion_getROI (zoom_region, &ev);
-	    properties = GNOME_Magnifier_ZoomRegion_getProperties (zoom_region, &ev);
-	    value = bonobo_pbclient_get_value (properties, "viewport", TC_GNOME_Magnifier_RectBounds, &ev);
-	    memcpy (&zoomer_props->viewport, value->_value, sizeof (GNOME_Magnifier_RectBounds));
-	    CORBA_free (value);
-	    zoomer_props->is_managed = bonobo_pbclient_get_boolean (properties, "is-managed", NULL);
-	    zoomer_props->scroll_policy = bonobo_pbclient_get_short (properties, "smooth-scroll-policy", NULL);
-	    zoomer_props->contrast = bonobo_pbclient_get_float (properties, "contrast", NULL);
-	    zoomer_props->zx = bonobo_pbclient_get_float (properties, "mag-factor-x", NULL);
-	    zoomer_props->zy = bonobo_pbclient_get_float (properties, "mag-factor-y", NULL);
-	    zoomer_props->xalign = bonobo_pbclient_get_long (properties, "x-alignment", NULL);
-	    zoomer_props->yalign = bonobo_pbclient_get_long (properties, "y-alignment", NULL);
-	    zoomer_props->border_color = bonobo_pbclient_get_long (properties, "border-color", NULL); 
-	    zoomer_props->border_size = bonobo_pbclient_get_long (properties, "border-size", NULL);
-	    zoomer_props->smoothing_type = bonobo_pbclient_get_string (properties, "smoothing-type", NULL); 
-	    zoomer_props->inverse = bonobo_pbclient_get_boolean (properties, "inverse-video", NULL); 
-
-	    bonobo_object_release_unref (properties, &ev);
-	    magnifier_unref_zoom_region ((gpointer) zoom_region, NULL);
-	    save_props = g_slist_append (save_props, zoomer_props);
+	    MagnifierZoomRegionSaveProps *zoomer_props = g_slice_new0 (MagnifierZoomRegionSaveProps);
+
+	    zoomer_props->rectbounds = zoom_region->roi;
+	    g_object_get (zoom_region,
+			  "viewport", &zoomer_props->viewport,
+			  "is-managed", &zoomer_props->is_managed,
+			  "smooth-scroll-policy", &zoomer_props->scroll_policy,
+			  "contrast", &zoomer_props->contrast,
+			  "mag-factor-x", &zoomer_props->zx,
+			  "mag-factor-y", &zoomer_props->zy,
+			  "x-alignment", &zoomer_props->xalign,
+			  "y-alignment", &zoomer_props->yalign,
+			  "border-color", &zoomer_props->border_color,
+			  "border-size", &zoomer_props->border_size,
+			  "smoothing-type", &zoomer_props->smoothing_type,
+			  "inverse-video", &zoomer_props->inverse,
+			  NULL);
+
+	    g_object_unref (zoom_region);
+	    save_props = g_slist_prepend (save_props, zoomer_props);
 	}
 	list = g_list_next (list);
     }   
 
     magnifier->zoom_regions = NULL;
-    magnifier->zoom_regions_dbus = NULL;
 
-    return save_props;
+    return g_slist_reverse (save_props);
 }
 
 static void
@@ -610,45 +503,39 @@ magnifier_zoom_regions_restore (Magnifier *magnifier, GSList *region_params)
 
 	while (list)
 	{
-		CORBA_Environment ev;
 		MagnifierZoomRegionSaveProps *zoomer_props = list->data;
-		GNOME_Magnifier_ZoomRegion new_region;
-		Bonobo_PropertyBag new_properties;
-
-		CORBA_exception_init (&ev);
-		new_region = GNOME_Magnifier_Magnifier_createZoomRegion (BONOBO_OBJREF (magnifier), zoomer_props->zx, zoomer_props->zy, &zoomer_props->rectbounds, &zoomer_props->viewport, &ev);
-		new_properties = GNOME_Magnifier_ZoomRegion_getProperties (new_region, &ev);
-		bonobo_pbclient_set_boolean (new_properties, "is-managed", 
-					     zoomer_props->is_managed, NULL);
-		bonobo_pbclient_set_short (new_properties, "smooth-scroll-policy", 
-					   zoomer_props->scroll_policy, NULL);
-		bonobo_pbclient_set_float (new_properties, "contrast", 
-					   zoomer_props->contrast, NULL);
+		ZoomRegion *new_region;
+
+		new_region = magnifier_create_zoom_region (magnifier,
+							   zoomer_props->zx,
+							   zoomer_props->zy,
+							   &zoomer_props->rectbounds,
+							   zoomer_props->viewport);
+		g_object_set (new_region,
+			      "is-managed", zoomer_props->is_managed,
+			      "smooth-scroll-policy", zoomer_props->scroll_policy,
+			      "contrast", zoomer_props->contrast,
 /* NOT YET USED
-		bonobo_pbclient_set_long (new_properties, "x-alignment", 
-					     zoomer_props->xalign, NULL);
-		bonobo_pbclient_set_long (new_properties, "y-alignment", 
-					     zoomer_props->yalign, NULL);
+			      "x-alignment", zoomer_props->xalign,
+			      "y-alignment", zoomer_props->yalign,
 */
-		bonobo_pbclient_set_long (new_properties, "border-color", 
-					     zoomer_props->border_color, NULL);
-		bonobo_pbclient_set_long (new_properties, "border-size", 
-					     zoomer_props->border_size, NULL);
-		bonobo_pbclient_set_string (new_properties, "smoothing-type", 
-					     zoomer_props->smoothing_type, NULL);
-		bonobo_pbclient_set_boolean (new_properties, "inverse-video", 
-					     zoomer_props->inverse, NULL);
-		GNOME_Magnifier_Magnifier_addZoomRegion (BONOBO_OBJREF (magnifier), new_region, &ev);
+			      "border-color", zoomer_props->border_color,
+			      "border-size", zoomer_props->border_size,
+			      "smoothing-type", zoomer_props->smoothing_type,
+			      "inverse-video", zoomer_props->inverse,
+			      NULL);
+		magnifier_add_zoom_region (magnifier, new_region);
+		g_object_unref (new_region);
+		g_free (zoomer_props->viewport);
 		g_free (zoomer_props->smoothing_type);
-		g_free (zoomer_props);
-		bonobo_object_release_unref (new_properties, &ev);
+		g_slice_free (MagnifierZoomRegionSaveProps, zoomer_props);
 		list = g_slist_next (list);
 	}
 	g_slist_free (region_params);
 }
 
 static void
-magnifier_init_display (Magnifier *magnifier, gchar *display_name, gboolean is_target)
+magnifier_init_display (Magnifier *magnifier, const gchar *display_name, gboolean is_target)
 {
     if (!can_open_display (display_name))
 	return;
@@ -790,7 +677,7 @@ magnifier_transform_cursor (Magnifier *magnifier)
 		g_object_unref (cursor_pixmap);
 		g_object_unref (mask_pixmap);
 		magnifier->priv->cursor = gdk_pixmap_new (
-			gtk_widget_get_window (magnifier->priv->w),
+			gtk_widget_get_window (GTK_WIDGET (magnifier)),
 			size_x, size_y,
 			-1);
 		if (!GDK_IS_DRAWABLE (magnifier->priv->cursor)) 
@@ -799,7 +686,7 @@ magnifier_transform_cursor (Magnifier *magnifier)
 		    return;
 		}
 		magnifier->priv->cursor_mask = gdk_pixmap_new (
-		        gtk_widget_get_window (magnifier->priv->w),
+		        gtk_widget_get_window (GTK_WIDGET (magnifier)),
 			size_x, size_y,
 			1);
 		if (GDK_IS_DRAWABLE (magnifier->priv->cursor)) {
@@ -895,13 +782,13 @@ magnifier_reset_struts_at_idle (gpointer data)
 		Magnifier *magnifier = MAGNIFIER (data);
 #if GTK_CHECK_VERSION (2,19,5)
 		if (magnifier->priv &&
-		    gtk_widget_get_realized (magnifier->priv->w) &&
+		    gtk_widget_get_realized (GTK_WIDGET (magnifier)) &&
 		    gmag_gs_check_set_struts (magnifier)) {
 			return FALSE;
 		}
 #else
 		if (magnifier->priv &&
-		    GTK_WIDGET_REALIZED (magnifier->priv->w) && 
+		    GTK_WIDGET_REALIZED (magnifier) &&
 		    gmag_gs_check_set_struts (magnifier)) {
 			return FALSE;
 		}
@@ -911,479 +798,470 @@ magnifier_reset_struts_at_idle (gpointer data)
 }
 
 static void
-magnifier_get_property (BonoboPropertyBag *bag,
-			BonoboArg *arg,
-			guint arg_id,
-			CORBA_Environment *ev,
-			gpointer user_data)
-{
-	Magnifier *magnifier = user_data;
-	int csize = 0;
-
-	DBG (fprintf (stderr, "Get property: \t%s\n", mag_prop_names[arg_id]));
-	
-	switch (arg_id) {
-	case MAGNIFIER_SOURCE_SIZE_PROP:
-		BONOBO_ARG_SET_GENERAL (arg, magnifier->source_bounds,
-					TC_GNOME_Magnifier_RectBounds,
-					GNOME_Magnifier_RectBounds, NULL);
-		break;
-	case MAGNIFIER_TARGET_SIZE_PROP:
-	    	BONOBO_ARG_SET_GENERAL (arg, magnifier->target_bounds,
-					TC_GNOME_Magnifier_RectBounds,
-					GNOME_Magnifier_RectBounds, NULL);
+method_call_cb (GDBusConnection       *connection,
+		const gchar           *sender,
+		const gchar           *object_path,
+		const gchar           *interface_name,
+		const gchar           *method_name,
+		GVariant              *parameters,
+		GDBusMethodInvocation *invocation,
+		gpointer               user_data)
+{
+	Magnifier *magnifier = MAGNIFIER (user_data);
+
+	if (g_strcmp0 (method_name, "fullScreenCapable") == 0) {
+		gboolean retval = FALSE;
+
+		if ((strcmp (magnifier->source_display_name,
+			     magnifier->target_display_name) != 0) ||
+		    gmag_gs_use_compositor (magnifier->source_display_name, magnifier->target_display_name)) {
+		    retval = TRUE;
+		}
 
-		break;
-	case MAGNIFIER_CURSOR_SET_PROP:
-		BONOBO_ARG_SET_STRING (arg, magnifier->cursor_set);
-		break;
-	case MAGNIFIER_CURSOR_SIZE_PROP:
-		BONOBO_ARG_SET_INT (arg, magnifier->cursor_size_x);
-		BONOBO_ARG_SET_INT (arg, magnifier->cursor_size_y);
-		break;
-	case MAGNIFIER_CURSOR_ZOOM_PROP:
-		BONOBO_ARG_SET_FLOAT (arg, magnifier->cursor_scale_factor);
-		break;
-	case MAGNIFIER_CURSOR_COLOR_PROP:
-		BONOBO_ARG_SET_GENERAL (arg, magnifier->cursor_color,
-					TC_CORBA_unsigned_long,
-					CORBA_unsigned_long, NULL);
-		break;
-	case MAGNIFIER_CURSOR_HOTSPOT_PROP:
-		BONOBO_ARG_SET_GENERAL (arg, magnifier->cursor_hotspot,
-					TC_GNOME_Magnifier_Point,
-					GNOME_Magnifier_Point, NULL);
+		g_dbus_method_invocation_return_value (invocation,
+						       g_variant_new ("(b)", retval));
+	} else if (g_strcmp0 (method_name, "hideCursor") == 0) {
+		gmag_gs_hide_cursor (magnifier);
 
-		break;
-	case MAGNIFIER_CURSOR_DEFAULT_SIZE_PROP:
-		if (magnifier->priv->cursor)
-			gdk_drawable_get_size (magnifier->priv->cursor,
-					       &csize, &csize);
-		BONOBO_ARG_SET_INT (arg, csize);
-		break;
-	case MAGNIFIER_CROSSWIRE_SIZE_PROP:
-		BONOBO_ARG_SET_INT (arg, magnifier->crosswire_size);
-		break;
-	case MAGNIFIER_CROSSWIRE_LENGTH_PROP:
-		BONOBO_ARG_SET_INT (arg, magnifier->crosswire_length);
-		break;
-	case MAGNIFIER_CROSSWIRE_CLIP_PROP:
-		BONOBO_ARG_SET_BOOLEAN (arg, magnifier->crosswire_clip);
-		break;
-	case MAGNIFIER_CROSSWIRE_COLOR_PROP:
-		BONOBO_ARG_SET_LONG (arg, magnifier->crosswire_color);
-		break;
-        case MAGNIFIER_SOURCE_DISPLAY_PROP:
-		BONOBO_ARG_SET_STRING (arg, magnifier->source_display_name);
-	        break;
-	case MAGNIFIER_TARGET_DISPLAY_PROP:
-		BONOBO_ARG_SET_STRING (arg, magnifier->target_display_name);
-	        break;
-	default:
-		bonobo_exception_set (ev, ex_Bonobo_PropertyBag_NotFound);
-	};
-}
+		g_dbus_method_invocation_return_value (invocation, NULL);
+	} else if (g_strcmp0 (method_name, "showCursor") == 0) {
+		gmag_gs_show_cursor (magnifier);
 
-gboolean
-impl_dbus_magnifier_set_source_display (Magnifier *magnifier, gchar *source_display)
-{
-	gchar *full_display_string = source_display;
-	if (can_open_display (full_display_string))
-	{
-	    GSList *zoom_region_params = NULL;
-	    magnifier->source_screen_num =
-		magnifier_parse_display_name (magnifier,
-					      full_display_string,
-					      NULL);
-	    magnifier->source_display =
-		gdk_display_open (full_display_string);
-	    magnifier->source_display_name = g_strdup (full_display_string);
-	    zoom_region_params = magnifier_zoom_regions_save (magnifier);
-	    magnifier->priv->root =
-		gdk_screen_get_root_window (
-		    gdk_display_get_screen (
-			magnifier->source_display,
-			magnifier->source_screen_num));
+		g_dbus_method_invocation_return_value (invocation, NULL);
+	} else if (g_strcmp0 (method_name, "supportColorblindFilters") == 0) {
+#ifdef HAVE_COLORBLIND
+		gboolean retval = TRUE;
+#else
+		gboolean retval = FALSE;
+#endif
+		g_dbus_method_invocation_return_value (invocation,
+						       g_variant_new ("(b)", retval));
+	} else if (g_strcmp0 (method_name, "createZoomRegion") == 0) {
+		ZoomRegion *zoom_region;
+		double      zx, zy;
+		GVariant   *roi_v, *viewport_v;
+		const int  *items;
+		gsize       n_items;
+		RectBounds  roi;
+		RectBounds  viewport;
+
+		g_variant_get (parameters, "(dd@ai@ai)", &zx, &zy, &roi_v, &viewport_v);
+		items = g_variant_get_fixed_array (roi_v, &n_items, sizeof (gint32));
+		if (n_items == 4) {
+			roi.x1 = items[0];
+			roi.y1 = items[1];
+			roi.x2 = items[2];
+			roi.y2 = items[3];
+		}
+		g_variant_unref (roi_v);
+
+		items = g_variant_get_fixed_array (viewport_v, &n_items, sizeof (gint32));
+		if (n_items == 4) {
+			viewport.x1 = items[0];
+			viewport.y1 = items[1];
+			viewport.x2 = items[2];
+			viewport.y2 = items[3];
+		}
+		g_variant_unref (viewport_v);
+
+		zoom_region = magnifier_create_zoom_region (magnifier, zx, zy, &roi, &viewport);
+		g_dbus_method_invocation_return_value (invocation,
+						       g_variant_new ("(o)", zoom_region->object_path));
+	} else if (g_strcmp0 (method_name, "getZoomRegions") == 0) {
+		ZoomRegion *zoom_region;
+		gchar **list;
+		int i, len;
+
+		len = g_list_length (magnifier->zoom_regions);
+		list = g_malloc0 (sizeof (gchar *) * len);
+		for (i = 0; i < len; ++i) {
+			zoom_region = g_list_nth_data (magnifier->zoom_regions, i);
+			list[i] = zoom_region->object_path;
+		}
 
-	    /* remove the source_drawable, since in the new display the
-	     * composite can be unavailable and the source_drawable is
-	     * where the desktop screen is composed. If this is not
-	     * freed it will be used even if the display doesn't use
-	     * composite what will lead to wrong behavior and crashes.
-	     * If composite is used in the new display this variable is
-	     * re-created */
-	    if (magnifier->priv->source_drawable) {
-		    g_object_unref (magnifier->priv->source_drawable);
-		    magnifier->priv->source_drawable = NULL;
-	    }
+		DBG (fprintf (stderr, "Get zoom regions: \t%d\n", len));
 
-	    /* attach listeners for DAMAGE, "dirty region", XFIXES
-	     * cursor changes */
-            magnifier_set_extension_listeners (magnifier, magnifier_get_root (magnifier));
-	    magnifier_get_display_rect_bounds (magnifier, &magnifier->source_bounds, FALSE);
-	    magnifier_adjust_source_size (magnifier);
-	    magnifier_zoom_regions_restore (magnifier, zoom_region_params);
-	    magnifier_warp_cursor_to_screen (magnifier);
-	    gmag_gs_check_set_struts (magnifier);
-	    gmag_gs_reset_overlay_at_idle (magnifier);
-	}
-	DBG(fprintf (stderr, "Set source display: \t%s\n", full_display_string));
-	
-	return TRUE;
-}
+		g_dbus_method_invocation_return_value (invocation,
+						       g_variant_new_strv ((const gchar * const*)list, len));
+		g_free (list);
+	} else if (g_strcmp0 (method_name, "addZoomRegion") == 0) {
+		ZoomRegion *zoom_region;
+		const gchar *zoom_region_path;
 
-gchar*
-impl_dbus_magnifier_get_source_display (Magnifier *magnifier)
-{
-	return g_strdup (magnifier->source_display_name);
-}
+		g_variant_get (parameters, "(&o)", &zoom_region_path);
 
-gboolean
-impl_dbus_magnifier_set_target_display (Magnifier *magnifier, gchar *target_display)
-{
-	gchar *full_display_string = target_display;
-	if (can_open_display (full_display_string))
-	{
-	    magnifier->target_screen_num =
-		magnifier_parse_display_name (magnifier,
-					      full_display_string,
-					      NULL);
-	    magnifier->target_display =
-		gdk_display_open (full_display_string);
-	    magnifier->target_display_name = g_strdup (full_display_string);
-	    if (GTK_IS_WINDOW (magnifier->priv->w)) 
-	    {
-#ifdef REPARENT_GTK_WINDOW_WORKS
-		gtk_window_set_screen (GTK_WINDOW (magnifier->priv->w), 
-				       gdk_display_get_screen (
-					   magnifier->target_display,
-					   magnifier->target_screen_num));
-#else
-		GSList *zoom_region_params = NULL;
-		/* disconnect from the old window's destroy signal */
-		g_object_disconnect (magnifier->priv->w,
-			  "any_signal::realize", magnifier_realize, NULL,
-			  "any_signal::size_allocate", magnifier_size_allocate, NULL,
-			  "any_signal::destroy", magnifier_exit, NULL,
-		          NULL);
-		/* save the old zoom region state */
-	        zoom_region_params = magnifier_zoom_regions_save (magnifier);
-		/* destroy the old window */
-		gtk_widget_destroy (magnifier->priv->w);
-		/* and re-initialize... */
-		magnifier_init_window (magnifier, gdk_display_get_screen (
-					   magnifier->target_display,
-					   magnifier->target_screen_num));
-		/* restore the zoom regions in their new host magnifier window */
-		magnifier_zoom_regions_restore (magnifier, zoom_region_params);
-#endif
-	    }
-	    magnifier_get_display_rect_bounds (magnifier, &magnifier->source_bounds, FALSE);
-	    magnifier_init_cursor_set (magnifier, magnifier->cursor_set); /* needed to reset pixmaps */
-	    if (magnifier->priv->overlay)
-		    gdk_window_move (magnifier->priv->overlay,
-				     magnifier->target_bounds.x1,
-				     magnifier->target_bounds.y1);
-	    else
-		    gtk_window_move (GTK_WINDOW (magnifier->priv->w),
-				     magnifier->target_bounds.x1,
-				     magnifier->target_bounds.y1);
-	    
-	    if ((magnifier->target_bounds.x2 - magnifier->target_bounds.x1 > 0) &&
-		(magnifier->target_bounds.y2 - magnifier->target_bounds.y1) > 0)
-	    {
-		    if (magnifier->priv->overlay)
-			    gdk_window_resize (
-				    magnifier->priv->overlay,
-				    magnifier->target_bounds.x2 -
-				    magnifier->target_bounds.x1,
-				    magnifier->target_bounds.y2 -
-				    magnifier->target_bounds.y1);
-		gtk_window_resize (GTK_WINDOW (magnifier->priv->w),
-			       magnifier->target_bounds.x2 - magnifier->target_bounds.x1,
-			       magnifier->target_bounds.y2 - magnifier->target_bounds.y1);
-	    DBG(fprintf (stderr, "Set target size: \t%d,%d to %d,%d\n", 
-		     magnifier->target_bounds.x1, magnifier->target_bounds.y1, magnifier->target_bounds.x2, magnifier->target_bounds.y2));
-	    }
-	    /* N. B. we don't reset the target bounds to the limits of the new display, because */
-	    /* doing so would override the client-specified magnifier size */
-	    /* magnifier_get_display_rect_bounds (magnifier, &magnifier->target_bounds, TRUE); */
-	    gmag_gs_check_set_struts (magnifier);
-	}
-	DBG(fprintf (stderr, "Set target display: \t%s (screen %d)\n", 
-		      full_display_string, magnifier->target_screen_num));
-		      
-	return TRUE;
-}
+		if (!magnifier->source_initialized)
+		{
+			magnifier_set_extension_listeners (magnifier, magnifier_get_root (magnifier));
+		}
 
-gchar*
-impl_dbus_magnifier_get_target_display (Magnifier *magnifier)
-{
-	return g_strdup (magnifier->target_display_name);
-}
+		/* FIXME: this needs proper lifecycle management */
+		zoom_region = g_hash_table_lookup (zoom_hash, zoom_region_path);
+		magnifier_add_zoom_region (magnifier, zoom_region);
 
-gboolean
-impl_dbus_magnifier_set_source_size (Magnifier *magnifier, gint32 **bounds)
-{
-	magnifier->source_bounds.x1 = (*bounds)[0];
-	magnifier->source_bounds.y1 = (*bounds)[1];
-	magnifier->source_bounds.x2 = (*bounds)[2];
-	magnifier->source_bounds.y2 = (*bounds)[3];
-	DBG (fprintf (stderr, "Set source size: \t%d,%d to %d,%d\n", 
-		      magnifier->source_bounds.x1, magnifier->source_bounds.y1, magnifier->source_bounds.x2, magnifier->source_bounds.y2));
-		      
-	return TRUE;
-}
+		g_dbus_method_invocation_return_value (invocation,
+						       g_variant_new ("(b)", TRUE));
+	} else if (g_strcmp0 (method_name, "clearAllZoomRegions") == 0) {
+		g_list_foreach (magnifier->zoom_regions,
+				(GFunc)g_object_unref,
+				NULL);
+		g_list_free (magnifier->zoom_regions);
+		magnifier->zoom_regions = NULL;
 
-GArray*
-impl_dbus_magnifier_get_source_size (Magnifier *magnifier)
-{
-	GArray *ret = g_array_new (FALSE, FALSE, sizeof (gint32));
-	
-	g_array_append_val (ret, magnifier->source_bounds.x1);
-	g_array_append_val (ret, magnifier->source_bounds.y1);
-	g_array_append_val (ret, magnifier->source_bounds.x2);
-	g_array_append_val (ret, magnifier->source_bounds.y2);
-	
-	return ret;
-}
+		g_dbus_method_invocation_return_value (invocation, NULL);
+	} else if (g_strcmp0 (method_name, "dispose") == 0) {
+		magnifier_do_dispose (magnifier);
 
-gboolean
-impl_dbus_magnifier_set_target_size (Magnifier *magnifier, gint32 **bounds)
-{
-	magnifier->target_bounds.x1 = (*bounds)[0];
-	magnifier->target_bounds.y1 = (*bounds)[1];
-	magnifier->target_bounds.x2 = (*bounds)[2];
-	magnifier->target_bounds.y2 = (*bounds)[3];
-
-	if (magnifier->priv->overlay)
-		gdk_window_move_resize (magnifier->priv->overlay,
-					magnifier->target_bounds.x1,
-					magnifier->target_bounds.y1,
-					magnifier->target_bounds.x2 -
-					magnifier->target_bounds.x1,
-					magnifier->target_bounds.y2 -
-					magnifier->target_bounds.y1);
-	else
-		gtk_window_move (GTK_WINDOW (magnifier->priv->w),
-				 magnifier->target_bounds.x1,
-				 magnifier->target_bounds.y1);
-	
-	gtk_window_resize (GTK_WINDOW (magnifier->priv->w),
-			   magnifier->target_bounds.x2 - magnifier->target_bounds.x1,
-			   magnifier->target_bounds.y2 - magnifier->target_bounds.y1);
-	gmag_gs_check_set_struts (magnifier);
-	DBG(fprintf (stderr, "Set target size: \t%d,%d to %d,%d\n", 
-		      magnifier->target_bounds.x1, magnifier->target_bounds.y1, magnifier->target_bounds.x2, magnifier->target_bounds.y2));
-	if (!strcmp (magnifier->target_display_name, magnifier->source_display_name) && 
-	    (magnifier->target_screen_num == magnifier->source_screen_num)) 
-	    magnifier_adjust_source_size (magnifier);
-	    
-	return TRUE;
-}
+		g_dbus_method_invocation_return_value (invocation, NULL);
+	} else if (g_strcmp0 (method_name, "setSourceDisplay") == 0) {
+		const gchar *display_string;
 
-GArray*
-impl_dbus_magnifier_get_target_size (Magnifier *magnifier)
-{
-	GArray *ret = g_array_new (FALSE, FALSE, sizeof (gint32));
-	
-	g_array_append_val (ret, magnifier->target_bounds.x1);
-	g_array_append_val (ret, magnifier->target_bounds.y1);
-	g_array_append_val (ret, magnifier->target_bounds.x2);
-	g_array_append_val (ret, magnifier->target_bounds.y2);
-	
-	return ret;
-}
+		g_variant_get (parameters, "(&s)", &display_string);
+		g_object_set (magnifier, "source-display-screen", display_string, NULL);
 
-gboolean
-impl_dbus_magnifier_set_cursor_set (Magnifier *magnifier, gchar *cursor_set)
-{
-	magnifier_init_cursor_set (magnifier, g_strdup (cursor_set));
-	DBG (fprintf (stderr, "Setting cursor set: \t%s\n", cursor_set));
-	
-	return TRUE;
-}
+		g_dbus_method_invocation_return_value (invocation, NULL);
+	} else if (g_strcmp0 (method_name, "getSourceDisplay") == 0) {
+		g_dbus_method_invocation_return_value (invocation,
+						       g_variant_new ("(s)", magnifier->source_display_name));
+	} else if (g_strcmp0 (method_name, "setTargetDisplay") == 0) {
+		const gchar *display_string;
 
-gchar*
-impl_dbus_magnifier_get_cursor_set (Magnifier *magnifier)
-{
-	return g_strdup (magnifier->cursor_set);
-}
+		g_variant_get (parameters, "(&s)", &display_string);
+		g_object_set (magnifier, "target-display-screen", display_string, NULL);
 
-gboolean
-impl_dbus_magnifier_set_cursor_size (Magnifier *magnifier, gint x, gint y)
-{
-	magnifier->cursor_size_x = x;
-	magnifier->cursor_size_y = y;
-	magnifier_transform_cursor (magnifier);
-	DBG (fprintf (stderr, "Setting cursor size: \t%d\n", magnifier->cursor_size_x));
-	
-	return TRUE;
+		g_dbus_method_invocation_return_value (invocation, NULL);
+	} else if (g_strcmp0 (method_name, "getTargetDisplay") == 0) {
+		g_dbus_method_invocation_return_value (invocation,
+						       g_variant_new ("(s)", magnifier->target_display_name));
+	}
 }
 
-GArray*
-impl_dbus_magnifier_get_cursor_size (Magnifier *magnifier)
-{
-	GArray *ret = g_array_new (FALSE, FALSE, sizeof (gint));
-	
-	g_array_append_val (ret, magnifier->cursor_size_x);
-	g_array_append_val (ret, magnifier->cursor_size_y);
-	
-	return ret;
-}
+static GVariant *
+get_property_cb (GDBusConnection *connection,
+		 const gchar     *sender,
+		 const gchar     *object_path,
+		 const gchar     *interface_name,
+		 const gchar     *property_name,
+		 GError         **error,
+		 gpointer         user_data)
+{
+	Magnifier *magnifier = MAGNIFIER (user_data);
+	GVariant  *retval = NULL;
+
+	if (g_strcmp0 (property_name, "SourceSize") == 0) {
+		GVariant *children[4];
+
+		children[0] = g_variant_new_int32 (magnifier->source_bounds.x1);
+		children[1] = g_variant_new_int32 (magnifier->source_bounds.y1);
+		children[2] = g_variant_new_int32 (magnifier->source_bounds.x2);
+		children[3] = g_variant_new_int32 (magnifier->source_bounds.y2);
+		retval = g_variant_new_array (G_VARIANT_TYPE_INT32, children, 4);
+	} else if (g_strcmp0 (property_name, "TargetSize") == 0) {
+		GVariant *children[4];
+
+		children[0] = g_variant_new_int32 (magnifier->target_bounds.x1);
+		children[1] = g_variant_new_int32 (magnifier->target_bounds.y1);
+		children[2] = g_variant_new_int32 (magnifier->target_bounds.x2);
+		children[3] = g_variant_new_int32 (magnifier->target_bounds.y2);
+		retval = g_variant_new_array (G_VARIANT_TYPE_INT32, children, 4);
+	} else if (g_strcmp0 (property_name, "CursorSet") == 0) {
+		retval = g_variant_new_string (magnifier->cursor_set ? magnifier->cursor_set : "");
+	} else if (g_strcmp0 (property_name, "CursorSize") == 0) {
+		GVariant *children[2];
+
+		children[0] = g_variant_new_int32 (magnifier->cursor_size_x);
+		children[1] = g_variant_new_int32 (magnifier->cursor_size_y);
+		retval = g_variant_new_array (G_VARIANT_TYPE_INT32, children, 2);
+	} else if (g_strcmp0 (property_name, "CursorZoom") == 0) {
+		retval = g_variant_new_double (magnifier->cursor_scale_factor);
+	} else if (g_strcmp0 (property_name, "CursorColor") == 0) {
+		retval = g_variant_new_uint32 (magnifier->cursor_color);
+	} else if (g_strcmp0 (property_name, "CursorHotspot") == 0) {
+		GVariant *children[2];
+
+		children[0] = g_variant_new_int32 (magnifier->cursor_hotspot.x);
+		children[1] = g_variant_new_int32 (magnifier->cursor_hotspot.y);
+		retval = g_variant_new_array (G_VARIANT_TYPE_INT32, children, 2);
+	} else if (g_strcmp0 (property_name, "CursorDefaultSize") == 0) {
+		gint32 csize = 0;
+
+		if (magnifier->priv->cursor) {
+			gdk_drawable_get_size (magnifier->priv->cursor, &csize, &csize);
+		}
+		retval = g_variant_new_int32 (csize);
+	} else if (g_strcmp0 (property_name, "CrosswireSize") == 0) {
+		retval = g_variant_new_int32 (magnifier->crosswire_size);
+	} else if (g_strcmp0 (property_name, "CrosswireLength") == 0) {
+		retval = g_variant_new_int32 (magnifier->crosswire_length);
+	} else if (g_strcmp0 (property_name, "CrosswireClip") == 0) {
+		retval = g_variant_new_boolean (magnifier->crosswire_clip);
+	} else if (g_strcmp0 (property_name, "CrosswireColor") == 0) {
+		retval = g_variant_new_uint32 (magnifier->crosswire_color);
+	}
 
-gboolean
-impl_dbus_magnifier_set_cursor_zoom (Magnifier *magnifier, double factor)
-{
-	magnifier->cursor_scale_factor = factor;
-	DBG (fprintf (stderr, "Setting cursor scale factor: \t%f\n", magnifier->cursor_scale_factor));
-	magnifier_transform_cursor (magnifier);
-	
-	return TRUE;
+	return retval;
 }
 
-double
-impl_dbus_magnifier_get_cursor_zoom (Magnifier *magnifier)
-{
-	return magnifier->cursor_scale_factor;
-}
+static gboolean
+set_property_cb (GDBusConnection *connection,
+		 const gchar     *sender,
+		 const gchar     *object_path,
+		 const gchar     *interface_name,
+		 const gchar     *property_name,
+		 GVariant        *value,
+		 GError         **error,
+		 gpointer         user_data)
+{
+	Magnifier *magnifier = MAGNIFIER (user_data);
+
+	if (g_strcmp0 (property_name, "SourceSize") == 0) {
+		const int *items;
+		gsize      n_items;
+		RectBounds rect;
+
+		items = g_variant_get_fixed_array (value, &n_items, sizeof (gint32));
+		if (n_items == 4) {
+			rect.x1 = items[0];
+			rect.y1 = items[1];
+			rect.x2 = items[2];
+			rect.y2 = items[3];
+		}
+		g_object_set (magnifier, "source-display-bounds", &rect, NULL);
+	} else if (g_strcmp0 (property_name, "TargetSize") == 0) {
+		const int *items;
+		gsize      n_items;
+		RectBounds rect;
+
+		items = g_variant_get_fixed_array (value, &n_items, sizeof (gint32));
+		if (n_items == 4) {
+			rect.x1 = items[0];
+			rect.y1 = items[1];
+			rect.x2 = items[2];
+			rect.y2 = items[3];
+		}
+		g_object_set (magnifier, "target-display-bounds", &rect, NULL);
+	} else if (g_strcmp0 (property_name, "CursorSet") == 0) {
+		g_object_set (magnifier,
+			      "cursor-set", g_variant_get_string (value, NULL),
+			      NULL);
+	} else if (g_strcmp0 (property_name, "CursorSize") == 0) {
+		g_object_set (magnifier,
+			      "cursor-size", g_variant_get_int32 (value),
+			      NULL);
+	} else if (g_strcmp0 (property_name, "CursorZoom") == 0) {
+		g_object_set (magnifier,
+			      "cursor-scale-factor", g_variant_get_double (value),
+			      NULL);
+	} else if (g_strcmp0 (property_name, "CursorColor") == 0) {
+		g_object_set (magnifier,
+			      "cursor-color", g_variant_get_uint32 (value),
+			      NULL);
+	} else if (g_strcmp0 (property_name, "CursorHotspot") == 0) {
+		const int *items;
+		gsize      n_items;
+		Point      point;
+
+		items = g_variant_get_fixed_array (value, &n_items, sizeof (gint32));
+		if (n_items == 2) {
+			point.x = items[0];
+			point.y = items[1];
+		}
+		g_object_set (magnifier, "cursor-hotspot", &point, NULL);
+	} else if (g_strcmp0 (property_name, "CrosswireSize") == 0) {
+		g_object_set (magnifier,
+			      "crosswire-size", g_variant_get_int32 (value),
+			      NULL);
+	} else if (g_strcmp0 (property_name, "CrosswireLength") == 0) {
+		g_object_set (magnifier,
+			      "crosswire-length", g_variant_get_int32 (value),
+			      NULL);
+	} else if (g_strcmp0 (property_name, "CrosswireClip") == 0) {
+		g_object_set (magnifier,
+			      "crosswire-clip", g_variant_get_boolean (value),
+			      NULL);
+	} else if (g_strcmp0 (property_name, "CrosswireColor") == 0) {
+		g_object_set (magnifier,
+			      "crosswire-clip", g_variant_get_uint32 (value),
+			      NULL);
+	}
 
-gboolean
-impl_dbus_magnifier_set_cursor_color (Magnifier *magnifier, guint32 color)
-{
-	magnifier->cursor_color = color;
-	magnifier_transform_cursor (magnifier);
-	DBG (fprintf (stderr, "Setting cursor color: \t%u\n", (unsigned) magnifier->cursor_color));
-	
 	return TRUE;
 }
 
-guint32
-impl_dbus_magnifier_get_cursor_color (Magnifier *magnifier)
-{
-	return magnifier->cursor_color;
-}
+static const gchar introspection_xml[] =
+"<node>"
+  "<interface name='org.freedesktop.gnome.Magnifier'>"
+    "<method name='fullScreenCapable'>"
+      "<arg type='b' name='b-ret' direction='out'/>"
+    "</method>"
+    "<method name='hideCursor'/>"
+    "<method name='showCursor'/>"
+    "<method name='supportColorblindFilters'>"
+      "<arg type='b' name='b-ret' direction='out'/>"
+    "</method>"
+    "<method name='createZoomRegion'>"
+      "<arg type='d' name='zx' direction='in'/>"
+      "<arg type='d' name='zy' direction='in'/>"
+      "<arg type='ai' name='ROI' direction='in'/>"
+      "<arg type='ai' name='viewPort' direction='in'/>"
+      "<arg type='o' name='zoomRegion-ret' direction='out'/>"
+    "</method>"
+    "<method name='getZoomRegions'>"
+      "<arg type='as' name='zoomRegionList-ret' direction='out'/>"
+    "</method>"
+    "<method name='addZoomRegion'>"
+      "<arg type='o' name='region' direction='in'/>"
+      "<arg type='b' name='b-ret' direction='out'/>"
+    "</method>"
+    "<method name='clearAllZoomRegions'/>"
+    "<method name='dispose'/>"
+    "<property name='SourceSize' type='ai' access='readwrite'/>"
+    "<property name='TargetSize' type='ai' access='readwrite'/>"
+    "<property name='CursorSet' type='s' access='readwrite'/>"
+    "<property name='CursorSize' type='i' access='readwrite'/>"
+    "<property name='CursorZoom' type='d' access='readwrite'/>"
+    "<property name='CursorColor' type='u' access='readwrite'/>"
+    "<property name='CursorHotspot' type='ai' access='readwrite'/>"
+    "<property name='CrosswireSize' type='i' access='readwrite'/>"
+    "<property name='CrosswireLength' type='i' access='readwrite'/>"
+    "<property name='CrosswireClip' type='b' access='readwrite'/>"
+    "<property name='CrosswireColor' type='i' access='readwrite'/>"
+    "<property name='CursorDefaultSize' type='i' access='read'/>"
+  "</interface>"
+"</node>";
+
+static const GDBusInterfaceVTable interface_vtable = {
+	method_call_cb,
+	get_property_cb,
+	set_property_cb
+};
 
-gboolean
-impl_dbus_magnifier_set_cursor_hotspot (Magnifier *magnifier, gint32 x, gint32 y)
-{
-	magnifier->cursor_hotspot.x = x;
-	magnifier->cursor_hotspot.y = y;
-	magnifier_transform_cursor (magnifier);
-	
-	return TRUE;
-}
+static GDBusNodeInfo *introspection_data = NULL;
 
-GArray*
-impl_dbus_magnifier_get_cursor_hotspot (Magnifier *magnifier)
+static void
+magnifier_do_dispose (Magnifier *magnifier)
 {
-	GArray *ret = g_array_new (FALSE, FALSE, sizeof (gint32));
-	
-	g_array_append_val (ret, magnifier->cursor_hotspot.x);
-	g_array_append_val (ret, magnifier->cursor_hotspot.y);
-	
-	return ret;
-}
+	g_dbus_connection_unregister_object (dbus_connection, magnifier->priv->dbus_object_id);
 
-gint32
-impl_dbus_magnifier_get_cursor_default_size (Magnifier *magnifier)
-{
-	gint32 csize;
-	
-	if (magnifier->priv->cursor) {
-		gdk_drawable_get_size (magnifier->priv->cursor, &csize, &csize);
+	if (magnifier->zoom_regions) {
+		g_list_foreach (magnifier->zoom_regions, (GFunc)g_object_unref, NULL);
+		g_list_free (magnifier->zoom_regions);
 	}
-	
-	return csize;
-}
+	magnifier->zoom_regions = NULL;
 
-gboolean
-impl_dbus_magnifier_set_crosswire_size (Magnifier *magnifier, gint size)
-{
-	magnifier->crosswire_size = size;
-	DBG (fprintf (stderr, "Setting crosswire size: \t%d\n", magnifier->crosswire_size));
-	magnifier_zoom_regions_update_pointer (magnifier);
-	
-	return TRUE;
-}
+	g_object_unref (dbus_connection);
 
-gint
-impl_dbus_magnifier_get_crosswire_size (Magnifier *magnifier)
-{
-	return magnifier->crosswire_size;
+	gtk_main_quit ();
 }
 
-gboolean
-impl_dbus_magnifier_set_crosswire_length (Magnifier *magnifier, gint length)
+static void
+magnifier_gobject_dispose (GObject *object)
 {
-	GNOME_Magnifier_RectBounds rect_bounds;
-	rect_bounds.x1 = 0;
-	rect_bounds.y1 = 0;
-	rect_bounds.x2 = 4096;
-	rect_bounds.y2 = 4096;
-
-	magnifier->crosswire_length = length;
-	DBG (fprintf (stderr, "Setting crosswire length: \t%d\n", magnifier->crosswire_length));
-	magnifier_zoom_regions_mark_dirty (magnifier, rect_bounds);
-	
-	return TRUE;
-}
+	magnifier_do_dispose (MAGNIFIER (object));
 
-gboolean
-impl_dbus_magnifier_set_crosswire_clip (Magnifier *magnifier, gboolean clip)
-{
-	magnifier->crosswire_clip = clip;
-	DBG (fprintf (stderr, "Setting crosswire clip: \t%s\n", magnifier->crosswire_clip ? "true" : "false"));
-	magnifier_zoom_regions_update_pointer (magnifier);
-	
-	return TRUE;
+	G_OBJECT_CLASS (magnifier_parent_class)->dispose (object);
 }
 
-gboolean
-impl_dbus_magnifier_get_crosswire_clip (Magnifier *magnifier)
+static void
+magnifier_gobject_constructed (GObject *object)
 {
-	return magnifier->crosswire_clip;
-}
+	Magnifier   *magnifier = MAGNIFIER (object);
+	const gchar *display_env;
 
-gint
-impl_dbus_magnifier_get_crosswire_length (Magnifier *magnifier) {
-	return magnifier->crosswire_length;
-}
+	display_env = g_getenv ("DISPLAY");
 
-gboolean
-impl_dbus_magnifier_set_crosswire_color (Magnifier *magnifier, guint32 color)
-{
-	magnifier->crosswire_color = color;
-	DBG (fprintf (stderr, "Setting crosswire color: \t%ld\n", (long) magnifier->crosswire_color));
-	
-	return TRUE;
+	magnifier_init_display (magnifier, display_env, TRUE);
+	magnifier_init_display (magnifier, display_env, FALSE);
 }
 
-guint32
-impl_dbus_magnifier_get_crosswire_color (Magnifier *magnifier)
+static void
+magnifier_gobject_get_property (GObject    *object,
+				guint       prop_id,
+				GValue     *value,
+				GParamSpec *pspec)
 {
-	return magnifier->crosswire_color;
+	Magnifier *magnifier = MAGNIFIER (object);
+
+	switch (prop_id) {
+	case MAGNIFIER_SOURCE_SIZE_PROP: {
+		RectBounds *rect = g_new (RectBounds, 1);
+
+		*rect = magnifier->source_bounds;
+		g_value_set_pointer (value, rect);
+	}
+		break;
+	case MAGNIFIER_TARGET_SIZE_PROP: {
+		RectBounds *rect = g_new (RectBounds, 1);
+
+		*rect = magnifier->target_bounds;
+		g_value_set_pointer (value, rect);
+	}
+		break;
+	case MAGNIFIER_CURSOR_SET_PROP:
+		g_value_set_string (value, magnifier->cursor_set);
+		break;
+	case MAGNIFIER_CURSOR_SIZE_PROP:
+		g_value_set_int (value, magnifier->cursor_size_x);
+		break;
+	case MAGNIFIER_CURSOR_ZOOM_PROP:
+		g_value_set_float (value, magnifier->cursor_scale_factor);
+		break;
+	case MAGNIFIER_CURSOR_COLOR_PROP:
+		g_value_set_ulong (value, magnifier->cursor_color);
+		break;
+	case MAGNIFIER_CURSOR_HOTSPOT_PROP: {
+		Point *point = g_new (Point, 1);
+
+		*point = magnifier->cursor_hotspot;
+		g_value_set_pointer (value, point);
+	}
+		break;
+	case MAGNIFIER_CURSOR_DEFAULT_SIZE_PROP: {
+		int csize = 0;
+
+		if (magnifier->priv->cursor)
+			gdk_drawable_get_size (magnifier->priv->cursor,
+					       &csize, &csize);
+		g_value_set_uint (value, csize);
+	}
+		break;
+	case MAGNIFIER_CROSSWIRE_SIZE_PROP:
+		g_value_set_int (value, magnifier->crosswire_size);
+		break;
+	case MAGNIFIER_CROSSWIRE_LENGTH_PROP:
+		g_value_set_int (value, magnifier->crosswire_length);
+		break;
+	case MAGNIFIER_CROSSWIRE_CLIP_PROP:
+		g_value_set_boolean (value, magnifier->crosswire_clip);
+		break;
+	case MAGNIFIER_CROSSWIRE_COLOR_PROP:
+		g_value_set_long (value, magnifier->crosswire_color);
+		break;
+	case MAGNIFIER_SOURCE_DISPLAY_PROP:
+		g_value_set_string (value, magnifier->source_display_name);
+		break;
+	case MAGNIFIER_TARGET_DISPLAY_PROP:
+		g_value_set_string (value, magnifier->target_display_name);
+		break;
+	default:
+		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+	}
 }
 
 static void
-magnifier_set_property (BonoboPropertyBag *bag,
-			BonoboArg *arg,
-			guint arg_id,
-			CORBA_Environment *ev,
-			gpointer user_data)
+magnifier_gobject_set_property (GObject      *object,
+				guint         prop_id,
+				const GValue *value,
+				GParamSpec   *pspec)
 {
-	Magnifier *magnifier = user_data;
-	gchar *full_display_string;
+	Magnifier *magnifier = MAGNIFIER (object);
+	RectBounds rect_bounds = { 0, 0, 4096, 4096 };
 
-	GNOME_Magnifier_RectBounds rect_bounds;
-	rect_bounds.x1 = 0;
-	rect_bounds.y1 = 0;
-	rect_bounds.x2 = 4096;
-	rect_bounds.y2 = 4096;
+	switch (prop_id) {
+	case MAGNIFIER_SOURCE_DISPLAY_PROP: {
+		const gchar *full_display_string;
 
-	switch (arg_id) {
-	case MAGNIFIER_SOURCE_DISPLAY_PROP:
-		full_display_string = BONOBO_ARG_GET_STRING (arg);
+		full_display_string = g_value_get_string (value);
 		if (can_open_display (full_display_string))
 		{
 		    GSList *zoom_region_params = NULL;
@@ -1424,9 +1302,12 @@ magnifier_set_property (BonoboPropertyBag *bag,
 		    gmag_gs_reset_overlay_at_idle (magnifier);
 		}
 		DBG(fprintf (stderr, "Set source display: \t%s\n", full_display_string));
+	}
 		break;
-	case MAGNIFIER_TARGET_DISPLAY_PROP:
-		full_display_string = BONOBO_ARG_GET_STRING (arg);
+	case MAGNIFIER_TARGET_DISPLAY_PROP: {
+		const gchar *full_display_string;
+
+		full_display_string = g_value_get_string (value);
 		if (can_open_display (full_display_string))
 		{
 		    magnifier->target_screen_num =
@@ -1436,10 +1317,11 @@ magnifier_set_property (BonoboPropertyBag *bag,
 		    magnifier->target_display =
 			gdk_display_open (full_display_string);
 		    magnifier->target_display_name = g_strdup (full_display_string);
-		    if (GTK_IS_WINDOW (magnifier->priv->w)) 
+		    if (GTK_IS_WINDOW (magnifier))
 		    {
+#if 0 /* FIXME */
 #ifdef REPARENT_GTK_WINDOW_WORKS
-			gtk_window_set_screen (GTK_WINDOW (magnifier->priv->w), 
+			gtk_window_set_screen (GTK_WINDOW (magnifier),
 					       gdk_display_get_screen (
 						   magnifier->target_display,
 						   magnifier->target_screen_num));
@@ -1462,6 +1344,7 @@ magnifier_set_property (BonoboPropertyBag *bag,
 			/* restore the zoom regions in their new host magnifier window */
 			magnifier_zoom_regions_restore (magnifier, zoom_region_params);
 #endif
+#endif
 		    }
 		    magnifier_get_display_rect_bounds (magnifier, &magnifier->source_bounds, FALSE);
 		    magnifier_init_cursor_set (magnifier, magnifier->cursor_set); /* needed to reset pixmaps */
@@ -1470,7 +1353,7 @@ magnifier_set_property (BonoboPropertyBag *bag,
 					     magnifier->target_bounds.x1,
 					     magnifier->target_bounds.y1);
 		    else
-			    gtk_window_move (GTK_WINDOW (magnifier->priv->w),
+			    gtk_window_move (GTK_WINDOW (magnifier),
 					     magnifier->target_bounds.x1,
 					     magnifier->target_bounds.y1);
 		    
@@ -1484,7 +1367,7 @@ magnifier_set_property (BonoboPropertyBag *bag,
 					    magnifier->target_bounds.x1,
 					    magnifier->target_bounds.y2 -
 					    magnifier->target_bounds.y1);
-			gtk_window_resize (GTK_WINDOW (magnifier->priv->w),
+			gtk_window_resize (GTK_WINDOW (magnifier),
 				       magnifier->target_bounds.x2 - magnifier->target_bounds.x1,
 				       magnifier->target_bounds.y2 - magnifier->target_bounds.y1);
 		    DBG(fprintf (stderr, "Set target size: \t%d,%d to %d,%d\n", 
@@ -1497,21 +1380,20 @@ magnifier_set_property (BonoboPropertyBag *bag,
 		}
 		DBG(fprintf (stderr, "Set target display: \t%s (screen %d)\n", 
 			      full_display_string, magnifier->target_screen_num));
+	}
 		break;
-	case MAGNIFIER_SOURCE_SIZE_PROP:
-	        magnifier->source_bounds = BONOBO_ARG_GET_GENERAL (arg,
-								   TC_GNOME_Magnifier_RectBounds,
-								   GNOME_Magnifier_RectBounds,
-								   NULL);
+	case MAGNIFIER_SOURCE_SIZE_PROP: {
+		RectBounds *rect = g_value_get_pointer (value);
+
+	        magnifier->source_bounds = *rect;
 		DBG (fprintf (stderr, "Set source size: \t%d,%d to %d,%d\n", 
 			      magnifier->source_bounds.x1, magnifier->source_bounds.y1, magnifier->source_bounds.x2, magnifier->source_bounds.y2));
+	}
 		break;
-	case MAGNIFIER_TARGET_SIZE_PROP:
-	        magnifier->target_bounds = BONOBO_ARG_GET_GENERAL (arg,
-								   TC_GNOME_Magnifier_RectBounds,
-								   GNOME_Magnifier_RectBounds,
-				
-				   NULL);
+	case MAGNIFIER_TARGET_SIZE_PROP: {
+		RectBounds *rect = g_value_get_pointer (value);
+
+	        magnifier->target_bounds = *rect;
 		if (magnifier->priv->overlay)
 			gdk_window_move_resize (magnifier->priv->overlay,
 						magnifier->target_bounds.x1,
@@ -1521,11 +1403,11 @@ magnifier_set_property (BonoboPropertyBag *bag,
 						magnifier->target_bounds.y2 -
 						magnifier->target_bounds.y1);
 		else
-			gtk_window_move (GTK_WINDOW (magnifier->priv->w),
+			gtk_window_move (GTK_WINDOW (magnifier),
 					 magnifier->target_bounds.x1,
 					 magnifier->target_bounds.y1);
 		
-		gtk_window_resize (GTK_WINDOW (magnifier->priv->w),
+		gtk_window_resize (GTK_WINDOW (magnifier),
 				   magnifier->target_bounds.x2 - magnifier->target_bounds.x1,
 				   magnifier->target_bounds.y2 - magnifier->target_bounds.y1);
 		gmag_gs_check_set_struts (magnifier);
@@ -1534,49 +1416,44 @@ magnifier_set_property (BonoboPropertyBag *bag,
 		if (!strcmp (magnifier->target_display_name, magnifier->source_display_name) && 
 		    (magnifier->target_screen_num == magnifier->source_screen_num)) 
 		    magnifier_adjust_source_size (magnifier);
+	}
 		break;
 	case MAGNIFIER_CURSOR_SET_PROP:
-		magnifier_init_cursor_set (magnifier, g_strdup (BONOBO_ARG_GET_STRING (arg)));
-		DBG (fprintf (stderr, "Setting cursor set: \t%s\n", BONOBO_ARG_GET_STRING (arg)));
+		magnifier_init_cursor_set (magnifier, g_strdup (g_value_get_string (value)));
+		DBG (fprintf (stderr, "Setting cursor set: \t%s\n", g_value_get_string (value)));
 		break;
 	case MAGNIFIER_CURSOR_SIZE_PROP:
-		magnifier->cursor_size_x = BONOBO_ARG_GET_INT (arg);
-		magnifier->cursor_size_y = BONOBO_ARG_GET_INT (arg);
+		magnifier->cursor_size_x = g_value_get_int (value);
+		magnifier->cursor_size_y = magnifier->cursor_size_x;
 		magnifier_transform_cursor (magnifier);
 		DBG (fprintf (stderr, "Setting cursor size: \t%d\n", magnifier->cursor_size_x));
 		break;
 	case MAGNIFIER_CURSOR_ZOOM_PROP:
-		magnifier->cursor_scale_factor = BONOBO_ARG_GET_FLOAT (arg);
+		magnifier->cursor_scale_factor = g_value_get_float (value);
 		DBG (fprintf (stderr, "Setting cursor scale factor: \t%f\n", (float) magnifier->cursor_scale_factor));
 		magnifier_transform_cursor (magnifier);
 		break;
 	case MAGNIFIER_CURSOR_COLOR_PROP:
-		magnifier->cursor_color = BONOBO_ARG_GET_GENERAL (arg,
-								  TC_CORBA_unsigned_long, 
-								  CORBA_unsigned_long, 
-								  NULL);
+		magnifier->cursor_color = g_value_get_ulong (value);
 		magnifier_transform_cursor (magnifier);
 		DBG (fprintf (stderr, "Setting cursor color: \t%u\n", (unsigned) magnifier->cursor_color));
 		break;
-	case MAGNIFIER_CURSOR_HOTSPOT_PROP:
-		magnifier->cursor_hotspot = BONOBO_ARG_GET_GENERAL (arg,
-								    TC_GNOME_Magnifier_Point,
-								    GNOME_Magnifier_Point,
-								    NULL);
+	case MAGNIFIER_CURSOR_HOTSPOT_PROP: {
+		Point *point = g_value_get_pointer (value);
+
+		magnifier->cursor_hotspot = *point;
 		/* TODO: notify zoomers */
                 /* FIXME: don't call init_cursor, it overwrites this property! */
-		magnifier_transform_cursor (magnifier); 
-		break;
-	case MAGNIFIER_CURSOR_DEFAULT_SIZE_PROP:
-		bonobo_exception_set (ev, ex_Bonobo_PropertyBag_ReadOnly);
+		magnifier_transform_cursor (magnifier);
+	}
 		break;
 	case MAGNIFIER_CROSSWIRE_SIZE_PROP:
-		magnifier->crosswire_size = BONOBO_ARG_GET_INT (arg);
+		magnifier->crosswire_size = g_value_get_int (value);
 		DBG (fprintf (stderr, "Setting crosswire size: \t%d\n", magnifier->crosswire_size));
 		magnifier_zoom_regions_update_pointer (magnifier);
 		break;
 	case MAGNIFIER_CROSSWIRE_LENGTH_PROP:
-		magnifier->crosswire_length = BONOBO_ARG_GET_INT (arg);
+		magnifier->crosswire_length = g_value_get_int (value);
 		DBG (fprintf (stderr, "Setting crosswire length: \t%d\n", magnifier->crosswire_length));
 		/* FIXME: The call below forces the repaint of all the screen,
 		 * but I can't figure a better solution right now to the case
@@ -1584,713 +1461,277 @@ magnifier_set_property (BonoboPropertyBag *bag,
 		magnifier_zoom_regions_mark_dirty (magnifier, rect_bounds);
 		break;
 	case MAGNIFIER_CROSSWIRE_CLIP_PROP:
-		magnifier->crosswire_clip = BONOBO_ARG_GET_BOOLEAN (arg);
+		magnifier->crosswire_clip = g_value_get_boolean (value);
 		DBG (fprintf (stderr, "Setting crosswire clip: \t%s\n", magnifier->crosswire_clip ? "true" : "false"));
 		magnifier_zoom_regions_update_pointer (magnifier);
 		break;
 	case MAGNIFIER_CROSSWIRE_COLOR_PROP:
-		magnifier->crosswire_color = BONOBO_ARG_GET_LONG (arg);
+		magnifier->crosswire_color = g_value_get_long (value);
 		DBG (fprintf (stderr, "Setting crosswire size: \t%ld\n", (long) magnifier->crosswire_color));
 		break;
 	default:
-		bonobo_exception_set (ev, ex_Bonobo_PropertyBag_NotFound);
-		break;
-	};
+		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+	}
 }
 
 static void
-magnifier_do_dispose (Magnifier *magnifier)
+magnifier_init (Magnifier *magnifier)
 {
-	/* FIXME: this is dead ropey code structuring */
-	bonobo_activation_active_server_unregister (
-		MAGNIFIER_OAFIID, BONOBO_OBJREF (magnifier));
+	magnifier->priv = MAGNIFIER_GET_PRIVATE (magnifier);
 
-	if (magnifier->zoom_regions_dbus)
-		g_list_free (magnifier->zoom_regions_dbus);
-	if (magnifier->zoom_regions)
-		g_list_free (magnifier->zoom_regions);
-	magnifier->zoom_regions = NULL;
-	magnifier->zoom_regions_dbus = NULL;
-	
-	bonobo_main_quit ();
-}
+	magnifier->cursor_scale_factor = 1.0F;
+	magnifier->cursor_color = 0xFF000000;
+	magnifier->crosswire_size = 1;
+	magnifier->priv->use_source_cursor = TRUE;
+	magnifier_init_cursor_set (magnifier, "default");
 
-static void
-magnifier_gobject_dispose (GObject *object)
-{
-	magnifier_do_dispose (MAGNIFIER (object));
+	magnifier->priv->canvas = gtk_fixed_new ();
+	gtk_container_add (GTK_CONTAINER (magnifier), magnifier->priv->canvas);
 
-	BONOBO_CALL_PARENT (G_OBJECT_CLASS, dispose, (object));
-}
+	mag_timing.process = g_timer_new ();
+	mag_timing.frame = g_timer_new ();
+	mag_timing.scale = g_timer_new ();
+	mag_timing.idle = g_timer_new ();
 
-static inline
-CORBA_boolean
-impl_magnifier_support_colorblind_filters (PortableServer_Servant _servant G_GNUC_UNUSED,
-					   CORBA_Environment *ev G_GNUC_UNUSED)
-{
-#ifdef HAVE_COLORBLIND
-	return CORBA_TRUE;
-#else
-	return CORBA_FALSE;
+#ifdef DEBUG_CLIENT_CALLS
+	client_debug = (g_getenv ("MAG_CLIENT_DEBUG") != NULL);
 #endif
+	zoom_hash = g_hash_table_new (g_str_hash, g_str_equal);
 }
 
 static void
-impl_magnifier_hide_cursor (PortableServer_Servant servant,
-                        CORBA_Environment *ev)
+magnifier_size_allocate (GtkWidget     *widget,
+			 GtkAllocation *allocation)
 {
-        Magnifier *magnifier = MAGNIFIER (bonobo_object_from_servant (servant));
+	GTK_WIDGET_CLASS (magnifier_parent_class)->size_allocate (widget, allocation);
 
-	gmag_gs_hide_cursor (magnifier);
+	gmag_gs_check_set_struts (MAGNIFIER (widget));
 }
 
 static void
-impl_magnifier_show_cursor (PortableServer_Servant servant,
-                            CORBA_Environment *ev)
-{
-	Magnifier *magnifier = MAGNIFIER (bonobo_object_from_servant (servant));
-
-	gmag_gs_show_cursor (magnifier);
-}
-
-static
-CORBA_boolean
-impl_magnifier_full_screen_capable (PortableServer_Servant servant,
-				    CORBA_Environment * ev)
-{
-	Magnifier *magnifier = MAGNIFIER (bonobo_object_from_servant (servant));
-
-	if ((strcmp (magnifier->source_display_name,
-		     magnifier->target_display_name) != 0) ||
-		gmag_gs_use_compositor (magnifier))
-		return CORBA_TRUE;
-
-	return CORBA_FALSE;
-}
-
-gboolean
-impl_dbus_magnifier_full_screen_capable (Magnifier *magnifier)
-{
-	if ((strcmp (magnifier->source_display_name,
-		     magnifier->target_display_name) != 0) ||
-		gmag_gs_use_compositor (magnifier)) {
-		return TRUE;
-	}
-
-	return FALSE;
-}
-
-gboolean
-impl_dbus_magnifier_hide_cursor (Magnifier *magnifier)
-{
-	gmag_gs_hide_cursor (magnifier);
-	
-	return TRUE;
-}
-
-gboolean
-impl_dbus_magnifier_show_cursor (Magnifier *magnifier)
-{
-	gmag_gs_show_cursor (magnifier);
-
-	return TRUE;
-}
-
-gboolean
-impl_dbus_magnifier_support_colorblind_filters (Magnifier *magnifier)
-{
-#ifdef HAVE_COLORBLIND
-	return TRUE;
-#else
-	return FALSE;
-#endif
-}
-
-gchar*
-impl_dbus_magnifier_create_zoom_region (Magnifier *magnifier,
-					const double zx,
-				   	const double zy,
-				   	const gint32 **roi,
-				   	const gint32 **viewport)
-{
-	ZoomRegion *zoom_region = zoom_region_new();
-
-	DBG (fprintf (stderr, "Create zoom region: \tzoom %f,%f, viewport %d,%d to %d,%d\n", (float) zx, (float) zy, (*viewport)[0]/*x1*/, (*viewport)[1]/*y1*/, (*viewport)[2]/*x2*/, (*viewport)[3]/*y3*/));
-
-	/* FIXME:
-	 * shouldn't do this here, since it causes the region to get
-	 * mapped onto the parent, if if it's not explicitly added!
-	 */
-	DBG(g_message ("creating zoom region with parent %p", magnifier));
-	zoom_region->priv->parent = magnifier;
-
-	impl_dbus_zoom_region_set_mag_factor (zoom_region, zx, zy);
-	
-	impl_dbus_zoom_region_move_resize (zoom_region, viewport);
-
-	impl_dbus_zoom_region_set_roi (zoom_region, roi);
-
-	gtk_widget_set_size_request (magnifier->priv->canvas,
-				     (*viewport)[2] - (*viewport)[0],
-				     (*viewport)[3] - (*viewport)[1]);
-	gtk_widget_show (magnifier->priv->canvas);
-	gtk_widget_show (magnifier->priv->w);
-	
-	g_hash_table_insert (zoom_hash, g_strdup(zoom_region->object_path), zoom_region);
-
-	return g_strdup (zoom_region->object_path);
-}
-
-gchar**
-impl_dbus_magnifier_get_zoom_regions (Magnifier *magnifier)
-{
-	ZoomRegion *zoom_region;
-	gchar **list;
-	int i, len;
-
-	len = g_list_length (magnifier->zoom_regions);
-	list = g_malloc0 (sizeof (gchar *) * len);
-	for (i = 0; i < len; ++i) {
-		zoom_region = g_list_nth_data (magnifier->zoom_regions_dbus, i);
-		list[i] = g_strdup (zoom_region->object_path);
-	}
-
-	DBG (fprintf (stderr, "Get zoom regions: \t%d\n", len));
-	
-	return list; 
-}
-
-gboolean
-impl_dbus_magnifier_add_zoom_region (Magnifier *magnifier, gchar *zoom_region_path)
-{
-	if (!magnifier->source_initialized) 
-	{
-		magnifier_set_extension_listeners (magnifier, magnifier_get_root (magnifier));
-	}
-
-	/* FIXME: this needs proper lifecycle management */
-	ZoomRegion *zoom_region = g_hash_table_lookup (zoom_hash, zoom_region_path);
-	magnifier->zoom_regions = g_list_append (magnifier->zoom_regions, BONOBO_OBJREF (zoom_region));
-	magnifier->zoom_regions_dbus = g_list_append (magnifier->zoom_regions_dbus, zoom_region);
-	g_hash_table_remove (zoom_hash, zoom_region_path);
-	gmag_gs_check_set_struts (magnifier);
-
-	return TRUE;
-}
-
-gboolean
-impl_dbus_magnifier_clear_all_zoom_regions (Magnifier *magnifier)
+magnifier_realize (GtkWidget *widget)
 {
-	g_list_foreach (magnifier->zoom_regions_dbus,
-			magnifier_dbus_unref_zoom_region, magnifier);
-	g_list_foreach (magnifier->zoom_regions,
-			magnifier_unref_zoom_region, magnifier);
-	g_list_free (magnifier->zoom_regions);
-	g_list_free (magnifier->zoom_regions_dbus);
-	magnifier->zoom_regions = NULL;
-	magnifier->zoom_regions_dbus = NULL;
-
-	return TRUE;
-}
+	GTK_WIDGET_CLASS (magnifier_parent_class)->realize (widget);
 
-gboolean
-impl_dbus_magnifier_dispose (Magnifier *magnifier)
-{
-	magnifier_do_dispose (magnifier);
-	
-	return TRUE;
+	gmag_gs_magnifier_realize (widget);
 }
 
 static void
-impl_magnifier_set_source_display (PortableServer_Servant servant,
-				   const CORBA_char *display,
-				   CORBA_Environment *ev)
+magnifier_destroy (GtkObject *object)
 {
-	Magnifier *magnifier = MAGNIFIER (bonobo_object_from_servant (servant));
-	BonoboArg *arg = bonobo_arg_new (BONOBO_ARG_STRING);
-	gchar *full_display_string;
-
-	full_display_string = g_strdup (display);
-	if (strcmp (full_display_string, "") == 0)
-		full_display_string = (gchar *) g_getenv ("DISPLAY");
-
-	BONOBO_ARG_SET_STRING (arg, full_display_string);
-	
-	DBG (fprintf (stderr, "Set source display: \t%s\n",
-		      full_display_string));
-
-	if (strcmp (full_display_string, magnifier->source_display_name)) {
-	    magnifier_set_property (magnifier->property_bag,
-				    arg,
-				    MAGNIFIER_SOURCE_DISPLAY_PROP,
-				    ev,
-				    magnifier);
-	}
-	else
-	{
-	    DBG (fprintf (stderr, "Attempt to set source to same value as previous: %s\n",
-			  full_display_string));
-	}
-	bonobo_arg_release (arg);
+	gtk_main_quit ();
 }
 
 static void
-impl_magnifier_set_target_display (PortableServer_Servant servant,
-				   const CORBA_char *display,
-				   CORBA_Environment *ev)
-{
-	Magnifier *magnifier = MAGNIFIER (bonobo_object_from_servant (servant));
-	BonoboArg *arg = bonobo_arg_new (BONOBO_ARG_STRING);
-	gchar *full_display_string;
-
-	full_display_string = g_strdup (display);
-	if (strcmp (full_display_string, "") == 0)
-		full_display_string = (gchar *) g_getenv ("DISPLAY");
-
-	BONOBO_ARG_SET_STRING (arg, full_display_string);
-	
-	DBG (fprintf (stderr, "Set target display: \t%s\n",
-		      full_display_string));
-
-	if (strcmp (full_display_string, magnifier->target_display_name)) 
-	{
-	    magnifier_set_property (magnifier->property_bag,
-				    arg,
-				    MAGNIFIER_TARGET_DISPLAY_PROP,
-				    ev,
-				    magnifier);
-	}
-	else
-	{
-	    DBG (fprintf (stderr, "Attempt to set target to same value as previous: %s\n",
-			  full_display_string));
-	}
-	bonobo_arg_release (arg);
-}
-
-static 
-CORBA_string
-impl_magnifier_get_source_display (PortableServer_Servant servant,
-				   CORBA_Environment *ev)
-{
-        Magnifier *magnifier = MAGNIFIER (bonobo_object_from_servant (servant));
-	DBG (fprintf (stderr, "Get source display: \t%s\n", magnifier->source_display_name));
-
-	return CORBA_string_dup (magnifier->source_display_name ? magnifier->source_display_name : "");
-}
-
-static 
-CORBA_string
-impl_magnifier_get_target_display (PortableServer_Servant servant,
-				   CORBA_Environment *ev)
+magnifier_class_init (MagnifierClass *klass)
 {
-        Magnifier *magnifier = MAGNIFIER (bonobo_object_from_servant (servant));
-	DBG (fprintf (stderr, "Get target display: \t%s\n", 
-		      magnifier->target_display_name));
+	GObjectClass * object_class = (GObjectClass *) klass;
+	GtkWidgetClass *widget_class = (GtkWidgetClass *) klass;
+	GtkObjectClass *gtk_object_class = (GtkObjectClass *) klass;
 
-	return CORBA_string_dup (magnifier->target_display_name ? magnifier->target_display_name : "");
+	object_class->constructed = magnifier_gobject_constructed;
+	object_class->dispose = magnifier_gobject_dispose;
+	object_class->get_property = magnifier_gobject_get_property;
+	object_class->set_property = magnifier_gobject_set_property;
+
+	widget_class->realize = magnifier_realize;
+	widget_class->size_allocate = magnifier_size_allocate;
+	gtk_object_class->destroy = magnifier_destroy;
+
+	g_object_class_install_property (object_class,
+					 MAGNIFIER_SOURCE_DISPLAY_PROP,
+					 g_param_spec_string ("source-display-screen",
+							      "SourceDisplayScreen",
+							      "source display screen",
+							      NULL,
+							      G_PARAM_WRITABLE));
+	g_object_class_install_property (object_class,
+					 MAGNIFIER_TARGET_DISPLAY_PROP,
+					 g_param_spec_string ("target-display-screen",
+							      "TargetDisplayScreen",
+							      "target display screen",
+							      NULL,
+							      G_PARAM_WRITABLE));
+	g_object_class_install_property (object_class,
+					 MAGNIFIER_SOURCE_SIZE_PROP,
+					 g_param_spec_pointer ("source-display-bounds",
+							       "SourceDisplayBounds",
+							       "source display bounds/size",
+							       G_PARAM_READWRITE));
+	g_object_class_install_property (object_class,
+					 MAGNIFIER_TARGET_SIZE_PROP,
+					 g_param_spec_pointer ("target-display-bounds",
+							       "TargetDisplayBounds",
+							       "target display bounds/size",
+							       G_PARAM_READWRITE));
+	g_object_class_install_property (object_class,
+					 MAGNIFIER_CURSOR_SET_PROP,
+					 g_param_spec_string ("cursor-set",
+							      "CursorSet",
+							      "name of cursor set",
+							      NULL,
+							      G_PARAM_READWRITE));
+	g_object_class_install_property (object_class,
+					 MAGNIFIER_CURSOR_SIZE_PROP,
+					 g_param_spec_int ("cursor-size",
+							   "CursorSize",
+							   "cursor size, in pixels",
+							   0, G_MAXINT, 64,
+							   G_PARAM_READWRITE));
+	g_object_class_install_property (object_class,
+					 MAGNIFIER_CURSOR_ZOOM_PROP,
+					 g_param_spec_float ("cursor-scale-factor",
+							     "CursorScaleFactor",
+							     "scale factor for cursors (overrides size)",
+							     0, G_MAXFLOAT, 1.0F,
+							     G_PARAM_READWRITE));
+	g_object_class_install_property (object_class,
+					 MAGNIFIER_CURSOR_COLOR_PROP,
+					 g_param_spec_ulong ("cursor-color",
+							     "CursorColor",
+							     "foreground color for 1-bit cursors, as ARGB",
+							     0, G_MAXULONG, 0xFF000000,
+							     G_PARAM_READWRITE));
+	g_object_class_install_property (object_class,
+					 MAGNIFIER_CURSOR_HOTSPOT_PROP,
+					 g_param_spec_pointer ("cursor-hotspot",
+							       "CursorHotspot",
+							       "hotspot relative to cursor's upper-left-corner, at default resolition",
+							       G_PARAM_READWRITE));
+	g_object_class_install_property (object_class,
+					 MAGNIFIER_CURSOR_DEFAULT_SIZE_PROP,
+					 g_param_spec_int ("cursor-default-size",
+							   "CursorDefaultSize",
+							   "default size of current cursor set",
+							   G_MININT, G_MAXINT, 0,
+							   G_PARAM_READWRITE));
+	g_object_class_install_property (object_class,
+					 MAGNIFIER_CROSSWIRE_SIZE_PROP,
+					 g_param_spec_int ("crosswire-size",
+							   "CrosswireSize",
+							   "thickness of crosswire cursor, in target pixels",
+							   G_MININT, G_MAXINT, 1,
+							   G_PARAM_READWRITE));
+	g_object_class_install_property (object_class,
+					 MAGNIFIER_CROSSWIRE_LENGTH_PROP,
+					 g_param_spec_int ("crosswire-length",
+							   "CrosswireLength",
+							   "length of crosswire cursor, in target pixels",
+							   G_MININT, G_MAXINT, 0,
+							   G_PARAM_READWRITE));
+	g_object_class_install_property (object_class,
+					 MAGNIFIER_CROSSWIRE_COLOR_PROP,
+					 g_param_spec_long ("crosswire-color",
+							    "CrosswireColor",
+							    "color of crosswire, as A-RGB; note that alpha is required. (use 0 for XOR wire)",
+							    G_MINLONG, G_MAXLONG, 0,
+							    G_PARAM_READWRITE));
+	g_object_class_install_property (object_class,
+					 MAGNIFIER_CROSSWIRE_CLIP_PROP,
+					 g_param_spec_boolean ("crosswire-clip",
+							       "CrosswireClip",
+							       "whether to inset the cursor over the crosswire or not",
+							       FALSE,
+							       G_PARAM_READWRITE));
+
+	g_type_class_add_private (klass, sizeof (MagnifierPrivate));
 }
 
-static GNOME_Magnifier_ZoomRegion
-impl_magnifier_create_zoom_region (PortableServer_Servant servant,
-				   const CORBA_float zx,
-				   const CORBA_float zy,
-				   const GNOME_Magnifier_RectBounds *roi,
-				   const GNOME_Magnifier_RectBounds *viewport,
-				   CORBA_Environment *ev)
+Magnifier *
+magnifier_new (gboolean     override_redirect,
+	       const gchar *source_display_name,
+	       const gchar *target_display_name)
 {
-	Magnifier *magnifier = MAGNIFIER (bonobo_object_from_servant (servant));
-	CORBA_any viewport_any;
-	ZoomRegion *zoom_region = zoom_region_new ();
-	Bonobo_PropertyBag properties;
-	GNOME_Magnifier_ZoomRegion retval;
-
-	DBG (fprintf (stderr, "Create zoom region: \tzoom %f,%f, viewport %d,%d to %d,%d\n", (float) zx, (float) zy, viewport->x1, viewport->y1, viewport->x2, viewport->y2));
-
-	/* FIXME:
-	 * shouldn't do this here, since it causes the region to get
-	 * mapped onto the parent, if if it's not explicitly added!
-	 */
-	DBG(g_message ("creating zoom region with parent %p", magnifier));
-	zoom_region->priv->parent = magnifier;
-
-	retval = BONOBO_OBJREF (zoom_region);
-
-	/* XXX: should check ev after each call, below */
-	CORBA_exception_init (ev);
-	GNOME_Magnifier_ZoomRegion_setMagFactor (retval, zx, zy, ev);
-
-	if (ev->_major != CORBA_NO_EXCEPTION)
-		fprintf (stderr, "EXCEPTION setMagFactor\n");
-
-	CORBA_exception_init (ev);
-	properties = GNOME_Magnifier_ZoomRegion_getProperties (retval, ev);
-	if (ev->_major != CORBA_NO_EXCEPTION)
-		fprintf (stderr, "EXCEPTION getProperties\n");
-
-	viewport_any._type = TC_GNOME_Magnifier_RectBounds;
-	viewport_any._value = (gpointer) viewport;
-	Bonobo_PropertyBag_setValue (
-		properties, "viewport", &viewport_any, ev);
-
-	GNOME_Magnifier_ZoomRegion_setROI (retval, roi, ev);
-	if (ev->_major != CORBA_NO_EXCEPTION)
-		fprintf (stderr, "EXCEPTION setROI\n");
-
-	CORBA_exception_init (ev);
-
-	gtk_widget_set_size_request (magnifier->priv->canvas,
-			   viewport->x2 - viewport->x1,
-			   viewport->y2 - viewport->y1);
-	gtk_widget_show (magnifier->priv->canvas);
-	gtk_widget_show (magnifier->priv->w);
+	Magnifier *mag;
+	GtkWindowType mag_win_type = GTK_WINDOW_TOPLEVEL;
+	guint32 request_name_reply;
+	GVariant *result;
+	GError *error = NULL;
 
-	bonobo_object_release_unref (properties, ev);
-	
-	return CORBA_Object_duplicate (retval, ev);
-}
+	if (override_redirect || gmag_gs_use_compositor (source_display_name, target_display_name))
+		mag_win_type = GTK_WINDOW_POPUP;
 
-static
-CORBA_boolean
-impl_magnifier_add_zoom_region (PortableServer_Servant servant,
-				const GNOME_Magnifier_ZoomRegion region,
-				CORBA_Environment * ev)
-{
-	Magnifier *magnifier = MAGNIFIER (bonobo_object_from_servant (servant));
+	mag = g_object_new (magnifier_get_type(),
+			    "source-display-screen", source_display_name,
+			    "target-display-screen", target_display_name,
+			    "type", mag_win_type,
+			    "can_focus", FALSE,
+			    "title", "magnifier",
+			    "allow_grow", TRUE,
+			    "allow_shrink", TRUE,
+			    "border_width", 0,
+			    NULL);
+
+	if (!dbus_connection)
+		dbus_connection = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
+	if (!dbus_connection) {
+		g_error ("Unable to connect to dbus: %s", error->message);
+		g_error_free (error);
+		g_object_unref (mag);
 
-	if (!magnifier->source_initialized) 
-	{
-		magnifier_set_extension_listeners (magnifier, magnifier_get_root (magnifier));
+		return NULL;
 	}
 
-	/* FIXME: this needs proper lifecycle management */
-	magnifier->zoom_regions = g_list_append (magnifier->zoom_regions, region);
-	gmag_gs_check_set_struts (magnifier);
-
-	return CORBA_TRUE;
-}
-
-static Bonobo_PropertyBag
-impl_magnifier_get_properties (PortableServer_Servant servant,
-			       CORBA_Environment *ev)
-{
-	Magnifier *magnifier = MAGNIFIER (bonobo_object_from_servant (servant));
-	return bonobo_object_dup_ref (
-		BONOBO_OBJREF (magnifier->property_bag), ev);
-}
+	result = g_dbus_connection_call_sync (dbus_connection,
+					      "org.freedesktop.DBus",
+					      "/org/freedesktop/DBus",
+					      "org.freedesktop.DBus",
+					      "RequestName",
+					      g_variant_new ("(su)",
+							     "org.freedesktop.gnome.Magnifier",
+							     G_BUS_NAME_OWNER_FLAGS_NONE),
+					      G_VARIANT_TYPE ("(u)"),
+					      G_DBUS_CALL_FLAGS_NONE,
+					      -1, NULL, &error);
+	if (!result) {
+		g_warning ("Cannot register the magnifier: %s",
+			   error->message);
+		g_error_free (error);
+		g_object_unref (mag);
 
-GNOME_Magnifier_ZoomRegionList *
-impl_magnifier_get_zoom_regions (PortableServer_Servant servant,
-				 CORBA_Environment * ev)
-{
-	Magnifier *magnifier =
-		MAGNIFIER (bonobo_object_from_servant (servant));
-
-	GNOME_Magnifier_ZoomRegionList *list;
-	CORBA_Object objref;
-	int i, len;
-
-	len = g_list_length (magnifier->zoom_regions);
-	list = GNOME_Magnifier_ZoomRegionList__alloc ();
-	list->_length = len;
-	list->_buffer =
-		GNOME_Magnifier_ZoomRegionList_allocbuf (list->_length);
-	for (i = 0; i < len; ++i) {
-		objref = g_list_nth_data (magnifier->zoom_regions, i);
-		list->_buffer [i] =
-			CORBA_Object_duplicate (objref, ev);
+		return NULL;
 	}
-	CORBA_sequence_set_release (list, CORBA_TRUE);
-
-	DBG (fprintf (stderr, "Get zoom regions: \t%d\n", len));
-	
-	return list; 
-}
-
-static void
-impl_magnifier_clear_all_zoom_regions (PortableServer_Servant servant,
-				       CORBA_Environment * ev)
-{
-	Magnifier *magnifier = MAGNIFIER (bonobo_object_from_servant (servant));
-	fprintf (stderr, "Clear all zoom regions.\n");
-
-	g_list_foreach (magnifier->zoom_regions,
-			magnifier_unref_zoom_region, magnifier);
-	g_list_free (magnifier->zoom_regions);
-	magnifier->zoom_regions = NULL;
-	magnifier->zoom_regions_dbus = NULL;
-}
-
-static void
-impl_magnifier_dispose (PortableServer_Servant servant,
-			CORBA_Environment *ev)
-{
-	magnifier_do_dispose (
-		MAGNIFIER (bonobo_object_from_servant (servant)));
-}
 
-static void
-magnifier_class_init (MagnifierClass *klass)
-{
-        GObjectClass * object_class = (GObjectClass *) klass;
-        POA_GNOME_Magnifier_Magnifier__epv *epv = &klass->epv;
-	parent_class = g_type_class_peek (BONOBO_TYPE_OBJECT); /* needed by BONOBO_CALL_PARENT! */
-
-	object_class->dispose = magnifier_gobject_dispose;
-
-	epv->fullScreenCapable = impl_magnifier_full_screen_capable;
-	epv->hideCursor = impl_magnifier_hide_cursor;
-	epv->showCursor = impl_magnifier_show_cursor;
-	epv->supportColorblindFilters = impl_magnifier_support_colorblind_filters;
-        epv->_set_SourceDisplay = impl_magnifier_set_source_display;
-	epv->_set_TargetDisplay = impl_magnifier_set_target_display;
-        epv->_get_SourceDisplay = impl_magnifier_get_source_display;
-	epv->_get_TargetDisplay = impl_magnifier_get_target_display;
-	epv->getProperties = impl_magnifier_get_properties;
-	epv->getZoomRegions = impl_magnifier_get_zoom_regions;
-	epv->createZoomRegion = impl_magnifier_create_zoom_region;
-	epv->addZoomRegion = impl_magnifier_add_zoom_region;
-	epv->clearAllZoomRegions = impl_magnifier_clear_all_zoom_regions;
-	epv->dispose = impl_magnifier_dispose;
-}
-
-static void
-magnifier_properties_init (Magnifier *magnifier)
-{
-	BonoboArg *def;
-	GNOME_Magnifier_RectBounds rect_bounds;
-	gchar *display_env;
-
-	magnifier->property_bag =
-		bonobo_property_bag_new_closure (
-			g_cclosure_new_object (
-				G_CALLBACK (magnifier_get_property),
-				G_OBJECT (magnifier)),
-			g_cclosure_new_object (
-				G_CALLBACK (magnifier_set_property),
-				G_OBJECT (magnifier)));
-	/* Aggregate so magnifier implements Bonobo_PropertyBag */
-	bonobo_object_add_interface (BONOBO_OBJECT (magnifier),
-				     BONOBO_OBJECT (magnifier->property_bag));
-
-	def = bonobo_arg_new (BONOBO_ARG_STRING);
-	display_env = getenv ("DISPLAY");
-	BONOBO_ARG_SET_STRING (def, display_env);
-
-	bonobo_property_bag_add (magnifier->property_bag,
-				 "source-display-screen",
-				 MAGNIFIER_SOURCE_DISPLAY_PROP,
-				 BONOBO_ARG_STRING,
-				 def,
-				 "source display screen",
-				 Bonobo_PROPERTY_WRITEABLE);
-
-	bonobo_property_bag_add (magnifier->property_bag,
-				 "target-display-screen",
-				 MAGNIFIER_TARGET_DISPLAY_PROP,
-				 BONOBO_ARG_STRING,
-				 def,
-				 "target display screen",
-				 Bonobo_PROPERTY_WRITEABLE);
-
-	bonobo_arg_release (def);
+	g_variant_get (result, "(u)", &request_name_reply);
+	g_variant_unref (result);
 
-	magnifier_init_display (magnifier, display_env, TRUE);
-	magnifier_init_display (magnifier, display_env, FALSE);
-
-	magnifier_get_display_rect_bounds (magnifier, &rect_bounds, FALSE);
-	def = bonobo_arg_new_from (TC_GNOME_Magnifier_RectBounds, &rect_bounds);
-        
-	bonobo_property_bag_add (magnifier->property_bag,
-				 "source-display-bounds",
-				 MAGNIFIER_SOURCE_SIZE_PROP,
-				 TC_GNOME_Magnifier_RectBounds,
-				 def,
-				 "source display bounds/size",
-				 Bonobo_PROPERTY_READABLE |
-				 Bonobo_PROPERTY_WRITEABLE);
-	bonobo_arg_release (def);
-	
-	magnifier_get_display_rect_bounds (magnifier, &rect_bounds, TRUE);
-	def = bonobo_arg_new_from (TC_GNOME_Magnifier_RectBounds, &rect_bounds);
-
-	bonobo_property_bag_add (magnifier->property_bag,
-				 "target-display-bounds",
-				 MAGNIFIER_TARGET_SIZE_PROP,
-				 TC_GNOME_Magnifier_RectBounds,
-				 def,
-				 "target display bounds/size",
-				 Bonobo_PROPERTY_READABLE |
-				 Bonobo_PROPERTY_WRITEABLE);
-	bonobo_arg_release (def);
-
-	bonobo_property_bag_add (magnifier->property_bag,
-				 "cursor-set",
-				 MAGNIFIER_CURSOR_SET_PROP,
-				 BONOBO_ARG_STRING,
-				 NULL,
-				 "name of cursor set",
-				 Bonobo_PROPERTY_READABLE |
-				 Bonobo_PROPERTY_WRITEABLE);
-
-	def = bonobo_arg_new (BONOBO_ARG_INT);
-	BONOBO_ARG_SET_INT (def, 64);
-	
-	bonobo_property_bag_add (magnifier->property_bag,
-				 "cursor-size",
-				 MAGNIFIER_CURSOR_SIZE_PROP,
-				 BONOBO_ARG_INT,
-				 def,
-				 "cursor size, in pixels",
-				 Bonobo_PROPERTY_READABLE |
-				 Bonobo_PROPERTY_WRITEABLE);
-	bonobo_arg_release (def);
-	
-	bonobo_property_bag_add (magnifier->property_bag,
-				 "cursor-scale-factor",
-				 MAGNIFIER_CURSOR_ZOOM_PROP,
-				 BONOBO_ARG_FLOAT,
-				 NULL,
-				 "scale factor for cursors (overrides size)",
-				 Bonobo_PROPERTY_READABLE |
-				 Bonobo_PROPERTY_WRITEABLE);
-	
-	bonobo_property_bag_add (magnifier->property_bag,
-				 "cursor-color",
-				 MAGNIFIER_CURSOR_COLOR_PROP,
-				 TC_CORBA_unsigned_long,
-				 NULL,
-				 "foreground color for 1-bit cursors, as ARGB",
-				 Bonobo_PROPERTY_READABLE |
-				 Bonobo_PROPERTY_WRITEABLE);	
-
-	bonobo_property_bag_add (magnifier->property_bag,
-				 "cursor-hotspot",
-				 MAGNIFIER_CURSOR_HOTSPOT_PROP,
-				 TC_GNOME_Magnifier_Point,
-				 NULL,
-				 "hotspot relative to cursor's upper-left-corner, at default resolition",
-				 Bonobo_PROPERTY_READABLE |
-				 Bonobo_PROPERTY_WRITEABLE);
-	
-	bonobo_property_bag_add (magnifier->property_bag,
-				 "cursor-default-size",
-				 MAGNIFIER_CURSOR_DEFAULT_SIZE_PROP,
-				 BONOBO_ARG_INT,
-				 NULL,
-				 "default size of current cursor set",
-				 Bonobo_PROPERTY_READABLE);
-
-	bonobo_property_bag_add (magnifier->property_bag,
-				 "crosswire-size",
-				 MAGNIFIER_CROSSWIRE_SIZE_PROP,
-				 BONOBO_ARG_INT,
-				 NULL,
-				 "thickness of crosswire cursor, in target pixels",
-				 Bonobo_PROPERTY_READABLE |
-				 Bonobo_PROPERTY_WRITEABLE);
-
-	bonobo_property_bag_add (magnifier->property_bag,
-				 "crosswire-length",
-				 MAGNIFIER_CROSSWIRE_LENGTH_PROP,
-				 BONOBO_ARG_INT,
-				 NULL,
-				 "length of crosswire cursor, in target pixels",
-				 Bonobo_PROPERTY_READABLE |
-				 Bonobo_PROPERTY_WRITEABLE);
-	
-	bonobo_property_bag_add (magnifier->property_bag,
-				 "crosswire-color",
-				 MAGNIFIER_CROSSWIRE_COLOR_PROP,
-				 BONOBO_ARG_LONG,
-				 NULL,
-				 "color of crosswire, as A-RGB; note that alpha is required. (use 0 for XOR wire)",
-				 Bonobo_PROPERTY_READABLE |
-				 Bonobo_PROPERTY_WRITEABLE);
-
-	bonobo_property_bag_add (magnifier->property_bag,
-				 "crosswire-clip",
-				 MAGNIFIER_CROSSWIRE_CLIP_PROP,
-				 BONOBO_ARG_BOOLEAN,
-				 NULL,
-				 "whether to inset the cursor over the crosswire or not",
-				 Bonobo_PROPERTY_READABLE |
-				 Bonobo_PROPERTY_WRITEABLE);
-}
-
-static void
-magnifier_init_window (Magnifier *magnifier, GdkScreen *screen)
-{
-	GtkWindowType mag_win_type = GTK_WINDOW_TOPLEVEL;
-	if (_is_override_redirect || gmag_gs_use_compositor (magnifier))
-		mag_win_type = GTK_WINDOW_POPUP;
-
-	magnifier->priv->w =
-		g_object_connect (gtk_widget_new (gtk_window_get_type (),
-						  "user_data", NULL,
-						  "can_focus", FALSE,
-						  "type", mag_win_type,  
-						  "title", "magnifier",
-						  "allow_grow", TRUE,
-						  "allow_shrink", TRUE,
-						  "border_width", 0,
-						  NULL),
-				  "signal::realize", magnifier_realize, NULL,
-				  "signal::size_allocate", magnifier_size_allocate, NULL,
-				  "signal::destroy", magnifier_exit, NULL,
-				  NULL);
-	gtk_window_set_screen (GTK_WINDOW (magnifier->priv->w), screen);
-	magnifier->priv->canvas = gtk_fixed_new ();
-	gtk_container_add (GTK_CONTAINER (magnifier->priv->w),
-			   magnifier->priv->canvas);
-	magnifier->priv->root = NULL;
-}
-
-static void
-magnifier_init (Magnifier *magnifier)
-{
-	magnifier->priv = g_new0 (MagnifierPrivate, 1);
-	magnifier_properties_init (magnifier);
-	magnifier->zoom_regions = NULL;
-	magnifier->zoom_regions_dbus = NULL;
-	magnifier->source_screen_num = 0;
-	magnifier->target_screen_num = 0;
-	magnifier->source_display_name = g_strdup (":0.0");
-	magnifier->target_display_name = g_strdup (":0.0");
-	magnifier->cursor_size_x = 0;
-	magnifier->cursor_size_y = 0;
-	magnifier->cursor_scale_factor = 1.0F;
-	magnifier->cursor_color = 0xFF000000;
-	magnifier->crosswire_size = 1;
-	magnifier->crosswire_length = 0;
-	magnifier->crosswire_color = 0;
-	magnifier->crosswire_clip = FALSE;
-	magnifier->cursor_hotspot.x = 0;
-	magnifier->cursor_hotspot.y = 0;
-	magnifier->target_bounds.x1 = 0;
-	magnifier->target_bounds.y1 = 0;
-	magnifier->target_bounds.x2 = 0;
-	magnifier->target_bounds.y2 = 0;
-	magnifier->priv->cursor = NULL;
-	magnifier->priv->w = NULL;
-	magnifier->priv->use_source_cursor = TRUE;
-	magnifier->priv->cursorlist = NULL;
-	magnifier->priv->source_drawable = NULL;
-	magnifier->priv->overlay = NULL;
-	magnifier_init_window (magnifier, 
-			       gdk_display_get_screen (magnifier->target_display, 
-						       magnifier->target_screen_num));
-	magnifier_init_cursor_set (magnifier, "default");
+	switch (request_name_reply) {
+	case 1: /* DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER */
+	case 4: /* DBUS_REQUEST_NAME_REPLY_ALREADY_OWNER */
+		introspection_data = g_dbus_node_info_new_for_xml (introspection_xml, &error);
+		if (!introspection_data) {
+			g_warning ("%s", error->message);
+		} else {
+		mag->priv->dbus_object_id =
+			g_dbus_connection_register_object (dbus_connection,
+							   "/org/freedesktop/gnome/Magnifier",
+							   introspection_data->interfaces[0],
+							   &interface_vtable,
+							   mag, NULL,
+							   &error);
+		if (error) {
+			g_printerr ("Failed to register magnifier object: %s\n", error->message);
+			g_error_free (error);
+			g_object_unref (mag);
+
+			return NULL;
+		}
+		}
+		break;
+	case 2: /* DBUS_REQUEST_NAME_REPLY_IN_QUEUE */
+	case 3: /* DBUS_REQUEST_NAME_REPLY_EXISTS */
+		printf("An instance of magnifier is already active. Exiting Program.\n");
+		exit (0);
+		break;
+	default:
+		g_warning ("Cannot register the magnifier: unhandled "
+			   "reply %u from RequestName", request_name_reply);
+	}
 
-	mag_timing.process = g_timer_new ();
-	mag_timing.frame = g_timer_new ();
-	mag_timing.scale = g_timer_new ();
-	mag_timing.idle = g_timer_new ();
-#ifdef DEBUG_CLIENT_CALLS
-	client_debug = (g_getenv ("MAG_CLIENT_DEBUG") != NULL);
-#endif
+	g_timeout_add (500, magnifier_reset_struts_at_idle, mag);
+	g_timeout_add (500, gmag_gs_reset_overlay_at_idle, mag);
 
-	zoom_hash = g_hash_table_new (g_str_hash, g_str_equal);
+	return mag;
 }
 
 GdkDrawable *
@@ -2321,72 +1762,3 @@ magnifier_get_cursor (Magnifier *magnifier)
         }
 	return magnifier->priv->cursor;
 }
-
-Magnifier *
-magnifier_new (gboolean override_redirect)
-{
-	Magnifier *mag;
-	MagLoginHelper *helper;
-	GError *error = NULL;
-	MagnifierClass *klass = NULL;
-	DBusGProxy *driver_proxy;
-	guint request_req;
-	int ret;
-
-	_is_override_redirect = override_redirect;
-
-	mag = g_object_new (magnifier_get_type(), NULL);
-
-	_this_magnifier = mag; /* FIXME what about multiple instances? */
-
-	helper = g_object_new (mag_login_helper_get_type (), NULL);
-	mag_login_helper_set_magnifier (helper, mag);
-
-	bonobo_object_add_interface (bonobo_object (mag), 
-				     BONOBO_OBJECT (helper));
-	
-	ret = bonobo_activation_active_server_register (
-		MAGNIFIER_OAFIID, BONOBO_OBJREF (mag));
-	if (ret != Bonobo_ACTIVATION_REG_SUCCESS) {
-	    if ( ret == Bonobo_ACTIVATION_REG_ALREADY_ACTIVE)
-	    {
-		printf("An instance of magnifier is already active. Exiting Program.\n");
-		exit(0);
-	    } else
-		g_error ("Error registering magnifier server.\n");
-	}
-	
-	klass = MAGNIFIER_GET_CLASS (mag);
-	
-	klass->connection = dbus_g_bus_get (DBUS_BUS_SESSION, &error);
-	if (klass->connection == NULL) {
-		g_warning ("Unable to connect to dbus: %s", error->message);
-		g_error_free (error);
-		return NULL;
-	}
-	
-	dbus_g_object_type_install_info (MAGNIFIER_TYPE, &dbus_glib_impl_dbus_magnifier_object_info);
-	
-	dbus_g_connection_register_g_object (klass->connection, "/org/freedesktop/gnome/Magnifier",
-					     G_OBJECT (_this_magnifier));
-	
-	driver_proxy = dbus_g_proxy_new_for_name (klass->connection, DBUS_SERVICE_DBUS, DBUS_PATH_DBUS,
-						  DBUS_INTERFACE_DBUS);
-						  
-	if (!org_freedesktop_DBus_request_name (driver_proxy, "org.freedesktop.gnome.Magnifier", 0, &request_req,
-						&error)) {
-		g_warning ("Unable to register service: %s", error->message);
-		g_error_free (error);					
-	}
-
-	g_timeout_add (500, magnifier_reset_struts_at_idle, mag);
-	g_timeout_add (500, gmag_gs_reset_overlay_at_idle, mag);
-	
-	return mag;
-}
-
-BONOBO_TYPE_FUNC_FULL (Magnifier, 
-		       GNOME_Magnifier_Magnifier,
-		       BONOBO_TYPE_OBJECT,
-		       magnifier)
-
diff --git a/magnifier/magnifier.h b/magnifier/magnifier.h
index 8aab945..905ffc7 100644
--- a/magnifier/magnifier.h
+++ b/magnifier/magnifier.h
@@ -23,22 +23,15 @@
 #ifndef MAGNIFIER_H_
 #define MAGNIFIER_H_
 
-#ifdef __cplusplus
-extern "C" {
-#endif /* __cplusplus */
-
-#include "GNOME_Magnifier.h"
-
 #include <glib.h>
+#include <glib-object.h>
 
+#include <gtk/gtk.h>
 #include <gdk/gdk.h>
 
-#include <bonobo/bonobo-object.h>
-#include <bonobo/bonobo-property-bag.h>
-
-#include <login-helper/login-helper.h>
+#include "zoom-region.h"
 
-#include <dbus/dbus-glib.h>
+G_BEGIN_DECLS
 
 #define MAGNIFIER_TYPE         (magnifier_get_type ())
 #define MAGNIFIER(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), MAGNIFIER_TYPE, Magnifier))
@@ -47,25 +40,10 @@ extern "C" {
 #define IS_MAGNIFIER_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), MAGNIFIER_TYPE))
 #define MAGNIFIER_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), MAGNIFIER_TYPE, MagnifierClass))
 
-#define MAGNIFIER_OAFIID "OAFIID:GNOME_Magnifier_Magnifier:0.9"
-
 typedef struct _MagnifierPrivate MagnifierPrivate;
 
 typedef struct {
-	gint32 x1;
-	gint32 y1;
-	gint32 x2;
-	gint32 y2;
-} RectBounds;
-
-typedef struct {
-	gint32 x;
-	gint32 y;
-} Point;
-
-typedef struct {
-        BonoboObject       parent;
-        BonoboPropertyBag *property_bag;
+	GtkWindow          parent;
 	GdkDisplay        *source_display;
 	GdkDisplay        *target_display;
 	gchar             *source_display_name;
@@ -73,7 +51,6 @@ typedef struct {
 	int                source_screen_num;
 	int                target_screen_num;
 	GList             *zoom_regions;
-	GList		  *zoom_regions_dbus;
         gboolean           source_initialized;
 	gint               crosswire_size;
 	gint               crosswire_length;
@@ -84,16 +61,14 @@ typedef struct {
 	gint               cursor_size_y;
 	guint32            cursor_color;
 	float              cursor_scale_factor;
-	GNOME_Magnifier_RectBounds source_bounds;
-	GNOME_Magnifier_RectBounds target_bounds;
-	GNOME_Magnifier_Point	   cursor_hotspot;
+	RectBounds         source_bounds;
+	RectBounds         target_bounds;
+	Point	           cursor_hotspot;
 	MagnifierPrivate  *priv;
 } Magnifier;
 
 typedef struct {
-        BonoboObjectClass                   parent_class;
-        POA_GNOME_Magnifier_Magnifier__epv  epv;
-        DBusGConnection                    *connection;
+        GtkWindowClass parent_class;
 } MagnifierClass;
 
 /*
@@ -172,9 +147,18 @@ typedef struct timing {
 TimingStruct mag_timing;
 
 GdkDrawable *magnifier_get_cursor    (Magnifier *magnifier);
-GType        magnifier_get_type      (void);
+GType        magnifier_get_type      (void) G_GNUC_CONST;
 GdkWindow   *magnifier_get_root      (Magnifier *magnifier);
-Magnifier   *magnifier_new           (gboolean override_redirect);
+Magnifier   *magnifier_new           (gboolean     override_redirect,
+				      const gchar *source_display_name,
+				      const gchar *target_display_name);
+ZoomRegion *magnifier_create_zoom_region (Magnifier  *magnifier,
+					  gdouble     zx,
+					  gdouble     zy,
+					  RectBounds *roi,
+					  RectBounds *viewport);
+void         magnifier_add_zoom_region (Magnifier  *magnifier,
+					ZoomRegion *zoom_region);
 void         magnifier_notify_damage (Magnifier *magnifier,
 				      GdkRectangle *rect);
 void         magnifier_set_cursor_from_pixbuf (Magnifier *magnifier,
@@ -186,47 +170,6 @@ void         magnifier_transform_cursor (Magnifier *magnifier);
 void         magnifier_zoom_regions_update_pointer (Magnifier *magnifier);
 gboolean     magnifier_full_screen_capable (Magnifier *magnifier);
 
-/* D-BUS methods */
-gboolean	impl_dbus_magnifier_full_screen_capable (Magnifier *magnifier);
-gboolean	impl_dbus_magnifier_hide_cursor (Magnifier *magnifier);
-gboolean	impl_dbus_magnifier_show_cursor (Magnifier *magnifier);
-gboolean	impl_dbus_magnifier_support_colorblind_filters (Magnifier *magnifier);
-gchar*		impl_dbus_magnifier_create_zoom_region (Magnifier *magnifier, const double zx, const double zy,
-			const gint32 **roi, const gint32 **viewport);
-gchar**		impl_dbus_magnifier_get_zoom_regions (Magnifier *magnifier);
-gboolean	impl_dbus_magnifier_add_zoom_region (Magnifier *magnifier, gchar *zoom_region_path);
-gboolean	impl_dbus_magnifier_clear_all_zoom_regions (Magnifier *magnifier);
-gboolean	impl_dbus_magnifier_dispose (Magnifier *magnifier);
-gboolean	impl_dbus_magnifier_set_source_display (Magnifier *magnifier, gchar *source_display);
-gchar*		impl_dbus_magnifier_get_source_display (Magnifier *magnifier);
-gboolean	impl_dbus_magnifier_set_target_display (Magnifier *magnifier, gchar *target_display);
-gchar*		impl_dbus_magnifier_get_target_display (Magnifier *magnifier);
-gboolean	impl_dbus_magnifier_set_source_size (Magnifier *magnifier, gint32 **bounds);
-GArray*		impl_dbus_magnifier_get_source_size (Magnifier *magnifier);
-gboolean	impl_dbus_magnifier_set_target_size (Magnifier *magnifier, gint32 **bounds);
-GArray*		impl_dbus_magnifier_get_target_size (Magnifier *magnifier);
-gboolean	impl_dbus_magnifier_set_cursor_set (Magnifier *magnifier, gchar *cursor_set);
-gchar*		impl_dbus_magnifier_get_cursor_set (Magnifier *magnifier);
-gboolean	impl_dbus_magnifier_set_cursor_size (Magnifier *magnifier, gint x, gint y);
-GArray*		impl_dbus_magnifier_get_cursor_size (Magnifier *magnifier);
-gboolean	impl_dbus_magnifier_set_cursor_zoom (Magnifier *magnifier, double factor);
-double		impl_dbus_magnifier_get_cursor_zoom (Magnifier *magnifier);
-gboolean	impl_dbus_magnifier_set_cursor_color (Magnifier *magnifier, guint32 color);
-guint32		impl_dbus_magnifier_get_cursor_color (Magnifier *magnifier);
-gboolean	impl_dbus_magnifier_set_cursor_hotspot (Magnifier *magnifier, gint32 x, gint32 y);
-GArray*		impl_dbus_magnifier_get_cursor_hotspot (Magnifier *magnifier);
-gint32		impl_dbus_magnifier_get_cursor_default_size (Magnifier *magnifier);
-gboolean	impl_dbus_magnifier_set_crosswire_size (Magnifier *magnifier, gint size);
-gint		impl_dbus_magnifier_get_crosswire_size (Magnifier *magnifier);
-gboolean	impl_dbus_magnifier_set_crosswire_length (Magnifier *magnifier, gint length);
-gint		impl_dbus_magnifier_get_crosswire_length (Magnifier *magnifier);
-gboolean	impl_dbus_magnifier_set_crosswire_clip (Magnifier *magnifier, gboolean clip);
-gboolean	impl_dbus_magnifier_get_crosswire_clip (Magnifier *magnifier);
-gboolean	impl_dbus_magnifier_set_crosswire_color (Magnifier *magnifier, guint32 color);
-guint32		impl_dbus_magnifier_get_crosswire_color (Magnifier *magnifier);
-
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
+G_END_DECLS
 
 #endif /* MAGNIFIER_H_ */
diff --git a/magnifier/x11/gmag-graphical-server.c b/magnifier/x11/gmag-graphical-server.c
index a5c6c5f..c322557 100644
--- a/magnifier/x11/gmag-graphical-server.c
+++ b/magnifier/x11/gmag-graphical-server.c
@@ -153,24 +153,24 @@ gboolean
 gmag_gs_check_set_struts (Magnifier *magnifier)
 {
 #ifdef HAVE_COMPOSITE
-	if (gmag_gs_use_compositor (magnifier))
+	if (gmag_gs_use_compositor (magnifier->source_display_name, magnifier->target_display_name))
 		return TRUE;
 #endif
 
 #if GTK_CHECK_VERSION (2,19,5)
 	if (magnifier &&
-	    magnifier->priv && magnifier->priv->w && gtk_widget_get_realized (magnifier->priv->w) &&
-	    gtk_widget_get_window (magnifier->priv->w))
+	    gtk_widget_get_realized (GTK_WIDGET (magnifier)) &&
+	    gtk_widget_get_window (GTK_WIDGET (magnifier)))
 #else
 	if (magnifier &&
-	    magnifier->priv && magnifier->priv->w && GTK_WIDGET_REALIZED (magnifier->priv->w) &&
-	    gtk_widget_get_window (magnifier->priv->w))
+	    GTK_WIDGET_REALIZED (magnifier) &&
+	    gtk_widget_get_window (GTK_WIDGET (magnifier)))
 #endif
 	{
 		Atom atom_strut = gdk_x11_get_xatom_by_name ("_NET_WM_STRUT");
 		Atom atom_strut_partial = gdk_x11_get_xatom_by_name ("_NET_WM_STRUT_PARTIAL");
 		guint32 struts[12] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
-		GtkWidget *widget = magnifier->priv->w;
+		GtkWidget *widget = GTK_WIDGET (magnifier);
 		gint width = gdk_screen_get_width (
 			gdk_display_get_screen (magnifier->target_display,
 						magnifier->target_screen_num));
@@ -181,8 +181,8 @@ gmag_gs_check_set_struts (Magnifier *magnifier)
 		gint right_margin, left_margin, top_margin, bottom_margin;
 		gint wx, wy, ww, wh;
 
-		gtk_window_get_position (GTK_WINDOW (magnifier->priv->w), &wx, &wy);
-		gtk_window_get_size (GTK_WINDOW (magnifier->priv->w), &ww, &wh);
+		gtk_window_get_position (GTK_WINDOW (magnifier), &wx, &wy);
+		gtk_window_get_size (GTK_WINDOW (magnifier), &ww, &wh);
 
 		left_margin = wx;
 		right_margin = (width - ww) - wx;
@@ -254,36 +254,34 @@ gmag_gs_reset_overlay_at_idle (gpointer data)
 	if (data) {
 		Magnifier *magnifier = MAGNIFIER (data);
 #if GTK_CHECK_VERSION (2,19,5)
-		if (magnifier->priv && magnifier->priv->w &&
-		    gtk_widget_get_realized (magnifier->priv->w))
+		if (gtk_widget_get_realized (GTK_WIDGET (magnifier)))
 #else
-		if (magnifier->priv && magnifier->priv->w &&
-		    GTK_WIDGET_REALIZED (magnifier->priv->w))
+		if (GTK_WIDGET_REALIZED (magnifier))
 #endif
-			if (gtk_widget_get_window (magnifier->priv->w)) {
+			if (gtk_widget_get_window (GTK_WIDGET (magnifier))) {
 #ifdef HAVE_OVERLAY
 				gint      x, y, over_w, over_h;
 				if (!magnifier->priv->overlay) {
-					magnifier->priv->overlay = gdk_window_foreign_new (XCompositeGetOverlayWindow (GDK_WINDOW_XDISPLAY (gtk_widget_get_window (magnifier->priv->w)), GDK_WINDOW_XID (magnifier->priv->root)));
+					magnifier->priv->overlay = gdk_window_foreign_new (XCompositeGetOverlayWindow (GDK_WINDOW_XDISPLAY (gtk_widget_get_window (GTK_WIDGET (magnifier))), GDK_WINDOW_XID (magnifier->priv->root)));
 					gdk_window_get_position (
-						gtk_widget_get_window (magnifier->priv->w), &x,
+						gtk_widget_get_window (GTK_WIDGET (magnifier)), &x,
 						&y);
 					gdk_drawable_get_size (
-						gtk_widget_get_window (magnifier->priv->w),
+						gtk_widget_get_window (GTK_WIDGET (magnifier)),
 						&over_w, &over_h);
 					gdk_window_move_resize (
 						magnifier->priv->overlay, x, y,
 						over_w, over_h);
 					gdk_window_reparent (
-						gtk_widget_get_window (magnifier->priv->w),
+						gtk_widget_get_window (GTK_WIDGET (magnifier)),
 						magnifier->priv->overlay, 0, 0);
 				}
 #ifdef HAVE_SHAPEINPUT			
-				XShapeCombineRectangles (GDK_WINDOW_XDISPLAY (gtk_widget_get_window (magnifier->priv->w)), GDK_WINDOW_XID (magnifier->priv->overlay), ShapeInput, 0, 0, NULL, 0, ShapeSet, YXBanded);
+				XShapeCombineRectangles (GDK_WINDOW_XDISPLAY (gtk_widget_get_window (GTK_WIDGET (magnifier))), GDK_WINDOW_XID (magnifier->priv->overlay), ShapeInput, 0, 0, NULL, 0, ShapeSet, YXBanded);
 #endif /* HAVE_SHAPEINPUT */
 #else
 #ifdef HAVE_SHAPEINPUT
-				XShapeCombineRectangles (GDK_WINDOW_XDISPLAY (gtk_widget_get_window (magnifier->priv->w)), GDK_WINDOW_XID (gtk_widget_get_window (magnifier->priv->w)), ShapeInput, 0, 0, NULL, 0, ShapeSet, YXBanded);
+				XShapeCombineRectangles (GDK_WINDOW_XDISPLAY (gtk_widget_get_window (GTK_WIDGET (magnifier))), GDK_WINDOW_XID (gtk_widget_get_window (GTK_WIDGET (magnifier))), ShapeInput, 0, 0, NULL, 0, ShapeSet, YXBanded);
 #endif /* HAVE_SHAPEINPUT */
 #endif /* HAVE_OVERLAY */
 				return FALSE;
@@ -384,8 +382,8 @@ gmag_gs_events_handler (GIOChannel *source, GIOCondition condition,
 	if (magnifier->priv->overlay)
 		mag_window = GDK_WINDOW_XID (magnifier->priv->overlay);
 #else
-	if (magnifier->priv->w && gtk_widget_get_window (magnifier->priv->w))
-		mag_window = GDK_WINDOW_XID (gtk_widget_get_window (magnifier->priv->w));
+	if (gtk_widget_get_window (GTK_WIDGET (magnifier)))
+		mag_window = GDK_WINDOW_XID (gtk_widget_get_window (GTK_WIDGET (magnifier)));
 #endif /* HAVE_OVERLAY */
 
 	do
@@ -468,10 +466,11 @@ gmag_gs_use_damage ()
  * others.
  */
 gboolean
-gmag_gs_use_compositor (Magnifier *magnifier)
+gmag_gs_use_compositor (const gchar *source_display_name,
+			const gchar *target_display_name)
 {
 	if (dpy == NULL) {
-		dpy = XOpenDisplay (magnifier->source_display_name); 
+		dpy = XOpenDisplay (source_display_name);
 	}
 
 	if (!gmag_gs_use_damage ()) {
@@ -483,8 +482,8 @@ gmag_gs_use_compositor (Magnifier *magnifier)
 	/* if the source and target display are different we don't need the
 	 * composite extension. This is the case when using the dummy driver or
 	 * a dual head configuration */
-	if (strcmp (magnifier->source_display_name,
-		    magnifier->target_display_name) != 0)
+	if (strcmp (source_display_name,
+		    target_display_name) != 0)
 		return FALSE;
 
 	if (XQueryExtension (dpy, "Composite", &major, &event, &error) &&
@@ -546,7 +545,7 @@ gmag_gs_client_init (Magnifier *magnifier)
 	g_io_channel_unref (ioc); 
 
 	use_damage = gmag_gs_use_damage ();
-	use_compositor = gmag_gs_use_compositor (magnifier);
+	use_compositor = gmag_gs_use_compositor (magnifier->source_display_name, magnifier->target_display_name);
 
 	fixes_event_base = gmag_cursor_init (magnifier, dpy);
 
diff --git a/magnifier/x11/gmag-graphical-server.h b/magnifier/x11/gmag-graphical-server.h
index 2352574..d51bd70 100644
--- a/magnifier/x11/gmag-graphical-server.h
+++ b/magnifier/x11/gmag-graphical-server.h
@@ -43,7 +43,8 @@ void       gmag_gs_magnifier_realize (GtkWidget *widget);
 gboolean   gmag_gs_error_check (void);
 gboolean   gmag_gs_reset_overlay_at_idle (gpointer data);
 gboolean   gmag_gs_check_set_struts (Magnifier *magnifier);
-gboolean   gmag_gs_use_compositor (Magnifier *magnifier);
+gboolean   gmag_gs_use_compositor (const gchar *source_display_name,
+				   const gchar *target_display_name);
 void       gmag_gs_hide_cursor (Magnifier *magnifier);
 void       gmag_gs_show_cursor (Magnifier *magnifier);
 
diff --git a/magnifier/zoom-region-private.h b/magnifier/zoom-region-private.h
index 3a6d68a..d5ad435 100644
--- a/magnifier/zoom-region-private.h
+++ b/magnifier/zoom-region-private.h
@@ -24,16 +24,14 @@
 #define ZOOM_REGION_PRIVATE_H_
 
 
-#ifdef __cplusplus
-extern "C" {
-#endif /* __cplusplus */
+G_BEGIN_DECLS
 
 struct _ZoomRegionPrivate {
 	GList *q;
 	/* bounds of currently exposed region, in target pixmap coords */
-	GNOME_Magnifier_RectBounds exposed_bounds; 
+	RectBounds exposed_bounds;
 	/* bounds of valid ('gettable') source area, in source coords */
-	GNOME_Magnifier_RectBounds source_area;
+	RectBounds source_area;
 	gpointer parent;
 	GtkWidget *w;
 	GtkWidget *border;
@@ -53,10 +51,9 @@ struct _ZoomRegionPrivate {
         guint  update_pointer_id;
         guint  update_handler_id;
 	gboolean test;
+	guint dbus_object_id;
 };
 
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
+G_END_DECLS
 
 #endif /* ZOOM_REGION_PRIVATE_H_ */
diff --git a/magnifier/zoom-region.c b/magnifier/zoom-region.c
index 66df717..3bb5e7d 100644
--- a/magnifier/zoom-region.c
+++ b/magnifier/zoom-region.c
@@ -25,7 +25,6 @@
 
 #include <stdlib.h>
 #include <string.h>
-#include <popt.h>
 
 #ifdef HAVE_COLORBLIND
 #include <colorblind.h>
@@ -39,7 +38,6 @@
 #endif
 
 #include <gdk/gdkx.h>
-#include <libbonobo.h>
 #include <math.h>
 
 #undef ZOOM_REGION_DEBUG
@@ -48,7 +46,6 @@
 #include "zoom-region-private.h"
 #include "magnifier.h" /* needed to access parent data */
 #include "magnifier-private.h" /* needed to access parent data */
-#include "zoom-region-server.h"
 
 #define DEBUG_CLIENT_CALLS
 
@@ -59,9 +56,8 @@ static gboolean client_debug = FALSE;
 #define DBG(a) 
 #endif
 
-static GObjectClass *parent_class = NULL;
-
 enum {
+	PROP_0,
 	ZOOM_REGION_MANAGED_PROP,
 	ZOOM_REGION_POLL_MOUSE_PROP,
 	ZOOM_REGION_DRAW_CURSOR_PROP,
@@ -91,42 +87,7 @@ enum {
 	ZOOM_REGION_TIMING_OUTPUT_PROP,
 	ZOOM_REGION_TIMING_PAN_RATE_PROP,
 	ZOOM_REGION_EXIT_MAGNIFIER
-} PropIdx;
-
-#ifdef DEBUG_CLIENT_CALLS
-gchar* prop_names[ZOOM_REGION_EXIT_MAGNIFIER + 1] = 
-{
-	"MANAGED",
-	"POLLMOUSE",
-	"DRAWCURSOR",
-	"SMOOTHSCROLL",
-	"COLORBLIND",
-	"INVERT",
-	"SMOOTHING",
-	"CONTRASTR",
-	"CONTRASTG",
-	"CONTRASTB",
-	"BRIGHTR",
-	"BRIGHTG",
-	"BRIGHTB",
-	"XSCALE",
-	"YSCALE",
-	"BORDERSIZE",
-	"BORDERSIZETOP",
-	"BORDERSIZELEFT",
-	"BORDERSIZERIGHT",
-	"BORDERSIZEBOTTOM",
-	"BORDERCOLOR",
-	"XALIGN",
-	"YALIGN",
-	"VIEWPORT",
-	"TESTPATTERN",
-	"TIMING_TEST",
-	"TIMING_OUTPUT",
-	"TIMING_PAN_RATE",
-	"EXIT_MAGNIFIER"
 };
-#endif
 
 typedef enum {
 	ZOOM_REGION_ERROR_NONE,
@@ -151,6 +112,8 @@ static gboolean can_coalesce = TRUE ; /* change this when event coalescing is wo
 
 static int zoom_region_number = 0;
 
+static GDBusConnection *dbus_connection = NULL;
+
 #define CLAMP_B_C(v) (t = (v), CLAMP (t, -1, 1));
 
 static void zoom_region_sync (ZoomRegion *region);
@@ -163,14 +126,23 @@ static void zoom_region_queue_update (ZoomRegion *zoom_region,
 static int  zoom_region_process_updates (gpointer data);
 static void zoom_region_paint (ZoomRegion *zoom_region, GdkRectangle *rect);
 static void zoom_region_paint_pixmap (ZoomRegion *zoom_region, GdkRectangle *rect);
+static gboolean zoom_region_update_pointer (ZoomRegion *zoom_region, gboolean draw_cursor);
 static int  zoom_region_update_pointer_timeout (gpointer data);
 static GdkRectangle zoom_region_rect_from_bounds (ZoomRegion *zoom_region,
-						  const GNOME_Magnifier_RectBounds *bounds);
+						  const RectBounds *bounds);
 static ZoomRegionPixmapCreationError zoom_region_create_pixmap (ZoomRegion *zoom_region);
 static GdkRectangle zoom_region_update_pixmap (ZoomRegion *zoom_region, const GdkRectangle update_rect, GdkRectangle *paint_rect);
 static void zoom_region_get_move_x_y (ZoomRegion *zoom_region, long *x, long *y);
 static void zoom_region_recompute_exposed_bounds (ZoomRegion *zoom_region);
 static void zoom_region_update_current (ZoomRegion *zoom_region);
+static int zoom_region_pan_test (gpointer data);
+static int zoom_region_process_pending (gpointer data);
+static void zoom_region_do_dispose (ZoomRegion *zoom_region);
+
+#define ZOOM_REGION_GET_PRIVATE(object) \
+	(G_TYPE_INSTANCE_GET_PRIVATE ((object), ZOOM_REGION_TYPE, ZoomRegionPrivate))
+
+G_DEFINE_TYPE (ZoomRegion, zoom_region, GTK_TYPE_DRAWING_AREA)
 
 void
 reset_timing_stats()
@@ -548,7 +520,7 @@ _rectangle_clip_to_rectangle (GdkRectangle area,
 
 static GdkRectangle
 _rectangle_clip_to_bounds (GdkRectangle area,
-			   GNOME_Magnifier_RectBounds *clip_bounds)
+			   RectBounds *clip_bounds)
 {
 	area.x = MAX (area.x, clip_bounds->x1);
 	area.x = MIN (area.x, clip_bounds->x2);
@@ -563,7 +535,7 @@ static GdkRectangle
 zoom_region_clip_to_source (ZoomRegion *zoom_region,
 			    GdkRectangle area)
 {
-    GNOME_Magnifier_RectBounds *source_rect_ptr;
+    RectBounds *source_rect_ptr;
     if (zoom_region && zoom_region->priv && zoom_region->priv->parent)
     {
 	source_rect_ptr = &((Magnifier *)zoom_region->priv->parent)->source_bounds;
@@ -577,7 +549,7 @@ static GdkRectangle
 zoom_region_clip_to_exposed_target (ZoomRegion *zoom_region,
 				    GdkRectangle area)
 {
-	GNOME_Magnifier_RectBounds onscreen_target, *source_area;
+	RectBounds onscreen_target, *source_area;
 	source_area = &zoom_region->priv->source_area;
 
 	onscreen_target.x1 = MAX (floor (zoom_region->priv->exposed_bounds.x1
@@ -620,8 +592,8 @@ zoom_region_clip_to_window (ZoomRegion *zoom_region,
 
 	return area;
 
-	if (gtk_widget_get_window (zoom_region->priv->w))
-		gdk_drawable_get_size (GDK_DRAWABLE (gtk_widget_get_window (zoom_region->priv->w)),
+	if (gtk_widget_get_window (GTK_WIDGET (zoom_region)))
+		gdk_drawable_get_size (GDK_DRAWABLE (gtk_widget_get_window (GTK_WIDGET (zoom_region))),
 				       &window_rect.x,
 				       &window_rect.y);
 	else 
@@ -634,7 +606,7 @@ zoom_region_clip_to_window (ZoomRegion *zoom_region,
 
 static GdkRectangle
 zoom_region_source_rect_from_view_bounds (ZoomRegion *zoom_region,
-					  const GNOME_Magnifier_RectBounds *view_bounds)
+					  const RectBounds *view_bounds)
 {
 	GdkRectangle source_rect;
 	source_rect.x = floor ((view_bounds->x1 + zoom_region->priv->exposed_bounds.x1)
@@ -676,7 +648,7 @@ zoom_region_source_rect_from_view_rect (ZoomRegion *zoom_region,
 
 static GdkRectangle
 zoom_region_rect_from_bounds (ZoomRegion *zoom_region,
-			      const GNOME_Magnifier_RectBounds *bounds)
+			      const RectBounds *bounds)
 {
 	GdkRectangle rect;
 	rect.x = bounds->x1;
@@ -686,9 +658,7 @@ zoom_region_rect_from_bounds (ZoomRegion *zoom_region,
 	return rect;
 }
 
-/** **************  **/
-
-static CORBA_boolean
+static gboolean
 zoom_region_update_scale (ZoomRegion *zoom_region, gdouble x, gdouble y)
 {
 	gdouble x_old = zoom_region->xscale;
@@ -838,13 +808,13 @@ zoom_region_paint_crosswire_cursor (ZoomRegion *zoom_region, GdkRectangle *clip_
 	g_assert (zoom_region->alive);
 #endif
 	if (!(magnifier &&
-	      gtk_widget_get_window (zoom_region->priv->w) &&
-	      GDK_IS_DRAWABLE (gtk_widget_get_window (zoom_region->priv->w)) &&
+	      gtk_widget_get_window (GTK_WIDGET (zoom_region)) &&
+	      GDK_IS_DRAWABLE (gtk_widget_get_window (GTK_WIDGET (zoom_region))) &&
 	      magnifier->crosswire_size > 0)) return;
 
 	if (zoom_region->priv->crosswire_gc == NULL) 
 	{
-		zoom_region->priv->crosswire_gc = gdk_gc_new (gtk_widget_get_window (zoom_region->priv->w));
+		zoom_region->priv->crosswire_gc = gdk_gc_new (gtk_widget_get_window (GTK_WIDGET (zoom_region)));
 		cmap = gdk_gc_get_colormap(zoom_region->priv->crosswire_gc);
 		last_color_init = FALSE;
 	}
@@ -934,32 +904,32 @@ zoom_region_paint_crosswire_cursor (ZoomRegion *zoom_region, GdkRectangle *clip_
 	}
 	if (magnifier->crosswire_size == 1) {
 		if (magnifier->crosswire_clip) {
-			gdk_draw_line (gtk_widget_get_window (zoom_region->priv->w),
+			gdk_draw_line (gtk_widget_get_window (GTK_WIDGET (zoom_region)),
 				       zoom_region->priv->crosswire_gc,
 				       rect.x, y_top_clip, rect.x,
 				       y_bottom_clip);
-			gdk_draw_line (gtk_widget_get_window (zoom_region->priv->w),
+			gdk_draw_line (gtk_widget_get_window (GTK_WIDGET (zoom_region)),
 				       zoom_region->priv->crosswire_gc,
 				       x_left_clip, rect.y, x_right_clip,
 				       rect.y);
 		}
-		gdk_draw_line (gtk_widget_get_window (zoom_region->priv->w),
+		gdk_draw_line (gtk_widget_get_window (GTK_WIDGET (zoom_region)),
 			       zoom_region->priv->crosswire_gc,
 			       rect.x, y_start, rect.x, y_end);
-		gdk_draw_line (gtk_widget_get_window (zoom_region->priv->w),
+		gdk_draw_line (gtk_widget_get_window (GTK_WIDGET (zoom_region)),
 			       zoom_region->priv->crosswire_gc,
 			       x_start, rect.y, x_end, rect.y);
 	}
 	else {
 		if (magnifier->crosswire_clip ) {
 			gdk_draw_rectangle (
-				gtk_widget_get_window (zoom_region->priv->w),
+				gtk_widget_get_window (GTK_WIDGET (zoom_region)),
 				zoom_region->priv->crosswire_gc, TRUE,
 				rect.x - magnifier->crosswire_size / 2,
 				y_top_clip, magnifier->crosswire_size,
 				y_bottom_clip - y_top_clip);
 			gdk_draw_rectangle (
-				gtk_widget_get_window (zoom_region->priv->w),
+				gtk_widget_get_window (GTK_WIDGET (zoom_region)),
 				zoom_region->priv->crosswire_gc, TRUE,
 				x_left_clip,
 				rect.y - magnifier->crosswire_size / 2,
@@ -967,12 +937,12 @@ zoom_region_paint_crosswire_cursor (ZoomRegion *zoom_region, GdkRectangle *clip_
 				magnifier->crosswire_size);
 		}
 		gdk_draw_rectangle (
-			gtk_widget_get_window (zoom_region->priv->w),
+			gtk_widget_get_window (GTK_WIDGET (zoom_region)),
 			zoom_region->priv->crosswire_gc, TRUE,
 			rect.x - magnifier->crosswire_size / 2, y_start,
 			magnifier->crosswire_size, y_end - y_start);
 		gdk_draw_rectangle (
-			gtk_widget_get_window (zoom_region->priv->w),
+			gtk_widget_get_window (GTK_WIDGET (zoom_region)),
 			zoom_region->priv->crosswire_gc, TRUE,
 			x_start, rect.y - magnifier->crosswire_size / 2,
 			x_end - x_start, magnifier->crosswire_size);
@@ -1034,18 +1004,18 @@ zoom_region_paint_cursor (ZoomRegion *zoom_region,
 				g_object_unref (zoom_region->priv->cursor_backing_pixels);
 			}
 			zoom_region->priv->cursor_backing_pixels =
-				gdk_pixmap_new (gtk_widget_get_window (zoom_region->priv->w),
+				gdk_pixmap_new (gtk_widget_get_window (GTK_WIDGET (zoom_region)),
 						rect.width,
 						rect.height,
 						-1);
 		}
-		if (gtk_widget_get_window (zoom_region->priv->w) != NULL)
+		if (gtk_widget_get_window (GTK_WIDGET (zoom_region)) != NULL)
 		{
 			if (zoom_region->priv->default_gc == NULL) 
-				zoom_region->priv->default_gc = gdk_gc_new(gtk_widget_get_window (zoom_region->priv->w));
+				zoom_region->priv->default_gc = gdk_gc_new(gtk_widget_get_window (GTK_WIDGET (zoom_region)));
 			gdk_draw_drawable (zoom_region->priv->cursor_backing_pixels,
 				     zoom_region->priv->default_gc,
-				     gtk_widget_get_window (zoom_region->priv->w),
+				     gtk_widget_get_window (GTK_WIDGET (zoom_region)),
 				     rect.x,
 				     rect.y,
 				     0, 0,
@@ -1053,10 +1023,10 @@ zoom_region_paint_cursor (ZoomRegion *zoom_region,
 				     rect.height);
 		}
 		DEBUG_RECT ("painting", rect);
-		if (cursor && zoom_region->priv->w && GDK_IS_DRAWABLE (gtk_widget_get_window (zoom_region->priv->w)))
+		if (cursor && GDK_IS_DRAWABLE (gtk_widget_get_window (GTK_WIDGET (zoom_region))))
 		{
 		    if (zoom_region->priv->paint_cursor_gc == NULL)
-				zoom_region->priv->paint_cursor_gc = gdk_gc_new (gtk_widget_get_window (zoom_region->priv->w));
+			    zoom_region->priv->paint_cursor_gc = gdk_gc_new (gtk_widget_get_window (GTK_WIDGET (zoom_region)));
 
 			gdk_gc_set_clip_rectangle (zoom_region->priv->paint_cursor_gc, clip_rect);
 			values.clip_x_origin = rect.x;
@@ -1065,12 +1035,12 @@ zoom_region_paint_cursor (ZoomRegion *zoom_region,
 			gdk_gc_set_values(zoom_region->priv->paint_cursor_gc, &values, GDK_GC_CLIP_X_ORIGIN |
 					  GDK_GC_CLIP_Y_ORIGIN  | GDK_GC_CLIP_MASK);
 
-			gdk_draw_rectangle (gtk_widget_get_window (zoom_region->priv->w),
+			gdk_draw_rectangle (gtk_widget_get_window (GTK_WIDGET (zoom_region)),
 					   zoom_region->priv->paint_cursor_gc,
 					   TRUE,
 					   rect.x, rect.y, rect.width, rect.height);
 
-			gdk_draw_drawable (gtk_widget_get_window (zoom_region->priv->w),
+			gdk_draw_drawable (gtk_widget_get_window (GTK_WIDGET (zoom_region)),
 					   zoom_region->priv->paint_cursor_gc,
 					   cursor,
 					   0, 0,
@@ -1163,15 +1133,14 @@ zoom_region_paint_pixmap (ZoomRegion *zoom_region,
 	g_assert (zoom_region->alive);
 #endif
 	g_assert (zoom_region->priv);
-	g_assert (zoom_region->priv->w);
 
-        if (!GDK_IS_DRAWABLE (gtk_widget_get_window (zoom_region->priv->w))) return;
+        if (!GDK_IS_DRAWABLE (gtk_widget_get_window (GTK_WIDGET (zoom_region)))) return;
 	if (zoom_region->priv->default_gc == NULL) 
-		zoom_region->priv->default_gc = gdk_gc_new (gtk_widget_get_window (zoom_region->priv->w));
+		zoom_region->priv->default_gc = gdk_gc_new (gtk_widget_get_window (GTK_WIDGET (zoom_region)));
 
-	if (zoom_region->priv->pixmap && GDK_IS_DRAWABLE (gtk_widget_get_window (zoom_region->priv->w)))
+	if (zoom_region->priv->pixmap && GDK_IS_DRAWABLE (gtk_widget_get_window (GTK_WIDGET (zoom_region))))
 	{
-		gdk_draw_drawable (gtk_widget_get_window (zoom_region->priv->w),
+		gdk_draw_drawable (gtk_widget_get_window (GTK_WIDGET (zoom_region)),
 				   zoom_region->priv->default_gc,
 				   zoom_region->priv->pixmap,
 				   area->x + zoom_region->priv->exposed_bounds.x1 - zoom_region->priv->source_area.x1 * zoom_region->xscale,
@@ -1208,7 +1177,7 @@ zoom_region_create_pixmap (ZoomRegion *zoom_region)
 #ifdef ZOOM_REGION_DEBUG
 	g_assert (zoom_region->alive);
 #endif
-	if (zoom_region->priv->w && GDK_IS_DRAWABLE (gtk_widget_get_window (zoom_region->priv->w)))
+	if (GDK_IS_DRAWABLE (gtk_widget_get_window (GTK_WIDGET (zoom_region))))
 	{
 		long width = (zoom_region->priv->source_area.x2 -
 			      zoom_region->priv->source_area.x1) * zoom_region->xscale;
@@ -1216,11 +1185,11 @@ zoom_region_create_pixmap (ZoomRegion *zoom_region)
 			       zoom_region->priv->source_area.y1) * zoom_region->yscale;
 		zoom_region->priv->pixmap =
 			gdk_pixmap_new (
-				gtk_widget_get_window (zoom_region->priv->w),
+				gtk_widget_get_window (GTK_WIDGET (zoom_region)),
 				width,
 				height,
 				gdk_drawable_get_depth (
-					gtk_widget_get_window (zoom_region->priv->w)));
+					gtk_widget_get_window (GTK_WIDGET (zoom_region))));
 
 		if (gmag_gs_error_check ()) {
 			zoom_region->priv->pixmap = NULL;
@@ -1238,38 +1207,7 @@ zoom_region_create_pixmap (ZoomRegion *zoom_region)
 	return ZOOM_REGION_ERROR_NO_TARGET_DRAWABLE;
 }
 
-static void
-zoom_region_expose_handler (GtkWindow * w,
-			    GdkEventExpose *event,
-			    gpointer data)
-{
-	ZoomRegion *zoom_region = data;
-	DEBUG_RECT ("expose", event->area);
-
-#ifdef ZOOM_REGION_DEBUG
-	g_assert (zoom_region->alive);
-#endif
-	if (zoom_region->priv->pixmap == NULL)
-	{
-	        ZoomRegionPixmapCreationError ret; 
-		/* TODO: scale down if this fails here */
-		while ((ret = zoom_region_create_pixmap (zoom_region)) ==
-		    ZOOM_REGION_ERROR_TOO_BIG) {
-			zoom_region->xscale -= 1.0;
-			zoom_region->yscale -= 1.0;
-			zoom_region->priv->pixmap = NULL;
-			g_warning ("Scale factor too big to fit in memory; shrinking.");
-		}
-		if (ret == ZOOM_REGION_ERROR_NO_TARGET_DRAWABLE) 
-			g_warning ("create-pixmap: no target drawable");
-		else
-			zoom_region_update_pixmap (zoom_region, event->area,
-						   NULL);
-	}
-	zoom_region_paint (zoom_region, &event->area);
-}
-
-static void
+void
 zoom_region_update_cursor (ZoomRegion *zoom_region, int dx, int dy,
 			   GdkRectangle *clip_rect)
 {
@@ -1284,10 +1222,23 @@ zoom_region_update_cursor (ZoomRegion *zoom_region, int dx, int dy,
 	zoom_region->priv->last_drawn_crosswire_pos.y += dy;
 	zoom_region_paint_cursor (zoom_region, clip_rect);
 	zoom_region_paint_crosswire_cursor (zoom_region, clip_rect);
-	if (GTK_IS_WIDGET (zoom_region->priv->w) &&
-	    GDK_IS_WINDOW (gtk_widget_get_window (zoom_region->priv->w)))
+	if (GTK_IS_WIDGET (zoom_region) &&
+	    GDK_IS_WINDOW (gtk_widget_get_window (GTK_WIDGET (zoom_region))))
 		gdk_display_sync (gdk_drawable_get_display (
-					  gtk_widget_get_window (zoom_region->priv->w)));
+					  gtk_widget_get_window (GTK_WIDGET (zoom_region))));
+}
+
+void
+zoom_region_mark_dirty (ZoomRegion *zoom_region, RectBounds *roi_dirty)
+{
+	DEBUG_RECT ("mark dirty", zoom_region_rect_from_bounds (
+			    zoom_region, roi_dirty) );
+
+	zoom_region_update_pointer (zoom_region, TRUE);
+	/* XXX ? should we clip here, or wait till process_updates? */
+	zoom_region_queue_update (zoom_region,
+	  zoom_region_clip_to_source (zoom_region,
+	      zoom_region_rect_from_bounds (zoom_region, roi_dirty)));
 }
 
 static gboolean
@@ -1306,9 +1257,9 @@ zoom_region_calculate_scroll_rects (ZoomRegion *zoom_region,
 #endif
 	rect.x = 0;
 	rect.y = 0;
-	if (zoom_region && zoom_region->priv->w &&
-	    gtk_widget_get_window (zoom_region->priv->w))
-		window = gtk_widget_get_window (zoom_region->priv->w);
+	if (zoom_region &&
+	    gtk_widget_get_window (GTK_WIDGET (zoom_region)))
+		window = gtk_widget_get_window (GTK_WIDGET (zoom_region));
 	else
 		retval = FALSE;
 	if (!window)
@@ -1355,8 +1306,8 @@ zoom_region_scroll_fast (ZoomRegion *zoom_region, int dx, int dy,
 #ifdef ZOOM_REGION_DEBUG
 	g_assert (zoom_region->alive);
 #endif
-	if (zoom_region->priv->w && gtk_widget_get_window (zoom_region->priv->w))
-		window = gtk_widget_get_window (zoom_region->priv->w);
+	if (gtk_widget_get_window (GTK_WIDGET (zoom_region)))
+		window = gtk_widget_get_window (GTK_WIDGET (zoom_region));
 	else {
 		processing_updates = FALSE;
 		return;
@@ -1369,7 +1320,7 @@ zoom_region_scroll_fast (ZoomRegion *zoom_region, int dx, int dy,
 	gdk_window_process_updates (window, FALSE);
 	/* sync reduces cursor flicker, but slows things down */
 	if (zoom_region->smooth_scroll_policy >
-	    GNOME_Magnifier_ZoomRegion_SCROLL_FASTEST)
+	    SCROLL_FASTEST)
 		gdk_display_sync (gdk_drawable_get_display (window)); 
 }
 
@@ -1385,8 +1336,8 @@ zoom_region_scroll_smooth (ZoomRegion *zoom_region, int dx, int dy,
 #ifdef ZOOM_REGION_DEBUG
 	g_assert (zoom_region->alive);
 #endif
-	if (zoom_region->priv->w && GDK_IS_DRAWABLE (gtk_widget_get_window (zoom_region->priv->w)))
-		window = gtk_widget_get_window (zoom_region->priv->w);
+	if (GDK_IS_DRAWABLE (gtk_widget_get_window (GTK_WIDGET (zoom_region))))
+		window = gtk_widget_get_window (GTK_WIDGET (zoom_region));
 	else
 		return;
 	window_rect.x = 0;
@@ -1437,7 +1388,7 @@ zoom_region_scroll (ZoomRegion *zoom_region, int dx, int dy)
 		zoom_region_update_pixmap (zoom_region, zoom_region_source_rect_from_view_rect (zoom_region, expose_rect_h), NULL);
 		zoom_region_update_pixmap (zoom_region, zoom_region_source_rect_from_view_rect (zoom_region, expose_rect_v), NULL);
 
-		if (zoom_region->smooth_scroll_policy > GNOME_Magnifier_ZoomRegion_SCROLL_FAST) {
+		if (zoom_region->smooth_scroll_policy > SCROLL_FAST) {
 			zoom_region_scroll_smooth (zoom_region, dx, dy,
 						   &scroll_rect,
 						   &expose_rect_h,
@@ -1607,44 +1558,44 @@ zoom_region_process_pixbuf (ZoomRegion *zoom_region, GdkPixbuf *pixbuf)
 
 #ifdef HAVE_COLORBLIND
  	if (zoom_region->color_blind_filter !=
- 	    GNOME_Magnifier_ZoomRegion_COLORBLIND_FILTER_T_NO_FILTER) {
+ 	    COLORBLIND_FILTER_T_NO_FILTER) {
  		color_blind_filter = TRUE;
  		cbr = colorblind_create ();
  		color = malloc (sizeof (COLORBLIND_XCOLOR));
  		switch (zoom_region->color_blind_filter) {
- 		case GNOME_Magnifier_ZoomRegion_COLORBLIND_FILTER_T_NO_FILTER:
+ 		case COLORBLIND_FILTER_T_NO_FILTER:
  			break; /* This entry is only to avoid a warning */
- 		case GNOME_Magnifier_ZoomRegion_COLORBLIND_FILTER_T_SELECTIVE_SATURATE_RED:
+ 		case COLORBLIND_FILTER_T_SELECTIVE_SATURATE_RED:
  			colorblind_set_filter_type (cbr, colorblind_filter_t_selective_saturate_red);
  			break;
- 		case GNOME_Magnifier_ZoomRegion_COLORBLIND_FILTER_T_SELECTIVE_SATURATE_GREEN:
+ 		case COLORBLIND_FILTER_T_SELECTIVE_SATURATE_GREEN:
  			colorblind_set_filter_type (cbr, colorblind_filter_t_selective_saturate_green);
  			break;
- 		case GNOME_Magnifier_ZoomRegion_COLORBLIND_FILTER_T_SELECTIVE_SATURATE_BLUE:
+ 		case COLORBLIND_FILTER_T_SELECTIVE_SATURATE_BLUE:
  			colorblind_set_filter_type (cbr, colorblind_filter_t_selective_saturate_blue);
  			break;
- 		case GNOME_Magnifier_ZoomRegion_COLORBLIND_FILTER_T_SELECTIVE_DESSATURATE_RED:
+ 		case COLORBLIND_FILTER_T_SELECTIVE_DESSATURATE_RED:
  			colorblind_set_filter_type (cbr, colorblind_filter_t_selective_dessaturate_red);
  			break;
- 		case GNOME_Magnifier_ZoomRegion_COLORBLIND_FILTER_T_SELECTIVE_DESSATURATE_GREEN:
+ 		case COLORBLIND_FILTER_T_SELECTIVE_DESSATURATE_GREEN:
  			colorblind_set_filter_type (cbr, colorblind_filter_t_selective_dessaturate_green);
  			break;
- 		case GNOME_Magnifier_ZoomRegion_COLORBLIND_FILTER_T_SELECTIVE_DESSATURATE_BLUE:
+ 		case COLORBLIND_FILTER_T_SELECTIVE_DESSATURATE_BLUE:
  			colorblind_set_filter_type (cbr, colorblind_filter_t_selective_dessaturate_blue);
  			break;
- 		case GNOME_Magnifier_ZoomRegion_COLORBLIND_FILTER_T_HUE_SHIFT_POSITIVE:
+ 		case COLORBLIND_FILTER_T_HUE_SHIFT_POSITIVE:
  			colorblind_set_filter_type (cbr, colorblind_filter_t_hue_shift_positive);
  			break;
- 		case GNOME_Magnifier_ZoomRegion_COLORBLIND_FILTER_T_HUE_SHIFT_NEGATIVE:
+ 		case COLORBLIND_FILTER_T_HUE_SHIFT_NEGATIVE:
  			colorblind_set_filter_type (cbr, colorblind_filter_t_hue_shift_negative);
  			break;
- 		case GNOME_Magnifier_ZoomRegion_COLORBLIND_FILTER_T_SELECTIVE_SATURATE:
+ 		case COLORBLIND_FILTER_T_SELECTIVE_SATURATE:
  			colorblind_set_filter_type (cbr, colorblind_filter_t_selective_saturate);
  			break;
- 		case GNOME_Magnifier_ZoomRegion_COLORBLIND_FILTER_T_SELECTIVE_DESSATURATE:
+ 		case COLORBLIND_FILTER_T_SELECTIVE_DESSATURATE:
  			colorblind_set_filter_type (cbr, colorblind_filter_t_selective_dessaturate);
  			break;
- 		case GNOME_Magnifier_ZoomRegion_COLORBLIND_FILTER_T_MONOCHRONE_OTHERS:
+ 		case COLORBLIND_FILTER_T_MONOCHRONE_OTHERS:
  			colorblind_set_filter_type (cbr, colorblind_filter_t_monochrome_others);
  			break;
  		}
@@ -1773,10 +1724,10 @@ zoom_region_get_source_subwindow (ZoomRegion *zoom_region,
 				for (j = 0; j < height; ++j)
 					gdk_image_put_pixel (test_image, i, j, i*j);
 
-			zoom_region->priv->source_drawable = gdk_pixmap_new (gtk_widget_get_window (zoom_region->priv->w), width, height, -1);
+			zoom_region->priv->source_drawable = gdk_pixmap_new (gtk_widget_get_window (GTK_WIDGET (zoom_region)), width, height, -1);
 
 			if (zoom_region->priv->default_gc == NULL)
-				zoom_region->priv->default_gc = gdk_gc_new(gtk_widget_get_window (zoom_region->priv->w));
+				zoom_region->priv->default_gc = gdk_gc_new(gtk_widget_get_window (GTK_WIDGET (zoom_region)));
 
 			gdk_draw_image (zoom_region->priv->source_drawable,
 					zoom_region->priv->default_gc,
@@ -1891,7 +1842,7 @@ zoom_region_update_pixmap (ZoomRegion *zoom_region,
 		zoom_region_post_process_pixbuf (zoom_region, subimage,
 						 zoom_region->priv->scaled_pixbuf);
 		if (zoom_region->priv->default_gc == NULL)
-			zoom_region->priv->default_gc = gdk_gc_new(gtk_widget_get_window (zoom_region->priv->w));
+			zoom_region->priv->default_gc = gdk_gc_new(gtk_widget_get_window (GTK_WIDGET (zoom_region)));
 
 #ifndef USE_GDK_PIXBUF_RENDER_TO_DRAWABLE 
 		if (GDK_IS_DRAWABLE (zoom_region->priv->pixmap))
@@ -1943,14 +1894,14 @@ zoom_region_update (ZoomRegion *zoom_region,
 		    const GdkRectangle update_rect)
 {
 	GdkRectangle paint_rect = {0, 0, 0, 0};
-	if (zoom_region->priv->w && gtk_widget_get_window (zoom_region->priv->w)) {
+	if (gtk_widget_get_window (GTK_WIDGET (zoom_region))) {
 		GdkRectangle source_rect = zoom_region_update_pixmap (zoom_region, update_rect, &paint_rect);
 		if (paint_rect.x != 0 || paint_rect.y != 0 ||
 		    paint_rect.width != 0 || paint_rect.height != 0) {
 			gdk_window_begin_paint_rect (
-				gtk_widget_get_window (zoom_region->priv->w), &paint_rect);
+				gtk_widget_get_window (GTK_WIDGET (zoom_region)), &paint_rect);
 			zoom_region_paint (zoom_region, &paint_rect);
-			gdk_window_end_paint (gtk_widget_get_window (zoom_region->priv->w));
+				gdk_window_end_paint (gtk_widget_get_window (GTK_WIDGET (zoom_region)));
 		}
 		if (timing_test) {
 			mag_timing.num_scale_samples++;
@@ -1993,14 +1944,12 @@ static void
 zoom_region_init_window (ZoomRegion *zoom_region)
 {
 	GtkFixed *parent;
-	GtkWidget *zoomer, *border;
+	GtkWidget *border;
 	DBG(fprintf (stderr, "window not yet created...\n"));
 	parent = GTK_FIXED (
 		((Magnifier *)zoom_region->priv->parent)->priv->canvas);
-	zoomer = gtk_drawing_area_new ();
 	border = gtk_drawing_area_new ();
 	zoom_region->priv->border = border;
-	zoom_region->priv->w = zoomer;
 
 #ifdef ZOOM_REGION_DEBUG
 	g_assert (zoom_region->alive);
@@ -2010,7 +1959,7 @@ zoom_region_init_window (ZoomRegion *zoom_region)
 				     zoom_region->viewport.x1,
 				     zoom_region->viewport.y2 -
 				     zoom_region->viewport.y1);
-	gtk_widget_set_size_request (GTK_WIDGET (zoomer),
+	gtk_widget_set_size_request (GTK_WIDGET (zoom_region),
 				     zoom_region->viewport.x2 -
 				     zoom_region->viewport.x1 -
 				     (zoom_region->border_size_right +
@@ -2022,19 +1971,15 @@ zoom_region_init_window (ZoomRegion *zoom_region)
 	gtk_fixed_put (parent, border,
 		       zoom_region->viewport.x1,
 		       zoom_region->viewport.y1);
-	gtk_fixed_put (parent, zoomer,
+	gtk_fixed_put (parent, GTK_WIDGET (zoom_region),
 		       zoom_region->viewport.x1 +
 		       zoom_region->border_size_left,
 		       zoom_region->viewport.y1 +
 		       zoom_region->border_size_top);
 	gtk_widget_show (GTK_WIDGET (border));
-	gtk_widget_show (GTK_WIDGET (zoomer));
+	gtk_widget_show (GTK_WIDGET (zoom_region));
 	gtk_widget_show (GTK_WIDGET (parent));
-	zoom_region->priv->expose_handler_id =
-		g_signal_connect (G_OBJECT (zoom_region->priv->w),
-				  "expose_event",
-				  G_CALLBACK (zoom_region_expose_handler),
-				  zoom_region);
+
 	DBG(fprintf (stderr, "New window created\n"));
 }
 
@@ -2089,13 +2034,13 @@ timing_report(ZoomRegion *zoom_region)
 		x_scroll_incr = (float)mag_timing.dx_total / (float)mag_timing.num_line_samples;
 		y_scroll_incr = (float)mag_timing.dy_total / (float)mag_timing.num_line_samples;
 
-		gdk_drawable_get_size (GDK_DRAWABLE (gtk_widget_get_window (zoom_region->priv->w)),
+		gdk_drawable_get_size (GDK_DRAWABLE (gtk_widget_get_window (GTK_WIDGET (zoom_region))),
 			&x, &y);
 
 		fprintf(stderr, "  Frames Processed         = %ld\n", 
 			mag_timing.num_frame_samples + 1);
 		fprintf(stderr, "  Width/Height/Depth       = %d/%d/%d\n", x, y,
-			gdk_drawable_get_depth (gtk_widget_get_window (zoom_region->priv->w)));
+			gdk_drawable_get_depth (gtk_widget_get_window (GTK_WIDGET (zoom_region))));
 		fprintf(stderr, "  Zoom Factor (x/y)        = %f/%f\n", zoom_region->xscale,
 			zoom_region->yscale);
 		if (mag_timing.num_scale_samples != 0) {
@@ -2243,26 +2188,26 @@ zoom_region_get_move_x_y (ZoomRegion *zoom_region, long *x, long *y)
 		zoom_region->yscale;
 
 	switch (zoom_region->x_align_policy) {
-	case GNOME_Magnifier_ZoomRegion_ALIGN_MAX:
+	case ALIGN_MAX:
 		*x = zoom_region->roi.x2 - width;
 		break;
-	case GNOME_Magnifier_ZoomRegion_ALIGN_MIN:
+	case ALIGN_MIN:
 		*x = zoom_region->roi.x1;
 		break;
-	case GNOME_Magnifier_ZoomRegion_ALIGN_CENTER:
+	case ALIGN_CENTER:
 	default:
 		*x = ((zoom_region->roi.x1 + zoom_region->roi.x2) - width ) /
 			2;
 	}
 
 	switch (zoom_region->y_align_policy) {
-	case GNOME_Magnifier_ZoomRegion_ALIGN_MAX:
+	case ALIGN_MAX:
 		*y = zoom_region->roi.y2 - height;
 		break;
-	case GNOME_Magnifier_ZoomRegion_ALIGN_MIN:
+	case ALIGN_MIN:
 		*y = zoom_region->roi.y1;
 		break;
-	case GNOME_Magnifier_ZoomRegion_ALIGN_CENTER:
+	case ALIGN_CENTER:
 	default:
 		*y = ((zoom_region->roi.y1 + zoom_region->roi.y2) - height ) /
 			2;
@@ -2284,7 +2229,7 @@ zoom_region_align (ZoomRegion *zoom_region)
 		if (zoom_region->timing_output) {
 			gint x, y;
 
-			gdk_drawable_get_size (GDK_DRAWABLE (gtk_widget_get_window (zoom_region->priv->w)),
+			gdk_drawable_get_size (GDK_DRAWABLE (gtk_widget_get_window (GTK_WIDGET (zoom_region))),
 				&x, &y);
 
 			fprintf(stderr, "\nTiming Information - ROI   = (%d, %d) (%d, %d):\n",
@@ -2293,7 +2238,7 @@ zoom_region_align (ZoomRegion *zoom_region)
 			fprintf(stderr, "  Frame Number             = %ld\n", 
 				mag_timing.num_frame_samples + 1);
 			fprintf(stderr, "  Width/Height/Depth       = %d/%d/%d\n", x, y,
-				gdk_drawable_get_depth (gtk_widget_get_window (zoom_region->priv->w)));
+				gdk_drawable_get_depth (gtk_widget_get_window (GTK_WIDGET (zoom_region))));
 		}
 
 		/*
@@ -2335,8 +2280,12 @@ zoom_region_align (ZoomRegion *zoom_region)
 
 static void
 zoom_region_set_viewport (ZoomRegion *zoom_region,
-			  const GNOME_Magnifier_RectBounds *viewport)
+			  const RectBounds *viewport)
 {
+	Magnifier *magnifier;
+	GtkFixed  *fixed;
+	RectBounds *bounds = NULL;
+
 #ifdef ZOOM_REGION_DEBUG
 	g_assert (zoom_region->alive);
 #endif
@@ -2353,183 +2302,55 @@ zoom_region_set_viewport (ZoomRegion *zoom_region,
 		 (int) viewport->x2, (int) viewport->y2);
 #endif
 	zoom_region_align (zoom_region);
-	if (!zoom_region->priv->w) {
-		zoom_region_init_window (zoom_region);
-	} else {
-	        CORBA_any *any;
-		CORBA_Environment ev;
-		Bonobo_PropertyBag properties;
-		Magnifier *magnifier = (Magnifier *) zoom_region->priv->parent;
-		GtkFixed *fixed = GTK_FIXED (magnifier->priv->canvas);
-		gtk_fixed_move (fixed,
-				zoom_region->priv->border,
-				zoom_region->viewport.x1,
-				zoom_region->viewport.y1);
-		gtk_fixed_move (fixed,
-				zoom_region->priv->w,
-				zoom_region->viewport.x1 +
-				zoom_region->border_size_left,
-				zoom_region->viewport.y1 +
-				zoom_region->border_size_top);
-		gtk_widget_set_size_request (
+
+	magnifier = (Magnifier *) zoom_region->priv->parent;
+	fixed = GTK_FIXED (magnifier->priv->canvas);
+	gtk_fixed_move (fixed,
+			zoom_region->priv->border,
+			zoom_region->viewport.x1,
+			zoom_region->viewport.y1);
+	gtk_fixed_move (fixed,
+			GTK_WIDGET (zoom_region),
+			zoom_region->viewport.x1 +
+			zoom_region->border_size_left,
+			zoom_region->viewport.y1 +
+			zoom_region->border_size_top);
+	gtk_widget_set_size_request (
 			GTK_WIDGET (zoom_region->priv->border),
 			zoom_region->viewport.x2 - zoom_region->viewport.x1,
 			zoom_region->viewport.y2 - zoom_region->viewport.y1);
-		gtk_widget_set_size_request (GTK_WIDGET (zoom_region->priv->w),
-					     zoom_region->viewport.x2 -
-					     zoom_region->viewport.x1 -
-					     (zoom_region->border_size_right +
-					      zoom_region->border_size_left),
-					     zoom_region->viewport.y2 -
-					     zoom_region->viewport.y1 -
-					     (zoom_region->border_size_bottom +
-					      zoom_region->border_size_top));
-		CORBA_exception_init (&ev);
-		properties = 
-			GNOME_Magnifier_Magnifier_getProperties(
-				BONOBO_OBJREF (
-					(Magnifier *) zoom_region->priv->parent), &ev);
-		if (!BONOBO_EX (&ev))
-			any = Bonobo_PropertyBag_getValue (
-				properties, "source-display-bounds", &ev);
-		if (!BONOBO_EX (&ev))
-			zoom_region->priv->source_area =
-				*((GNOME_Magnifier_RectBounds *) any->_value);
-		if (zoom_region->priv->pixmap) 
-			g_object_unref (zoom_region->priv->pixmap);
-		zoom_region_create_pixmap (zoom_region);
-		if (zoom_region->priv->scaled_pixbuf)
-		        g_object_unref (zoom_region->priv->scaled_pixbuf);
+	gtk_widget_set_size_request (GTK_WIDGET (zoom_region),
+				     zoom_region->viewport.x2 -
+				     zoom_region->viewport.x1 -
+				     (zoom_region->border_size_right +
+				      zoom_region->border_size_left),
+				     zoom_region->viewport.y2 -
+				     zoom_region->viewport.y1 -
+				     (zoom_region->border_size_bottom +
+				      zoom_region->border_size_top));
+	g_object_get (magnifier, "source-display-bounds", &bounds, NULL);
+	zoom_region->priv->source_area = *bounds;
+	g_free (bounds);
+
+	if (zoom_region->priv->pixmap)
+		g_object_unref (zoom_region->priv->pixmap);
+	zoom_region_create_pixmap (zoom_region);
+	if (zoom_region->priv->scaled_pixbuf)
+		g_object_unref (zoom_region->priv->scaled_pixbuf);
 
-		zoom_region->priv->scaled_pixbuf = 
+	zoom_region->priv->scaled_pixbuf =
 		  gdk_pixbuf_new (GDK_COLORSPACE_RGB, FALSE, 8,
 				  (zoom_region->priv->source_area.x2 -
 				   zoom_region->priv->source_area.x1) * zoom_region->xscale + 1,
 				  (zoom_region->priv->source_area.y2 -
 				   zoom_region->priv->source_area.y1) * zoom_region->yscale + 1);
-	}
+
 	zoom_region_queue_update (zoom_region,
 				  zoom_region_source_rect_from_view_bounds (
 					  zoom_region, &zoom_region->viewport));
 }
 
 static void
-zoom_region_get_property (BonoboPropertyBag *bag,
-			  BonoboArg *arg,
-			  guint arg_id,
-			  CORBA_Environment *ev,
-			  gpointer user_data)
-{
-	ZoomRegion *zoom_region = user_data;
-
-#ifdef ZOOM_REGION_DEBUG
-	g_assert (zoom_region->alive);
-#endif
-	DBG (fprintf (stderr, "Get zoom-region property: %s\n", prop_names[arg_id]));
-
-	switch (arg_id) {
-	case ZOOM_REGION_MANAGED_PROP:
-		BONOBO_ARG_SET_BOOLEAN (arg, zoom_region->is_managed);
-		break;
-	case ZOOM_REGION_POLL_MOUSE_PROP:
-		BONOBO_ARG_SET_BOOLEAN (arg, zoom_region->poll_mouse);
-		break;
-	case ZOOM_REGION_DRAW_CURSOR_PROP:
-		BONOBO_ARG_SET_BOOLEAN (arg, zoom_region->draw_cursor);
-		break;
-	case ZOOM_REGION_INVERT_PROP:
-		BONOBO_ARG_SET_BOOLEAN (arg, zoom_region->invert);
-		break;
-	case ZOOM_REGION_SMOOTHSCROLL_PROP:
-		BONOBO_ARG_SET_SHORT (arg, zoom_region->smooth_scroll_policy);
-		break;
-	case ZOOM_REGION_COLORBLIND_PROP:
-		BONOBO_ARG_SET_SHORT (arg, zoom_region->color_blind_filter);
-		break;
-	case ZOOM_REGION_TESTPATTERN_PROP:
-		BONOBO_ARG_SET_BOOLEAN (arg, zoom_region->priv->test);
-		break;
-	case ZOOM_REGION_SMOOTHING_PROP:
-		BONOBO_ARG_SET_STRING (arg, zoom_region->smoothing);
-		break;
-	case ZOOM_REGION_CONTRASTR_PROP:
-		BONOBO_ARG_SET_FLOAT (arg, zoom_region->contrast_r);
-		break;
-	case ZOOM_REGION_CONTRASTG_PROP:
-		BONOBO_ARG_SET_FLOAT (arg, zoom_region->contrast_g);
-		break;
-	case ZOOM_REGION_CONTRASTB_PROP:
-		BONOBO_ARG_SET_FLOAT (arg, zoom_region->contrast_b);
-		break;
-	case ZOOM_REGION_BRIGHTR_PROP:
-		BONOBO_ARG_SET_FLOAT (arg, zoom_region->bright_r);
-		break;
-	case ZOOM_REGION_BRIGHTG_PROP:
-		BONOBO_ARG_SET_FLOAT (arg, zoom_region->bright_g);
-		break;
-	case ZOOM_REGION_BRIGHTB_PROP:
-		BONOBO_ARG_SET_FLOAT (arg, zoom_region->bright_b);
-		break;
-	case ZOOM_REGION_XSCALE_PROP:
-		BONOBO_ARG_SET_FLOAT (arg, zoom_region->xscale);
-		break;
-	case ZOOM_REGION_YSCALE_PROP:
-		BONOBO_ARG_SET_FLOAT (arg, zoom_region->yscale);
-		break;
-	case ZOOM_REGION_BORDERSIZE_PROP:
-		BONOBO_ARG_SET_LONG (
-			arg, (zoom_region->border_size_top +
-			      zoom_region->border_size_left +
-			      zoom_region->border_size_right +
-			      zoom_region->border_size_bottom) / 4);
-		break;
-	case ZOOM_REGION_BORDERSIZETOP_PROP:
-		BONOBO_ARG_SET_LONG (arg, zoom_region->border_size_top);
-		break;
-	case ZOOM_REGION_BORDERSIZELEFT_PROP:
-		BONOBO_ARG_SET_LONG (arg, zoom_region->border_size_left);
-		break;
-	case ZOOM_REGION_BORDERSIZERIGHT_PROP:
-		BONOBO_ARG_SET_LONG (arg, zoom_region->border_size_right);
-		break;
-	case ZOOM_REGION_BORDERSIZEBOTTOM_PROP:
-		BONOBO_ARG_SET_LONG (arg, zoom_region->border_size_bottom);
-		break;
-	case ZOOM_REGION_XALIGN_PROP:
-		/* TODO: enums here */
-		BONOBO_ARG_SET_INT (arg, zoom_region->x_align_policy);
-		break;
-	case ZOOM_REGION_YALIGN_PROP:
-		BONOBO_ARG_SET_INT (arg, zoom_region->y_align_policy);
-		break;
-	case ZOOM_REGION_BORDERCOLOR_PROP:
-		BONOBO_ARG_SET_LONG (arg,
-				     zoom_region->border_color);
-		break;
-	case ZOOM_REGION_VIEWPORT_PROP:
-		BONOBO_ARG_SET_GENERAL (arg, zoom_region->viewport,
-					TC_GNOME_Magnifier_RectBounds,
-					GNOME_Magnifier_RectBounds,
-					NULL);
-		break;
-	case ZOOM_REGION_TIMING_TEST_PROP:
-		BONOBO_ARG_SET_INT (arg, zoom_region->timing_iterations);
-		break;
-	case ZOOM_REGION_TIMING_OUTPUT_PROP:
-		BONOBO_ARG_SET_BOOLEAN (arg, zoom_region->timing_output);
-		break;
-	case ZOOM_REGION_TIMING_PAN_RATE_PROP:
-		BONOBO_ARG_SET_INT (arg, zoom_region->timing_pan_rate);
-		break;
-	case ZOOM_REGION_EXIT_MAGNIFIER:
-		BONOBO_ARG_SET_BOOLEAN (arg, zoom_region->exit_magnifier);
-		break;
-	default:
-		bonobo_exception_set (ev, ex_Bonobo_PropertyBag_NotFound);
-	};
-}
-
-static void
 zoom_region_update_borders (ZoomRegion *zoom_region)
 {
 	gtk_widget_set_size_request (GTK_WIDGET (zoom_region->priv->border),
@@ -2537,7 +2358,7 @@ zoom_region_update_borders (ZoomRegion *zoom_region)
 				     zoom_region->viewport.x1,
 				     zoom_region->viewport.y2 -
 				     zoom_region->viewport.y1);
-	gtk_widget_set_size_request (GTK_WIDGET (zoom_region->priv->w),
+	gtk_widget_set_size_request (GTK_WIDGET (zoom_region),
 				     zoom_region->viewport.x2 -
 				     zoom_region->viewport.x1 -
 				     (zoom_region->border_size_right +
@@ -2547,485 +2368,102 @@ zoom_region_update_borders (ZoomRegion *zoom_region)
 				     (zoom_region->border_size_bottom +
 				      zoom_region->border_size_top));
 	gtk_fixed_move (GTK_FIXED (((Magnifier *)zoom_region->priv->parent)->priv->canvas), zoom_region->priv->border, zoom_region->viewport.x1, zoom_region->viewport.y1);
-	gtk_fixed_move (GTK_FIXED (((Magnifier *)zoom_region->priv->parent)->priv->canvas), zoom_region->priv->w, zoom_region->viewport.x1 + zoom_region->border_size_left, zoom_region->viewport.y1 + zoom_region->border_size_top);
-}
-
-gboolean
-impl_dbus_zoom_region_set_managed (ZoomRegion *zoom_region, gboolean managed)
-{
-	zoom_region->is_managed = managed;
-	
-	return TRUE;
-}
-
-gboolean
-impl_dbus_zoom_region_get_managed (ZoomRegion *zoom_region)
-{
-	return zoom_region->is_managed;
+	gtk_fixed_move (GTK_FIXED (((Magnifier *)zoom_region->priv->parent)->priv->canvas), GTK_WIDGET (zoom_region), zoom_region->viewport.x1 + zoom_region->border_size_left, zoom_region->viewport.y1 + zoom_region->border_size_top);
 }
 
 gboolean
-impl_dbus_zoom_region_set_poll_mouse (ZoomRegion *zoom_region, gboolean poll_mouse)
+zoom_region_set_mag_factor (ZoomRegion *zoom_region,
+			    gdouble     mag_factor_x,
+			    gdouble     mag_factor_y)
 {
-	zoom_region->poll_mouse = poll_mouse;
-	if (zoom_region->poll_mouse) {
-		g_message ("Adding polling timer");
-		zoom_region->priv->update_pointer_id = g_timeout_add_full (G_PRIORITY_DEFAULT_IDLE,
-									   200,
-									   zoom_region_update_pointer_timeout,
-									   zoom_region,
-									   NULL);
-	} else if (zoom_region->priv->update_pointer_id) {
-		g_message ("Removing polling time");
-		g_source_remove (zoom_region->priv->update_pointer_id);
-		zoom_region->priv->update_pointer_id = 0;
-	}
-	
-	return TRUE;
-}
+	RectBounds *bounds;
+	gboolean    retval;
 
-gboolean
-impl_dbus_zoom_region_get_poll_mouse (ZoomRegion *zoom_region)
-{
-	return zoom_region->poll_mouse;
-}
-
-gboolean
-impl_dbus_zoom_region_set_draw_cursor (ZoomRegion *zoom_region, gboolean draw_cursor)
-{
-	zoom_region->draw_cursor = draw_cursor;
-	if (!zoom_region->draw_cursor) {
-		zoom_region_unpaint_cursor (zoom_region, NULL);
+	if ((zoom_region->xscale == mag_factor_x) &&
+	    (zoom_region->yscale == mag_factor_y)) {
+			return TRUE;
 	}
-	
-	return TRUE;
-}
-
-gboolean
-impl_dbus_zoom_region_get_draw_cursor (ZoomRegion *zoom_region)
-{
-	return zoom_region->draw_cursor;
-}
-
-gboolean
-impl_dbus_zoom_region_set_invert (ZoomRegion *zoom_region, gboolean invert)
-{
-	zoom_region->invert = invert;
-	zoom_region_update_current (zoom_region);
-	
-	return TRUE;
-}
 
-gboolean
-impl_dbus_zoom_region_get_invert (ZoomRegion *zoom_region)
-{
-	return zoom_region->invert;
-}
-
-gboolean
-impl_dbus_zoom_region_set_smoothscroll (ZoomRegion *zoom_region, gshort smoothscroll)
-{
-	zoom_region->smooth_scroll_policy = smoothscroll;
-	
-	return TRUE;
-}
+	g_object_get (zoom_region->priv->parent,
+		      "source-display-bounds", &bounds,
+		      NULL);
+	zoom_region->priv->source_area = *bounds;
+	g_free (bounds);
 
-gshort
-impl_dbus_zoom_region_get_smoothscroll (ZoomRegion *zoom_region)
-{
-	return zoom_region->smooth_scroll_policy;
-}
+	retval = zoom_region_update_scale (zoom_region, mag_factor_x, mag_factor_y);
+	zoom_region_sync (zoom_region);
 
-gboolean
-impl_dbus_zoom_region_set_colorblind (ZoomRegion *zoom_region, gshort colorblind)
-{
-	zoom_region->color_blind_filter = colorblind;
-	zoom_region_update_current (zoom_region);
-	
-	return TRUE;
+	return retval;
 }
 
-gshort
-impl_dbus_zoom_region_get_colorblind (ZoomRegion *zoom_region)
+void
+zoom_region_set_roi (ZoomRegion *zoom_region,
+		     RectBounds *bounds)
 {
-	return zoom_region->color_blind_filter;
-}
+	DBG (fprintf (stderr, "Set ROI: \t%d,%d %d,%d\n",
+		      bounds->x1, bounds->y1, bounds->x2, bounds->y2));
 
-gboolean
-impl_dbus_zoom_region_set_smoothing (ZoomRegion *zoom_region, gchar *smoothing)
-{
-	zoom_region->smoothing = g_strdup (smoothing);
-	if (!strncmp (zoom_region->smoothing, "bilinear", 8)) {
-		zoom_region->priv->gdk_interp_type = GDK_INTERP_BILINEAR;
-	} else {
-		zoom_region->priv->gdk_interp_type = GDK_INTERP_NEAREST;
+	if ((zoom_region->roi.x1 == bounds->x1) &&
+	    (zoom_region->roi.x2 == bounds->x2) &&
+	    (zoom_region->roi.y1 == bounds->y1) &&
+	    (zoom_region->roi.y2 == bounds->y2)) {
+		return;
 	}
-	zoom_region_update_current (zoom_region);
-	
-	return TRUE;
-}
 
-gchar*
-impl_dbus_zoom_region_get_smoothing (ZoomRegion *zoom_region)
-{
-	return g_strdup (zoom_region->smoothing);
-}
-
-gboolean
-impl_dbus_zoom_region_set_testpattern (ZoomRegion *zoom_region, gboolean test)
-{
-	zoom_region->priv->test = test;
-	if (zoom_region->priv->source_drawable) {
-		g_object_unref (zoom_region->priv->source_drawable);
-		zoom_region->priv->source_drawable = NULL;
+	/* if these bounds are clearly bogus, warn and ignore */
+	if (!bounds || (bounds->x2 <= bounds->x1)
+	    || (bounds->y2 < bounds->y1) ||
+	    ((bounds->x1 + bounds->x2)/2 < 0) ||
+	    ((bounds->y1 + bounds->y2)/2 < 0))
+	{
+		g_warning ("Bad bounds request (%d,%d to %d,%d), ignoring.\n",
+			   bounds->x1, bounds->y1, bounds->x2, bounds->y2);
+		return;
 	}
-	zoom_region_update_current (zoom_region);
-	
-	return TRUE;
-}
-
-gboolean
-impl_dbus_zoom_region_get_testpattern (ZoomRegion *zoom_region)
-{
-	return zoom_region->priv->test;
-}
-
-gboolean
-impl_dbus_zoom_region_set_bordersizes (ZoomRegion *zoom_region, gint32 **bordersizes)
-{
-	zoom_region->border_size_left   = (*bordersizes)[0];
-	zoom_region->border_size_top    = (*bordersizes)[1];
-	zoom_region->border_size_right  = (*bordersizes)[2];
-	zoom_region->border_size_bottom = (*bordersizes)[3];
-	zoom_region_update_borders (zoom_region);
-	
-	return TRUE;
-}
-
-GArray*
-impl_dbus_zoom_region_get_bordersizes (ZoomRegion *zoom_region)
-{
-	GArray *ret;
-	
-	ret = g_array_new (FALSE, FALSE, sizeof (gint32));
-	
-	g_array_append_val (ret, zoom_region->border_size_left);
-	g_array_append_val (ret, zoom_region->border_size_top);
-	g_array_append_val (ret, zoom_region->border_size_right);
-	g_array_append_val (ret, zoom_region->border_size_bottom);
-	
-	return ret;
-}
-
-gboolean
-impl_dbus_zoom_region_set_bordercolor (ZoomRegion *zoom_region, guint32 bordercolor)
-{
-	zoom_region->border_color = bordercolor;
-	zoom_region_paint_border (zoom_region);
-	
-	return TRUE;
-}
-
-guint32
-impl_dbus_zoom_region_get_bordercolor (ZoomRegion *zoom_region)
-{
-	return zoom_region->border_color;
-}
-
-gboolean
-impl_dbus_zoom_region_set_xalign (ZoomRegion *zoom_region, gint32 align)
-{
-	zoom_region->x_align_policy = align;
-	zoom_region_align (zoom_region);
-	
-	return TRUE;
-}
-
-gint32
-impl_dbus_zoom_region_get_xalign (ZoomRegion *zoom_region)
-{
-	return zoom_region->x_align_policy;
-}
-
-gboolean
-impl_dbus_zoom_region_set_yalign (ZoomRegion *zoom_region, gint32 align)
-{
-	zoom_region->y_align_policy = align;
-	zoom_region_align (zoom_region);
-	
-	return TRUE;
-}
-
-gint32
-impl_dbus_zoom_region_get_yalign (ZoomRegion *zoom_region)
-{
-	return zoom_region->y_align_policy;
-}
-
-gboolean
-impl_dbus_zoom_region_set_viewport (ZoomRegion *zoom_region, gint32 **viewport)
-{
-	GNOME_Magnifier_RectBounds *bounds = g_malloc (sizeof (GNOME_Magnifier_RectBounds));
-
-	bounds->x1 = (*viewport)[0];
-	bounds->y1 = (*viewport)[1];
-	bounds->x2 = (*viewport)[2];
-	bounds->y2 = (*viewport)[3];
-	
-	zoom_region_set_viewport (zoom_region, bounds);
-	
-	g_free (bounds);
-	
-	return TRUE;
-}
-
-GArray*
-impl_dbus_zoom_region_get_viewport (ZoomRegion *zoom_region)
-{
-	GArray *ret;
-	
-	ret = g_array_new (FALSE, FALSE, sizeof (gint32));
-	
-	g_array_append_val (ret, zoom_region->viewport.x1);
-	g_array_append_val (ret, zoom_region->viewport.y1);
-	g_array_append_val (ret, zoom_region->viewport.x2);
-	g_array_append_val (ret, zoom_region->viewport.y2);
-	
-	return ret;
-}
-
-gboolean
-impl_dbus_zoom_region_set_timing_test (ZoomRegion *zoom_region, gint32 timing_iterations)
-{
-	zoom_region->timing_iterations = timing_iterations;
-	timing_test = TRUE;
-	
-	return TRUE;
-}
-
-gint32
-impl_dbus_zoom_region_get_timing_test (ZoomRegion *zoom_region)
-{
-	return zoom_region->timing_iterations;
-}
 
-gboolean
-impl_dbus_zoom_region_set_timing_output (ZoomRegion *zoom_region, gboolean timing_output)
-{
-	zoom_region->timing_output = timing_output;
-	
-	return TRUE;
-}
-
-gboolean
-impl_dbus_zoom_region_get_timing_output (ZoomRegion *zoom_region)
-{
-	return zoom_region->timing_output;
-}
-
-gboolean
-impl_dbus_zoom_region_set_timing_pan_rate (ZoomRegion *zoom_region, gint32 timing_pan_rate)
-{
-	zoom_region->timing_pan_rate = timing_pan_rate;
-	timing_test = TRUE;
-	
-	return TRUE;
-}
+	zoom_region->roi = *bounds;
 
-gint32
-impl_dbus_zoom_region_get_timing_pan_rate (ZoomRegion *zoom_region)
-{
-	return zoom_region->timing_pan_rate;
-}
+	if (zoom_region->timing_pan_rate > 0) {
+		/* Set idle handler to do panning test */
+		g_idle_add_full (GDK_PRIORITY_REDRAW + 3,
+				 zoom_region_pan_test, zoom_region, NULL);
+	}
 
-gboolean
-impl_dbus_zoom_region_set_exit_magnifier (ZoomRegion *zoom_region, gboolean exit_magnifier)
-{
-	zoom_region->exit_magnifier = exit_magnifier;
-	
-	return TRUE;
-}
+	if (zoom_region->exit_magnifier) {
+		if (timing_test) {
+			fprintf(stderr, "\n### Timing Summary:\n\n");
+			if (zoom_region->timing_pan_rate)
+				fprintf(stderr, "  Pan Rate                 = %d\n", zoom_region->timing_pan_rate);
+			timing_report(zoom_region);
+		}
+		exit(0);
+	}
 
-gboolean
-impl_dbus_zoom_region_get_exit_magnifier (ZoomRegion *zoom_region)
-{
-	return zoom_region->exit_magnifier;
-}
+	/*
+	 * Do not bother trying to update the screen if the last
+	 * screen update has not had time to complete.
+	 */
+	if (processing_updates) {
+		/* Remove any previous idle handler */
+		if (pending_idle_handler != 0) {
+			g_source_remove(pending_idle_handler);
+			pending_idle_handler = 0;
+		}
 
-static void
-zoom_region_set_property (BonoboPropertyBag *bag,
-			  BonoboArg *arg,
-			  guint arg_id,
-			  CORBA_Environment *ev,
-			  gpointer user_data)
-{
-	ZoomRegion *zoom_region = user_data;
-	GNOME_Magnifier_RectBounds bounds;
-	gfloat t;
+		/* Set idle handler to process this pending update when possible */
 
-#ifdef ZOOM_REGION_DEBUG
-	g_assert (zoom_region->alive);
-#endif
-	DBG (fprintf (stderr, "Set zoom-region property: %s\n", prop_names[arg_id]));
+		pending_idle_handler = g_idle_add_full (GDK_PRIORITY_REDRAW + 2,
+							zoom_region_process_pending, zoom_region, NULL);
 
-	switch (arg_id) {
-	case ZOOM_REGION_MANAGED_PROP:
-		zoom_region->is_managed = BONOBO_ARG_GET_BOOLEAN (arg);
-		break;
-	case ZOOM_REGION_POLL_MOUSE_PROP:
-		zoom_region->poll_mouse = BONOBO_ARG_GET_BOOLEAN (arg);
-		if (zoom_region->poll_mouse)
-		{
-		    g_message ("Adding polling timer");
-		    zoom_region->priv->update_pointer_id =
-			g_timeout_add_full (G_PRIORITY_DEFAULT_IDLE,
-					    200,
-					    zoom_region_update_pointer_timeout,
-					    zoom_region,
-					    NULL);
-		}
-		else if (zoom_region->priv->update_pointer_id)
-		{
-		    g_message ("Removing polling timer");
-		    g_source_remove (zoom_region->priv->update_pointer_id);
-		    zoom_region->priv->update_pointer_id = 0;
-		}
-		break;
-	case ZOOM_REGION_DRAW_CURSOR_PROP:
-		zoom_region->draw_cursor = BONOBO_ARG_GET_BOOLEAN (arg);
-		if (!zoom_region->draw_cursor)
-			zoom_region_unpaint_cursor (zoom_region, NULL);
-		break;
-	case ZOOM_REGION_INVERT_PROP:
-		zoom_region->invert = BONOBO_ARG_GET_BOOLEAN (arg);
-		zoom_region_update_current (zoom_region);
-		break;
-	case ZOOM_REGION_SMOOTHSCROLL_PROP:
-		zoom_region->smooth_scroll_policy = BONOBO_ARG_GET_SHORT (arg);
-		break;
-	case ZOOM_REGION_COLORBLIND_PROP:
-		zoom_region->color_blind_filter = BONOBO_ARG_GET_SHORT (arg);
-		zoom_region_update_current (zoom_region);
-		break;
-	case ZOOM_REGION_SMOOTHING_PROP:
-		zoom_region->smoothing = BONOBO_ARG_GET_STRING (arg);
-		if (!strncmp (zoom_region->smoothing, "bilinear", 8))
-			zoom_region->priv->gdk_interp_type = GDK_INTERP_BILINEAR;
-		else 
-			zoom_region->priv->gdk_interp_type = GDK_INTERP_NEAREST;
-		zoom_region_update_current (zoom_region);
-		break;
-	case ZOOM_REGION_TESTPATTERN_PROP:
-		zoom_region->priv->test = BONOBO_ARG_GET_BOOLEAN (arg);
-		if (zoom_region->priv->source_drawable) {
-			g_object_unref (zoom_region->priv->source_drawable);
-			zoom_region->priv->source_drawable = NULL;
+		if (zoom_region->timing_output) {
+			fprintf(stderr,
+				"\n  [Last update not finished, pending - ROI=(%d, %d) (%d, %d)]\n\n",
+				zoom_region->roi.x1, zoom_region->roi.y1, zoom_region->roi.x2,
+				zoom_region->roi.y2);
 		}
-		zoom_region_update_current (zoom_region);
-		break;
-	case ZOOM_REGION_CONTRASTR_PROP:
-		zoom_region->contrast_r =
-			CLAMP_B_C (BONOBO_ARG_GET_FLOAT (arg));
-		zoom_region_update_current (zoom_region);
-		break;
-	case ZOOM_REGION_CONTRASTG_PROP:
-		zoom_region->contrast_g =
-			CLAMP_B_C (BONOBO_ARG_GET_FLOAT (arg));
-		zoom_region_update_current (zoom_region);
-		break;
-	case ZOOM_REGION_CONTRASTB_PROP:
-		zoom_region->contrast_b =
-			CLAMP_B_C (BONOBO_ARG_GET_FLOAT (arg));
-		zoom_region_update_current (zoom_region);
-		break;
-	case ZOOM_REGION_BRIGHTR_PROP:
-		zoom_region->bright_r =
-			CLAMP_B_C (BONOBO_ARG_GET_FLOAT (arg));
-		zoom_region_update_current (zoom_region);
-		break;
-	case ZOOM_REGION_BRIGHTG_PROP:
-		zoom_region->bright_g =
-			CLAMP_B_C (BONOBO_ARG_GET_FLOAT (arg));
-		zoom_region_update_current (zoom_region);
-		break;
-	case ZOOM_REGION_BRIGHTB_PROP:
-		zoom_region->bright_b =
-			CLAMP_B_C (BONOBO_ARG_GET_FLOAT (arg));
-		zoom_region_update_current (zoom_region);
-		break;
-	case ZOOM_REGION_XSCALE_PROP:
-		(void) zoom_region_update_scale (zoom_region,
-						 BONOBO_ARG_GET_FLOAT (arg),
-						 zoom_region->yscale);
-		break;
-	case ZOOM_REGION_YSCALE_PROP:
-		(void) zoom_region_update_scale (zoom_region,
-						 zoom_region->xscale,
-						 BONOBO_ARG_GET_FLOAT (arg));
-		
-		break;
-	case ZOOM_REGION_BORDERSIZE_PROP:
-		zoom_region->border_size_left =
-			zoom_region->border_size_top =
-			zoom_region->border_size_right =
-			zoom_region->border_size_bottom =
-			BONOBO_ARG_GET_LONG (arg);
-		zoom_region_update_borders (zoom_region);
-		break;
-	case ZOOM_REGION_BORDERSIZELEFT_PROP:
-		zoom_region->border_size_left = BONOBO_ARG_GET_LONG (arg);
-		zoom_region_update_borders (zoom_region);
-		break;
-	case ZOOM_REGION_BORDERSIZETOP_PROP:
-		zoom_region->border_size_top = BONOBO_ARG_GET_LONG (arg);
-		zoom_region_update_borders (zoom_region);
-		break;
-	case ZOOM_REGION_BORDERSIZERIGHT_PROP:
-		zoom_region->border_size_right = BONOBO_ARG_GET_LONG (arg);
-		zoom_region_update_borders (zoom_region);
-		break;
-	case ZOOM_REGION_BORDERSIZEBOTTOM_PROP:
-		zoom_region->border_size_bottom = BONOBO_ARG_GET_LONG (arg);
-		zoom_region_update_borders (zoom_region);
-		break;
-	case ZOOM_REGION_BORDERCOLOR_PROP:
-		zoom_region->border_color =
-			BONOBO_ARG_GET_LONG (arg);
-		zoom_region_paint_border (zoom_region);
-		break;
-	case ZOOM_REGION_XALIGN_PROP:
-		zoom_region->x_align_policy = BONOBO_ARG_GET_INT (arg);
-		zoom_region_align (zoom_region);
-		break;
-	case ZOOM_REGION_YALIGN_PROP:
-		/* TODO: enums here */
-		zoom_region->y_align_policy = BONOBO_ARG_GET_INT (arg);
+	} else {
 		zoom_region_align (zoom_region);
-		break;
-	case ZOOM_REGION_VIEWPORT_PROP:
-		bounds = BONOBO_ARG_GET_GENERAL (arg,
-						 TC_GNOME_Magnifier_RectBounds,
-						 GNOME_Magnifier_RectBounds,
-						 NULL);
-		zoom_region_set_viewport (zoom_region, &bounds);
-		break;
-	case ZOOM_REGION_TIMING_TEST_PROP:
-		zoom_region->timing_iterations = BONOBO_ARG_GET_INT (arg);
-		timing_test = TRUE;
-		break;
-	case ZOOM_REGION_TIMING_OUTPUT_PROP:
-		zoom_region->timing_output = BONOBO_ARG_GET_BOOLEAN (arg);
-		break;
-	case ZOOM_REGION_TIMING_PAN_RATE_PROP:
-		zoom_region->timing_pan_rate = BONOBO_ARG_GET_INT (arg);
-		timing_test = TRUE;
-		break;
-	case ZOOM_REGION_EXIT_MAGNIFIER:
-		zoom_region->exit_magnifier = BONOBO_ARG_GET_BOOLEAN (arg);
-		break;
-	default:
-		bonobo_exception_set (ev, ex_Bonobo_PropertyBag_NotFound);
-	};
+	}
 }
 
 static int
@@ -3044,10 +2482,9 @@ static int
 zoom_region_pan_test (gpointer data)
 {
 	ZoomRegion *zoom_region = (ZoomRegion *) data;
+	GList *zoom_regions;
 	Magnifier *magnifier = zoom_region->priv->parent; 
-	GNOME_Magnifier_ZoomRegionList *zoom_regions;
-	GNOME_Magnifier_RectBounds roi;
-	CORBA_Environment ev;
+	RectBounds roi;
 	static int counter = 0;
 	static gboolean finished_update = !TRUE;
         static float last_pixels_at_speed = -1;
@@ -3110,12 +2547,10 @@ zoom_region_pan_test (gpointer data)
 	if (counter > zoom_region->timing_iterations - 1)
 		zoom_region->exit_magnifier = TRUE;
 
-	zoom_regions = GNOME_Magnifier_Magnifier_getZoomRegions (
-		BONOBO_OBJREF (magnifier), &ev);
+	zoom_regions = magnifier->zoom_regions;
 
-	if (zoom_regions && (zoom_regions->_length > 0)) {
-		GNOME_Magnifier_ZoomRegion_setROI (
-			zoom_regions->_buffer[0], &roi, &ev);
+	if (zoom_regions) {
+		zoom_region_set_roi (ZOOM_REGION (zoom_regions->data), &roi);
 	}
 
 	if (!finished_update) {
@@ -3132,364 +2567,444 @@ zoom_region_pan_test (gpointer data)
 }
 
 static void
-impl_zoom_region_set_pointer_pos (PortableServer_Servant servant,
-				  const CORBA_long mouse_x,
-				  const CORBA_long mouse_y,
-				  CORBA_Environment *ev)
-{
-	ZoomRegion *zoom_region =
-		ZOOM_REGION (bonobo_object_from_servant (servant));
-	GdkRectangle paint_area, *clip = NULL;
-
-#ifdef ZOOM_REGION_DEBUG
-	g_assert (zoom_region->alive);
-#endif
-	DBG (fprintf (stderr, "Set Pointer: \t%ld,%ld\n", 
-		      (long) mouse_x, (long) mouse_y));
-
-	fprintf (stderr, "Set Pointer: \t%ld,%ld\n", 
-		      (long) mouse_x, (long) mouse_y);
-
-	zoom_region_set_cursor_pos (zoom_region, (int) mouse_x, (int) mouse_y);
-
-	if (GTK_IS_WIDGET (zoom_region->priv->w) && 
-	    GDK_IS_DRAWABLE (gtk_widget_get_window (zoom_region->priv->w)))
-	{
-	    gdk_drawable_get_size (
-		GDK_DRAWABLE (
-		    gtk_widget_get_window (zoom_region->priv->w)),
-		&paint_area.width, &paint_area.height);
-	    paint_area.x = 0;
-	    paint_area.y = 0;
-	    clip = &paint_area;
-	    paint_area = zoom_region_clip_to_source (
-		zoom_region, paint_area);
-	}
-	/* 
-	 * if we update the cursor now, it causes flicker if the client 
-	 * subsequently calls setROI, so we wait for a redraw.
-	 * Perhaps we should cue a redraw on idle instead?
-	 */
-}
-
-static void
-impl_zoom_region_set_contrast (PortableServer_Servant servant,
-			       const CORBA_float R,
-			       const CORBA_float G,
-			       const CORBA_float B,
-			       CORBA_Environment *ev)
-{
-	ZoomRegion *zoom_region =
-		ZOOM_REGION (bonobo_object_from_servant (servant));
+method_call_cb (GDBusConnection       *connection,
+		const gchar           *sender,
+		const gchar           *object_path,
+		const gchar           *interface_name,
+		const gchar           *method_name,
+		GVariant              *parameters,
+		GDBusMethodInvocation *invocation,
+		gpointer               user_data)
+{
+	ZoomRegion *zoom_region = ZOOM_REGION (user_data);
 	gfloat t;
 
 #ifdef ZOOM_REGION_DEBUG
 	g_assert (zoom_region->alive);
 #endif
-	DBG (fprintf (stderr, "Set contrast: \t%f,%f %f\n", R, G, B));
-
-	/* if the contrast values are the same, this is a NOOP */
-	if (zoom_region->contrast_r == R &&
-	    zoom_region->contrast_g == G &&
-	    zoom_region->contrast_b == B)
-		return;
-
-	zoom_region->contrast_r = CLAMP_B_C (R);
-	zoom_region->contrast_g = CLAMP_B_C (G);
-	zoom_region->contrast_b = CLAMP_B_C (B);
-
-	zoom_region_update_current (zoom_region);
-}
-
-static void
-impl_zoom_region_get_contrast (PortableServer_Servant servant,
-			       CORBA_float *R,
-			       CORBA_float *G,
-			       CORBA_float *B,
-			       CORBA_Environment *ev)
-{
-	ZoomRegion *zoom_region =
-		ZOOM_REGION (bonobo_object_from_servant (servant));
-
-#ifdef ZOOM_REGION_DEBUG
-	g_assert (zoom_region->alive);
-#endif
 
-	*R = zoom_region->contrast_r;
-	*G = zoom_region->contrast_g;
-	*B = zoom_region->contrast_b;
-}
-
-static void
-impl_zoom_region_set_brightness (PortableServer_Servant servant,
-				 const CORBA_float R,
-				 const CORBA_float G,
-				 const CORBA_float B,
-				 CORBA_Environment *ev)
-{
-	ZoomRegion *zoom_region =
-		ZOOM_REGION (bonobo_object_from_servant (servant));
-	gfloat t;
-
-#ifdef ZOOM_REGION_DEBUG
-	g_assert (zoom_region->alive);
-#endif
-	DBG (fprintf (stderr, "Set brightness: \t%f,%f %f\n", R, G, B));
-
-	/* if the contrast values are the same, this is a NOOP */
-	if (zoom_region->bright_r == R &&
-	    zoom_region->bright_g == G &&
-	    zoom_region->bright_b == B)
-		return;
-
-	zoom_region->bright_r = CLAMP_B_C (R);
-	zoom_region->bright_g = CLAMP_B_C (G);
-	zoom_region->bright_b = CLAMP_B_C (B);
-
-	zoom_region_update_current (zoom_region);
-}
-
-static void
-impl_zoom_region_get_brightness (PortableServer_Servant servant,
-				 CORBA_float *R,
-				 CORBA_float *G,
-				 CORBA_float *B,
-				 CORBA_Environment *ev)
-{
-	ZoomRegion *zoom_region =
-		ZOOM_REGION (bonobo_object_from_servant (servant));
-
-#ifdef ZOOM_REGION_DEBUG
-	g_assert (zoom_region->alive);
-#endif
-
-	*R = zoom_region->bright_r;
-	*G = zoom_region->bright_g;
-	*B = zoom_region->bright_b;
-}
-
-static void
-impl_zoom_region_set_roi (PortableServer_Servant servant,
-			  const GNOME_Magnifier_RectBounds *bounds,
-			  CORBA_Environment *ev)
-{
-	ZoomRegion *zoom_region =
-		ZOOM_REGION (bonobo_object_from_servant (servant));
+	if (g_strcmp0 (method_name, "setMagFactor") == 0) {
+		gdouble  mag_factor_x, mag_factor_y;
+		gboolean retval;
+
+		g_variant_get (parameters, "(dd)", &mag_factor_x, &mag_factor_y);
+		retval = zoom_region_set_mag_factor (zoom_region, mag_factor_x, mag_factor_y);
+		g_dbus_method_invocation_return_value (invocation,
+						       g_variant_new ("(b)", retval));
+	} else if (g_strcmp0 (method_name, "getMagFactor") == 0) {
+		GVariant *children[2];
+
+		children[0] = g_variant_new_double (zoom_region->xscale);
+		children[1] = g_variant_new_double (zoom_region->yscale);
+		g_dbus_method_invocation_return_value (invocation,
+						       g_variant_new_array (G_VARIANT_TYPE_DOUBLE, children, 2));
+	} else if (g_strcmp0 (method_name, "setRoi") == 0) {
+		RectBounds  bounds;
+		GVariant   *roi;
+		const int  *items;
+		gsize       n_items;
+
+		g_variant_get (parameters, "(@ai)", &roi);
+		items = g_variant_get_fixed_array (roi, &n_items, sizeof (gint32));
+		if (n_items == 4) {
+			bounds.x1 = items[0];
+			bounds.y1 = items[1];
+			bounds.x2 = items[2];
+			bounds.y2 = items[3];
+		}
+		g_variant_unref (roi);
+
+		zoom_region_set_roi (zoom_region, &bounds);
+
+		g_dbus_method_invocation_return_value (invocation, NULL);
+	} else if (g_strcmp0 (method_name, "updatePointer") == 0) {
+		zoom_region_update_cursor (zoom_region, 0, 0, NULL);
+		g_dbus_method_invocation_return_value (invocation, NULL);
+	} else if (g_strcmp0 (method_name, "markDirty") == 0) {
+		RectBounds  roi_dirty;
+		GVariant   *roi;
+		const int  *items;
+		gsize       n_items;
+
+		g_variant_get (parameters, "(@ai)", &roi);
+		items = g_variant_get_fixed_array (roi, &n_items, sizeof (gint32));
+		if (n_items == 4) {
+			roi_dirty.x1 = items[0];
+			roi_dirty.y1 = items[1];
+			roi_dirty.x2 = items[2];
+			roi_dirty.y2 = items[3];
+		}
+		g_variant_unref (roi);
+
+		zoom_region_mark_dirty (zoom_region, &roi_dirty);
+		g_dbus_method_invocation_return_value (invocation, NULL);
+	} else if (g_strcmp0 (method_name, "getRoi") == 0) {
+		GVariant *children[4];
+
+		children[0] = g_variant_new_int32 (zoom_region->roi.x1);
+		children[1] = g_variant_new_int32 (zoom_region->roi.y1);
+		children[2] = g_variant_new_int32 (zoom_region->roi.x2);
+		children[3] = g_variant_new_int32 (zoom_region->roi.y2);
+		g_dbus_method_invocation_return_value (invocation,
+						       g_variant_new_array (G_VARIANT_TYPE_INT32, children, 4));
+	} else if (g_strcmp0 (method_name, "moveResize") == 0) {
+		RectBounds  viewport;
+		GVariant   *viewport_v;
+		const int  *items;
+		gsize       n_items;
+
+		g_variant_get (parameters, "(@ai)", &viewport_v);
+		items = g_variant_get_fixed_array (viewport_v, &n_items, sizeof (gint32));
+		if (n_items == 4) {
+			viewport.x1 = items[0];
+			viewport.y1 = items[1];
+			viewport.x2 = items[2];
+			viewport.y2 = items[3];
+		}
+		g_variant_unref (viewport_v);
 
-#ifdef ZOOM_REGION_DEBUG
-	g_assert (zoom_region->alive);
-#endif
-	DBG (fprintf (stderr, "Set ROI: \t%d,%d %d,%d\n", 
-		      bounds->x1, bounds->y1, bounds->x2, bounds->y2));
+		zoom_region_set_viewport (zoom_region, &viewport);
+		g_dbus_method_invocation_return_value (invocation, NULL);
+	} else if (g_strcmp0 (method_name, "dispose") == 0) {
+		zoom_region_do_dispose (zoom_region);
+		g_dbus_method_invocation_return_value (invocation, NULL);
+	} else if (g_strcmp0 (method_name, "setPointerPos") == 0) {
+		GdkRectangle paint_area, *clip = NULL;
+		gint32 mouse_x, mouse_y;
 
-	if ((zoom_region->roi.x1 == bounds->x1) &&
-	    (zoom_region->roi.x2 == bounds->x2) &&
-	    (zoom_region->roi.y1 == bounds->y1) &&
-	    (zoom_region->roi.y2 == bounds->y2)) {
-	    return;
-	}
+		g_variant_get (parameters, "(ii)", &mouse_x, &mouse_y);
 
-	/* if these bounds are clearly bogus, warn and ignore */
-	if (!bounds || (bounds->x2 <= bounds->x1)
-	    || (bounds->y2 < bounds->y1) || 
-	    ((bounds->x1 + bounds->x2)/2 < 0) || 
-	    ((bounds->y1 + bounds->y2)/2 < 0))
-	{
-	    g_warning ("Bad bounds request (%d,%d to %d,%d), ignoring.\n",
-		       bounds->x1, bounds->y1, bounds->x2, bounds->y2);
-	    return;
-	}
+		DBG (fprintf (stderr, "Set Pointer: \t%ld,%ld\n",
+			      (long) mouse_x, (long) mouse_y));
 
-	zoom_region->roi = *bounds;
+		fprintf (stderr, "Set Pointer: \t%ld,%ld\n",
+			 (long) mouse_x, (long) mouse_y);
 
-	if (zoom_region->timing_pan_rate > 0) {
-		/* Set idle handler to do panning test */
-		g_idle_add_full (GDK_PRIORITY_REDRAW + 3, 
-			zoom_region_pan_test, zoom_region, NULL);
-	}
+		zoom_region_set_cursor_pos (zoom_region, (int) mouse_x, (int) mouse_y);
 
-	if (zoom_region->exit_magnifier) {
-		if (timing_test) {
-			fprintf(stderr, "\n### Timing Summary:\n\n");
-			if (zoom_region->timing_pan_rate)
-				fprintf(stderr, "  Pan Rate                 = %d\n", zoom_region->timing_pan_rate);
-			timing_report(zoom_region);
+		if (GTK_IS_WIDGET (zoom_region) &&
+		    GDK_IS_DRAWABLE (gtk_widget_get_window (GTK_WIDGET (zoom_region))))
+		{
+			gdk_drawable_get_size (
+				GDK_DRAWABLE (
+					gtk_widget_get_window (GTK_WIDGET (zoom_region))),
+				&paint_area.width, &paint_area.height);
+			paint_area.x = 0;
+			paint_area.y = 0;
+			clip = &paint_area;
+			paint_area = zoom_region_clip_to_source (
+				zoom_region, paint_area);
 		}
-		exit(0);
-	}
-
-	/*
-	 * Do not bother trying to update the screen if the last
-	 * screen update has not had time to complete.
-	 */
-	if (processing_updates) {
-		/* Remove any previous idle handler */
-		if (pending_idle_handler != 0) {
-			g_source_remove(pending_idle_handler);
-			pending_idle_handler = 0;
+		/*
+		 * if we update the cursor now, it causes flicker if the client
+		 * subsequently calls setROI, so we wait for a redraw.
+		 * Perhaps we should cue a redraw on idle instead?
+		 */
+		g_dbus_method_invocation_return_value (invocation, NULL);
+	} else if (g_strcmp0 (method_name, "setContrast") == 0) {
+		gdouble R, G, B;
+
+		g_variant_get (parameters, "(ddd)", &R, &G, &B);
+		DBG (fprintf (stderr, "Set contrast: \t%f,%f %f\n", R, G, B));
+
+		/* if the contrast values are the same, this is a NOOP */
+		if (zoom_region->contrast_r == R &&
+		    zoom_region->contrast_g == G &&
+		    zoom_region->contrast_b == B) {
+			g_dbus_method_invocation_return_value (invocation, NULL);
+			return;
 		}
 
-		/* Set idle handler to process this pending update when possible */
+		zoom_region->contrast_r = CLAMP_B_C (R);
+		zoom_region->contrast_g = CLAMP_B_C (G);
+		zoom_region->contrast_b = CLAMP_B_C (B);
 
-		pending_idle_handler = g_idle_add_full (GDK_PRIORITY_REDRAW + 2,
-			zoom_region_process_pending, zoom_region, NULL);
-
-		if (zoom_region->timing_output) {
-			fprintf(stderr,
-				"\n  [Last update not finished, pending - ROI=(%d, %d) (%d, %d)]\n\n",
-				zoom_region->roi.x1, zoom_region->roi.y1, zoom_region->roi.x2,
-				zoom_region->roi.y2);
+		zoom_region_update_current (zoom_region);
+		g_dbus_method_invocation_return_value (invocation, NULL);
+	} else if (g_strcmp0 (method_name, "getContrast") == 0) {
+		GVariant *children[3];
+
+		children[0] = g_variant_new_double (zoom_region->contrast_r);
+		children[1] = g_variant_new_double (zoom_region->contrast_g);
+		children[2] = g_variant_new_double (zoom_region->contrast_b);
+		g_dbus_method_invocation_return_value (invocation,
+						       g_variant_new_array (G_VARIANT_TYPE_DOUBLE, children, 3));
+	} else if (g_strcmp0 (method_name, "setBrightness") == 0) {
+		gdouble R, G, B;
+
+		g_variant_get (parameters, "(ddd)", &R, &G, &B);
+		DBG (fprintf (stderr, "Set brightness: \t%f,%f %f\n", R, G, B));
+
+		/* if the contrast values are the same, this is a NOOP */
+		if (zoom_region->bright_r == R &&
+		    zoom_region->bright_g == G &&
+		    zoom_region->bright_b == B) {
+			g_dbus_method_invocation_return_value (invocation, NULL);
+			return;
 		}
-	} else {
-		zoom_region_align (zoom_region);
-	}
-}
-
-static CORBA_boolean
-impl_zoom_region_set_mag_factor (PortableServer_Servant servant,
-				 const CORBA_float mag_factor_x,
-				 const CORBA_float mag_factor_y,
-				 CORBA_Environment *ev)
-{
-	ZoomRegion *zoom_region =
-		ZOOM_REGION (bonobo_object_from_servant (servant));
 
-#ifdef ZOOM_REGION_DEBUG
-	g_assert (zoom_region->alive);
-#endif
-	CORBA_any *any;
-	CORBA_boolean retval = CORBA_TRUE;
+		zoom_region->bright_r = CLAMP_B_C (R);
+		zoom_region->bright_g = CLAMP_B_C (G);
+		zoom_region->bright_b = CLAMP_B_C (B);
 
-	if ((zoom_region->xscale == mag_factor_x) &&
-	    (zoom_region->yscale == mag_factor_y)) {
-		return retval;
+		zoom_region_update_current (zoom_region);
+		g_dbus_method_invocation_return_value (invocation, NULL);
+	} else if (g_strcmp0 (method_name, "getBrightness") == 0) {
+		GVariant *children[3];
+
+		children[0] = g_variant_new_double (zoom_region->bright_r);
+		children[1] = g_variant_new_double (zoom_region->bright_g);
+		children[2] = g_variant_new_double (zoom_region->bright_b);
+		g_dbus_method_invocation_return_value (invocation,
+						       g_variant_new_array (G_VARIANT_TYPE_DOUBLE, children, 3));
+	}
+}
+
+static GVariant *
+get_property_cb (GDBusConnection *connection,
+		 const gchar     *sender,
+		 const gchar     *object_path,
+		 const gchar     *interface_name,
+		 const gchar     *property_name,
+		 GError         **error,
+		 gpointer         user_data)
+{
+	ZoomRegion *zoom_region = ZOOM_REGION (user_data);
+	GVariant   *retval = NULL;
+
+	if (g_strcmp0 (property_name, "Managed") == 0) {
+		retval = g_variant_new_boolean (zoom_region->is_managed);
+	} else if (g_strcmp0 (property_name, "PollMouse") == 0) {
+		retval = g_variant_new_boolean (zoom_region->poll_mouse);
+	} else if (g_strcmp0 (property_name, "DrawCursor") == 0) {
+		retval = g_variant_new_boolean (zoom_region->draw_cursor);
+	} else if (g_strcmp0 (property_name, "Invert") == 0) {
+		retval = g_variant_new_boolean (zoom_region->invert);
+	} else if (g_strcmp0 (property_name, "Smoothscroll") == 0) {
+		retval = g_variant_new_uint32 (zoom_region->smooth_scroll_policy);
+	} else if (g_strcmp0 (property_name, "Colorblind") == 0) {
+		retval = g_variant_new_uint32 (zoom_region->color_blind_filter);
+	} else if (g_strcmp0 (property_name, "Smoothing") == 0) {
+		retval = g_variant_new_string (zoom_region->smoothing ? zoom_region->smoothing : "");
+	} else if (g_strcmp0 (property_name, "Testpattern") == 0) {
+		retval = g_variant_new_boolean (zoom_region->priv->test);
+	} else if (g_strcmp0 (property_name, "Bordersizes") == 0) {
+		GVariant *children[4];
+
+		children[0] = g_variant_new_int32 (zoom_region->border_size_left);
+		children[1] = g_variant_new_int32 (zoom_region->border_size_top);
+		children[2] = g_variant_new_int32 (zoom_region->border_size_right);
+		children[3] = g_variant_new_int32 (zoom_region->border_size_bottom);
+		retval = g_variant_new_array (G_VARIANT_TYPE_INT32, children, 4);
+	} else if (g_strcmp0 (property_name, "Bordercolor") == 0) {
+		retval = g_variant_new_int32 (zoom_region->border_color);
+	} else if (g_strcmp0 (property_name, "Xalign") == 0) {
+		retval = g_variant_new_int32 (zoom_region->x_align_policy);
+	} else if (g_strcmp0 (property_name, "Yalign") == 0) {
+		retval = g_variant_new_int32 (zoom_region->y_align_policy);
+	} else if (g_strcmp0 (property_name, "Viewport") == 0) {
+		GVariant *children[4];
+
+		children[0] = g_variant_new_int32 (zoom_region->viewport.x1);
+		children[1] = g_variant_new_int32 (zoom_region->viewport.y1);
+		children[2] = g_variant_new_int32 (zoom_region->viewport.x2);
+		children[3] = g_variant_new_int32 (zoom_region->viewport.y2);
+		retval = g_variant_new_array (G_VARIANT_TYPE_INT32, children, 4);
+	} else if (g_strcmp0 (property_name, "TimingTest") == 0) {
+		retval = g_variant_new_int32 (zoom_region->timing_iterations);
+	} else if (g_strcmp0 (property_name, "TimingOutput") == 0) {
+		retval = g_variant_new_boolean (zoom_region->timing_output);
+	} else if (g_strcmp0 (property_name, "TimingPanRate") == 0) {
+		retval = g_variant_new_int32 (zoom_region->timing_pan_rate);
+	} else if (g_strcmp0 (property_name, "ExitMagnifier") == 0) {
+		retval = g_variant_new_boolean (zoom_region->exit_magnifier);
 	}
 
-	/* TODO: assert that parent is magnifier object */
-	Bonobo_PropertyBag properties =
-		GNOME_Magnifier_Magnifier_getProperties(
-			BONOBO_OBJREF (
-				(Magnifier *) zoom_region->priv->parent), ev);
-	any = Bonobo_PropertyBag_getValue (
-		properties, "source-display-bounds", ev);
-	if (!BONOBO_EX (ev))
-		zoom_region->priv->source_area =
-			*((GNOME_Magnifier_RectBounds *) any->_value);
-	else
-		retval = CORBA_FALSE;
-
-	retval = zoom_region_update_scale (zoom_region,
-					   mag_factor_x, mag_factor_y);
-	zoom_region_sync (zoom_region);
-
-	bonobo_object_release_unref (properties, NULL);
 	return retval;
 }
 
-static void
-impl_zoom_region_get_mag_factor (PortableServer_Servant servant,
-				 CORBA_float *mag_factor_x,
-				 CORBA_float *mag_factor_y,
-				 CORBA_Environment *ev)
-{
-	ZoomRegion *zoom_region =
-		ZOOM_REGION (bonobo_object_from_servant (servant));
-
-#ifdef ZOOM_REGION_DEBUG
-	g_assert (zoom_region->alive);
-#endif
-	*mag_factor_x = zoom_region->xscale;
-	*mag_factor_y = zoom_region->yscale;
-}
-
-static Bonobo_PropertyBag
-impl_zoom_region_get_properties (PortableServer_Servant servant,
-				 CORBA_Environment *ev)
-{
-	ZoomRegion *zoom_region =
-		ZOOM_REGION (bonobo_object_from_servant (servant));
-
-#ifdef ZOOM_REGION_DEBUG
-	g_assert (zoom_region->alive);
-#endif
-	return bonobo_object_dup_ref (
-		BONOBO_OBJREF (zoom_region->properties), ev);
-}
-
-static void
-impl_zoom_region_update_pointer (PortableServer_Servant servant,
-				 CORBA_Environment *ev)
-{
-	ZoomRegion *zoom_region =
-		ZOOM_REGION (bonobo_object_from_servant (servant));
-
-#ifdef ZOOM_REGION_DEBUG
-	g_assert (zoom_region->alive);
-#endif
-
-	zoom_region_update_cursor (zoom_region, 0, 0, NULL);
-}
-
-static void
-impl_zoom_region_mark_dirty (PortableServer_Servant servant,
-			     const GNOME_Magnifier_RectBounds *roi_dirty,
-			     CORBA_Environment *ev)
-{
-	ZoomRegion *zoom_region =
-		ZOOM_REGION (bonobo_object_from_servant (servant));
-
-#ifdef ZOOM_REGION_DEBUG
-	g_assert (zoom_region->alive);
-#endif
-	DEBUG_RECT ("mark dirty", zoom_region_rect_from_bounds (
-			    zoom_region, roi_dirty) );
-
-	zoom_region_update_pointer (zoom_region, TRUE);
-	/* XXX ? should we clip here, or wait till process_updates? */
-	zoom_region_queue_update (zoom_region, 
-	  zoom_region_clip_to_source (zoom_region, 
-	      zoom_region_rect_from_bounds (zoom_region, roi_dirty)));
-}
-
-static GNOME_Magnifier_RectBounds
-impl_zoom_region_get_roi (PortableServer_Servant servant,
-			  CORBA_Environment     *ev)
-{
-	ZoomRegion *zoom_region =
-		ZOOM_REGION (bonobo_object_from_servant (servant));
+static gboolean
+set_property_cb (GDBusConnection *connection,
+		 const gchar     *sender,
+		 const gchar     *object_path,
+		 const gchar     *interface_name,
+		 const gchar     *property_name,
+		 GVariant        *value,
+		 GError         **error,
+		 gpointer         user_data)
+{
+	ZoomRegion *zoom_region = ZOOM_REGION (user_data);
+
+	if (g_strcmp0 (property_name, "Managed") == 0) {
+		g_object_set (zoom_region,
+			      "is-managed", g_variant_get_boolean (value),
+			      NULL);
+	} else if (g_strcmp0 (property_name, "PollMouse") == 0) {
+		g_object_set (zoom_region,
+			      "poll-mouse", g_variant_get_boolean (value),
+			      NULL);
+	} else if (g_strcmp0 (property_name, "DrawCursor") == 0) {
+		g_object_set (zoom_region,
+			      "draw-cursor", g_variant_get_boolean (value),
+			      NULL);
+	} else if (g_strcmp0 (property_name, "Invert") == 0) {
+		g_object_set (zoom_region,
+			      "inverse-video", g_variant_get_boolean (value),
+			      NULL);
+	} else if (g_strcmp0 (property_name, "Smoothscroll") == 0) {
+		g_object_set (zoom_region,
+			      "smooth-scroll-policy", g_variant_get_uint32 (value),
+			      NULL);
+	} else if (g_strcmp0 (property_name, "Colorblind") == 0) {
+		g_object_set (zoom_region,
+			      "color-blind-filter", g_variant_get_uint32 (value),
+			      NULL);
+	} else if (g_strcmp0 (property_name, "Smoothing") == 0) {
+		g_object_set (zoom_region,
+			      "smoothing-type", g_variant_get_string (value, NULL),
+			      NULL);
+	} else if (g_strcmp0 (property_name, "Testpattern") == 0) {
+		g_object_set (zoom_region,
+			      "use-test-pattern", g_variant_get_boolean (value),
+			      NULL);
+	} else if (g_strcmp0 (property_name, "Bordersizes") == 0) {
+		const int *items;
+		gsize      n_items;
+
+		items = g_variant_get_fixed_array (value, &n_items, sizeof (gint32));
+		if (n_items == 4) {
+			g_object_set (zoom_region,
+				      "border-size-left", items[0],
+				      "border-size-top", items[1],
+				      "border-size-right", items[2],
+				      "border-size-bottom", items[3],
+				      NULL);
+		}
+	} else if (g_strcmp0 (property_name, "Bordercolor") == 0) {
+		g_object_set (zoom_region,
+			      "border-color", g_variant_get_int32 (value),
+			      NULL);
+	} else if (g_strcmp0 (property_name, "Xalign") == 0) {
+		g_object_set (zoom_region,
+			      "x-alignment", g_variant_get_int32 (value),
+			      NULL);
+	} else if (g_strcmp0 (property_name, "Yalign") == 0) {
+		g_object_set (zoom_region,
+			      "y-alignment", g_variant_get_int32 (value),
+			      NULL);
+	} else if (g_strcmp0 (property_name, "Viewport") == 0) {
+		const int *items;
+		gsize      n_items;
+		RectBounds viewport;
+
+		items = g_variant_get_fixed_array (value, &n_items, sizeof (gint32));
+		if (n_items == 4) {
+			viewport.x1 = items[0];
+			viewport.y1 = items[1];
+			viewport.x2 = items[2];
+			viewport.y2 = items[3];
+		}
+		g_object_set (zoom_region, "viewport", &viewport, NULL);
+	} else if (g_strcmp0 (property_name, "TimingTest") == 0) {
+		g_object_set (zoom_region,
+			      "timing-iterations", g_variant_get_int32 (value),
+			      NULL);
+	} else if (g_strcmp0 (property_name, "TimingOutput") == 0) {
+		g_object_set (zoom_region,
+			      "timing-output", g_variant_get_boolean (value),
+			      NULL);
+	} else if (g_strcmp0 (property_name, "TimingPanRate") == 0) {
+		g_object_set (zoom_region,
+			      "timing-pan-rate", g_variant_get_int32 (value),
+			      NULL);
+	} else if (g_strcmp0 (property_name, "ExitMagnifier") == 0) {
+		g_object_set (zoom_region,
+			      "exit-magnifier", g_variant_get_boolean (value),
+			      NULL);
+	}
 
-#ifdef ZOOM_REGION_DEBUG
-	g_assert (zoom_region->alive);
-#endif
-	return zoom_region->roi;
+	return TRUE;
 }
 
-static void
-impl_zoom_region_move_resize (PortableServer_Servant            servant,
-			      const GNOME_Magnifier_RectBounds *viewport_bounds,
-			      CORBA_Environment                *ev)
-{
-	ZoomRegion *zoom_region =
-		ZOOM_REGION (bonobo_object_from_servant (servant));
+static const gchar introspection_xml[] =
+"<node>"
+  "<interface name='org.freedesktop.gnome.Magnifier.ZoomRegion'>"
+    "<method name='setMagFactor'>"
+      "<arg type='d' name='magX' direction='in'/>"
+      "<arg type='d' name='magY' direction='in'/>"
+      "<arg type='b' name='b_ret' direction='out'/>"
+    "</method>"
+    "<method name='getMagFactor'>"
+      "<arg type='ad' name='factors' direction='out'/>"
+    "</method>"
+    "<method name='setRoi'>"
+      "<arg type='ai' name='Roi' direction='in'/>"
+    "</method>"
+    "<method name='updatePointer'/>"
+    "<method name='markDirty'>"
+      "<arg type='ai' name='dirtyRegion' direction='in'/>"
+    "</method>"
+    "<method name='getRoi'>"
+      "<arg type='ai' name='Roi-ret' direction='out'/>"
+    "</method>"
+    "<method name='moveResize'>"
+      "<arg type='ai' name='bounds' direction='in'/>"
+    "</method>"
+    "<method name='dispose'/>"
+    "<method name='setPointerPos'>"
+      "<arg type='i' name='mouse_x' direction='in'/>"
+      "<arg type='i' name='mouse_y' direction='in'/>"
+    "</method>"
+    "<method name='setContrast'>"
+      "<arg type='d' name='R' direction='in'/>"
+      "<arg type='d' name='G' direction='in'/>"
+      "<arg type='d' name='B' direction='in'/>"
+    "</method>"
+    "<method name='getContrast'>"
+      "<arg type='ad' name='RGB' direction='out'/>"
+    "</method>"
+    "<method name='setBrightness'>"
+      "<arg type='d' name='R' direction='in'/>"
+      "<arg type='d' name='G' direction='in'/>"
+      "<arg type='d' name='B' direction='in'/>"
+    "</method>"
+    "<method name='getBrightness'>"
+      "<arg type='d' name='RGB' direction='out'/>"
+    "</method>"
+    "<property name='Managed' type='b' access='readwrite'/>"
+    "<property name='PollMouse' type='b' access='readwrite'/>"
+    "<property name='DrawCursor' type='b' access='readwrite'/>"
+    "<property name='Invert' type='b' access='readwrite'/>"
+    "<property name='Smoothscroll' type='u' access='readwrite'/>"
+    "<property name='Colorblind' type='u' access='readwrite'/>"
+    "<property name='Smoothing' type='s' access='readwrite'/>"
+    "<property name='Testpattern' type='b' access='readwrite'/>"
+    "<property name='Bordersizes' type='ai' access='readwrite'/>"
+    "<property name='Bordercolor' type='i' access='readwrite'/>"
+    "<property name='Xalign' type='i' access='readwrite'/>"
+    "<property name='Yalign' type='i' access='readwrite'/>"
+    "<property name='Viewport' type='ai' access='readwrite'/>"
+    "<property name='TimingTest' type='i' access='readwrite'/>"
+    "<property name='TimingOutput' type='b' access='readwrite'/>"
+    "<property name='TimingPanRate' type='i' access='readwrite'/>"
+    "<property name='ExitMagnifier' type='b' access='readwrite'/>"
+  "</interface>"
+"</node>";
+
+static const GDBusInterfaceVTable interface_vtable = {
+	method_call_cb,
+	get_property_cb,
+	set_property_cb
+};
 
-#ifdef ZOOM_REGION_DEBUG
-	g_assert (zoom_region->alive);
-#endif
-	zoom_region_set_viewport (zoom_region, viewport_bounds);
-}
+static GDBusNodeInfo *introspection_data = NULL;
 
 /* could be called multiple times... */
 static void
 zoom_region_do_dispose (ZoomRegion *zoom_region)
 {
 	DBG(g_message ("disposing region %p", zoom_region));
-	if (zoom_region->priv && zoom_region->priv->expose_handler_id && 
-	    GTK_IS_WIDGET (zoom_region->priv->w)) {
-		g_signal_handler_disconnect (
-			zoom_region->priv->w,
-			zoom_region->priv->expose_handler_id);
-		zoom_region->priv->expose_handler_id = 0;
-	}
+
 	if (zoom_region->priv && zoom_region->priv->update_pointer_id)
 	    g_source_remove (zoom_region->priv->update_pointer_id);
 	if (zoom_region->priv && zoom_region->priv->update_handler_id)
@@ -3501,799 +3016,592 @@ zoom_region_do_dispose (ZoomRegion *zoom_region)
 #endif
 }
 
+/* this one really shuts down the object - called once only */
 static void
-impl_zoom_region_dispose (PortableServer_Servant servant,
-			  CORBA_Environment     *ev)
-{
-	ZoomRegion *zoom_region =
-		ZOOM_REGION (bonobo_object_from_servant (servant));
-	zoom_region_do_dispose (zoom_region);
-}
-
-gboolean
-impl_dbus_zoom_region_dispose (ZoomRegion *zoom_region)
-{
-	zoom_region_do_dispose (zoom_region);
-	
-	return TRUE;
-}
-
-gboolean
-impl_dbus_zoom_region_set_mag_factor (ZoomRegion *zoom_region, const gdouble mag_factor_x, const gdouble mag_factor_y)
-{
-#ifdef ZOOM_REGION_DEBUG
-	g_assert (zoom_region->alive);
-#endif
-	CORBA_Environment ev;
-	CORBA_exception_init (&ev);
-	CORBA_any *any;
-	gboolean retval = TRUE;
-
-	if ((zoom_region->xscale == mag_factor_x) &&
-	    (zoom_region->yscale == mag_factor_y)) {
-		return retval;
-	}
-	
-	/* TODO: assert that parent is magnifier object */
-	Bonobo_PropertyBag properties =
-		GNOME_Magnifier_Magnifier_getProperties(
-			BONOBO_OBJREF (
-				(Magnifier *) zoom_region->priv->parent), &ev);
-	any = Bonobo_PropertyBag_getValue (
-		properties, "source-display-bounds", &ev);
-	if (!BONOBO_EX (&ev))
-		zoom_region->priv->source_area =
-			*((GNOME_Magnifier_RectBounds *) any->_value);
-	else {
-		retval = FALSE;
-		return retval;
-	}
-
-	retval = zoom_region_update_scale (zoom_region, mag_factor_x, mag_factor_y);
-	zoom_region_sync (zoom_region);
-
-	return retval;
-}
-
-GArray*
-impl_dbus_zoom_region_get_mag_factor (ZoomRegion *zoom_region)
-{
-	GArray *ret;
-	
-	ret = g_array_new (FALSE, FALSE, sizeof (gdouble));
-	
-	g_array_append_val (ret, zoom_region->xscale);
-	g_array_append_val (ret, zoom_region->yscale);
-
-	return ret;
-}
-
-gboolean
-impl_dbus_zoom_region_set_roi (ZoomRegion *zoom_region, const gint32 **roi)
+zoom_region_finalize (GObject *region)
 {
-	RectBounds *bounds = g_malloc(sizeof(RectBounds));
-	_set_bounds (bounds, roi);
+	ZoomRegion *zoom_region = (ZoomRegion *) region;
 
-	#ifdef ZOOM_REGION_DEBUG
-	g_assert (zoom_region->alive);
-#endif
-	DBG (fprintf (stderr, "Set ROI: \t%d,%d %d,%d\n", 
-		      bounds->x1, bounds->y1, bounds->x2, bounds->y2));
+	DBG(g_message ("finalizing region %p", zoom_region));
 
-	if ((zoom_region->roi.x1 == bounds->x1) &&
-	    (zoom_region->roi.x2 == bounds->x2) &&
-	    (zoom_region->roi.y1 == bounds->y1) &&
-	    (zoom_region->roi.y2 == bounds->y2)) {
-	    return TRUE;
+	if (zoom_region->priv && zoom_region->priv->dbus_object_id > 0) {
+		g_dbus_connection_unregister_object (dbus_connection, zoom_region->priv->dbus_object_id);
+		zoom_region->priv->dbus_object_id = 0;
 	}
 
-	/* if these bounds are clearly bogus, warn and ignore */
-	if (!bounds || (bounds->x2 <= bounds->x1)
-	    || (bounds->y2 < bounds->y1) || 
-	    ((bounds->x1 + bounds->x2)/2 < 0) || 
-	    ((bounds->y1 + bounds->y2)/2 < 0))
+	if (zoom_region->priv && zoom_region->priv->q)
 	{
-	    g_warning ("Bad bounds request (%d,%d to %d,%d), ignoring.\n",
-		       bounds->x1, bounds->y1, bounds->x2, bounds->y2);
-	    return FALSE;
-	}
-
-	zoom_region->roi.x1 = bounds->x1;
-	zoom_region->roi.y1 = bounds->y1;
-	zoom_region->roi.x2 = bounds->x2;
-	zoom_region->roi.y2 = bounds->y2;
-
-	if (zoom_region->timing_pan_rate > 0) {
-		/* Set idle handler to do panning test */
-		g_idle_add_full (GDK_PRIORITY_REDRAW + 3, 
-			zoom_region_pan_test, zoom_region, NULL);
-	}
-
-	if (zoom_region->exit_magnifier) {
-		if (timing_test) {
-			fprintf(stderr, "\n### Timing Summary:\n\n");
-			if (zoom_region->timing_pan_rate)
-				fprintf(stderr, "  Pan Rate                 = %d\n", zoom_region->timing_pan_rate);
-			timing_report(zoom_region);
-		}
-		exit(0);
-	}
-
-	/*
-	 * Do not bother trying to update the screen if the last
-	 * screen update has not had time to complete.
-	 */
-	if (processing_updates) {
-		/* Remove any previous idle handler */
-		if (pending_idle_handler != 0) {
-			g_source_remove(pending_idle_handler);
-			pending_idle_handler = 0;
-		}
-
-		/* Set idle handler to process this pending update when possible */
-
-		pending_idle_handler = g_idle_add_full (GDK_PRIORITY_REDRAW + 2,
-			zoom_region_process_pending, zoom_region, NULL);
-
-		if (zoom_region->timing_output) {
-			fprintf(stderr,
-				"\n  [Last update not finished, pending - ROI=(%d, %d) (%d, %d)]\n\n",
-				zoom_region->roi.x1, zoom_region->roi.y1, zoom_region->roi.x2,
-				zoom_region->roi.y2);
-		}
-	} else {
-		zoom_region_align (zoom_region);
+		g_list_free (zoom_region->priv->q);
+		zoom_region->priv->q = NULL;
 	}
-	
-	return TRUE;
-}
-
-/* TODO: Deprecate this RPC */
-gboolean
-impl_dbus_zoom_region_update_pointer (ZoomRegion *zoom_region)
-{
-#ifdef ZOOM_REGION_DEBUG
-	g_assert (zoom_region->alive);
-#endif
-
-	zoom_region_update_cursor (zoom_region, 0, 0, NULL);
-	
-	return TRUE;
-}
-
-gboolean
-impl_dbus_zoom_region_mark_dirty (ZoomRegion *zoom_region, gint32 **bounds)
-{
-	GNOME_Magnifier_RectBounds *roi_dirty = g_malloc(sizeof(GNOME_Magnifier_RectBounds));
-	roi_dirty->x1 = (*bounds)[0];
-	roi_dirty->y1 = (*bounds)[1];
-	roi_dirty->x2 = (*bounds)[2];
-	roi_dirty->y2 = (*bounds)[3];
-
+	if (GTK_IS_WIDGET (zoom_region))
+		gtk_container_remove (GTK_CONTAINER (((Magnifier *) zoom_region->priv->parent)->priv->canvas), GTK_WIDGET (zoom_region));
+	if (GTK_IS_WIDGET (zoom_region->priv->border))
+		gtk_container_remove (GTK_CONTAINER (((Magnifier *) zoom_region->priv->parent)->priv->canvas), GTK_WIDGET (zoom_region->priv->border));
+	if (zoom_region->priv->source_pixbuf_cache)
+	    g_object_unref (zoom_region->priv->source_pixbuf_cache);
+	if (zoom_region->priv->scaled_pixbuf)
+	    g_object_unref (zoom_region->priv->scaled_pixbuf);
+	if (zoom_region->priv->pixmap)
+	    g_object_unref (zoom_region->priv->pixmap);
+	zoom_region->priv->pixmap = NULL;
+	zoom_region->priv->parent = NULL;
+	if (zoom_region->priv->cursor_backing_pixels)
+	    g_object_unref (zoom_region->priv->cursor_backing_pixels);
+	g_free (zoom_region->priv);
+	zoom_region->priv = NULL;
 #ifdef ZOOM_REGION_DEBUG
-	g_assert (zoom_region->alive);
+	zoom_region->alive = FALSE;
 #endif
-	DEBUG_RECT ("mark dirty", zoom_region_rect_from_bounds (
-			    zoom_region, roi_dirty) );
-
-	zoom_region_update_pointer (zoom_region, TRUE);
-	/* XXX ? should we clip here, or wait till process_updates? */
-	zoom_region_queue_update (zoom_region, 
-	  zoom_region_clip_to_source (zoom_region, 
-	      zoom_region_rect_from_bounds (zoom_region, roi_dirty)));
-
-	return TRUE;
+	G_OBJECT_CLASS (zoom_region_parent_class)->finalize (region);
 }
 
-GArray*
-impl_dbus_zoom_region_get_roi (ZoomRegion *zoom_region)
+/* could be called multiple times */
+static void
+zoom_region_dispose (GObject *object)
 {
-	GArray *ret;
-	
-	ret = g_array_new (FALSE, FALSE, sizeof (gint32));
-	
-	g_array_append_val (ret, zoom_region->roi.x1);
-	g_array_append_val (ret, zoom_region->roi.y1);
-	g_array_append_val (ret, zoom_region->roi.x2);
-	g_array_append_val (ret, zoom_region->roi.y2);
-	
-	return ret;
-}
+	zoom_region_do_dispose (ZOOM_REGION (object));
 
-gboolean
-impl_dbus_zoom_region_move_resize (ZoomRegion *zoom_region, const gint32 **viewport)
-{
-#ifdef ZOOM_REGION_DEBUG
-	g_assert (zoom_region->alive);
-#endif
-	GNOME_Magnifier_RectBounds *viewport_bounds = g_malloc (sizeof (GNOME_Magnifier_RectBounds));
-	viewport_bounds->x1 = (*viewport)[0];
-	viewport_bounds->y1 = (*viewport)[1];
-	viewport_bounds->x2 = (*viewport)[2];
-	viewport_bounds->y2 = (*viewport)[3];
-
-	zoom_region_set_viewport (zoom_region, viewport_bounds);
-
-	return TRUE;
+	G_OBJECT_CLASS (zoom_region_parent_class)->dispose (object);
 }
 
-gboolean
-impl_dbus_zoom_region_set_pointer_pos (ZoomRegion *zoom_region, gint32 mouse_x, gint32 mouse_y)
+static void
+zoom_region_get_property (GObject    *object,
+			  guint       prop_id,
+			  GValue     *value,
+			  GParamSpec *pspec)
 {
-	GdkRectangle paint_area, *clip = NULL;
+	ZoomRegion *zoom_region = ZOOM_REGION (object);
 
 #ifdef ZOOM_REGION_DEBUG
 	g_assert (zoom_region->alive);
 #endif
-	DBG (fprintf (stderr, "Set Pointer: \t%ld,%ld\n", 
-		      (long) mouse_x, (long) mouse_y));
+	DBG (fprintf (stderr, "Get zoom-region property: %s\n", g_param_spec_get_name (pspec)));
 
-	fprintf (stderr, "Set Pointer: \t%ld,%ld\n", 
-		      (long) mouse_x, (long) mouse_y);
-
-	zoom_region_set_cursor_pos (zoom_region, (int) mouse_x, (int) mouse_y);
+	switch (prop_id) {
+	case ZOOM_REGION_MANAGED_PROP:
+		g_value_set_boolean (value, zoom_region->is_managed);
+		break;
+	case ZOOM_REGION_POLL_MOUSE_PROP:
+		g_value_set_boolean (value, zoom_region->poll_mouse);
+		break;
+	case ZOOM_REGION_DRAW_CURSOR_PROP:
+		g_value_set_boolean (value, zoom_region->draw_cursor);
+		break;
+	case ZOOM_REGION_INVERT_PROP:
+		g_value_set_boolean (value, zoom_region->invert);
+		break;
+	case ZOOM_REGION_SMOOTHSCROLL_PROP:
+		g_value_set_uint (value, zoom_region->smooth_scroll_policy);
+		break;
+	case ZOOM_REGION_COLORBLIND_PROP:
+		g_value_set_uint (value, zoom_region->color_blind_filter);
+		break;
+	case ZOOM_REGION_TESTPATTERN_PROP:
+		g_value_set_boolean (value, zoom_region->priv->test);
+		break;
+	case ZOOM_REGION_SMOOTHING_PROP:
+		g_value_set_string (value, zoom_region->smoothing);
+		break;
+	case ZOOM_REGION_CONTRASTR_PROP:
+		g_value_set_float (value, zoom_region->contrast_r);
+		break;
+	case ZOOM_REGION_CONTRASTG_PROP:
+		g_value_set_float (value, zoom_region->contrast_g);
+		break;
+	case ZOOM_REGION_CONTRASTB_PROP:
+		g_value_set_float (value, zoom_region->contrast_b);
+		break;
+	case ZOOM_REGION_BRIGHTR_PROP:
+		g_value_set_float (value, zoom_region->bright_r);
+		break;
+	case ZOOM_REGION_BRIGHTG_PROP:
+		g_value_set_float (value, zoom_region->bright_g);
+		break;
+	case ZOOM_REGION_BRIGHTB_PROP:
+		g_value_set_float (value, zoom_region->bright_b);
+		break;
+	case ZOOM_REGION_XSCALE_PROP:
+		g_value_set_float (value, zoom_region->xscale);
+		break;
+	case ZOOM_REGION_YSCALE_PROP:
+		g_value_set_float (value, zoom_region->yscale);
+		break;
+	case ZOOM_REGION_BORDERSIZE_PROP:
+		g_value_set_long (value, (zoom_region->border_size_top +
+					  zoom_region->border_size_left +
+					  zoom_region->border_size_right +
+					  zoom_region->border_size_bottom) / 4);
+		break;
+	case ZOOM_REGION_BORDERSIZETOP_PROP:
+		g_value_set_long (value, zoom_region->border_size_top);
+		break;
+	case ZOOM_REGION_BORDERSIZELEFT_PROP:
+		g_value_set_long (value, zoom_region->border_size_left);
+		break;
+	case ZOOM_REGION_BORDERSIZERIGHT_PROP:
+		g_value_set_long (value, zoom_region->border_size_right);
+		break;
+	case ZOOM_REGION_BORDERSIZEBOTTOM_PROP:
+		g_value_set_long (value, zoom_region->border_size_bottom);
+		break;
+	case ZOOM_REGION_XALIGN_PROP:
+		/* TODO: enums here */
+		g_value_set_int (value, zoom_region->x_align_policy);
+		break;
+	case ZOOM_REGION_YALIGN_PROP:
+		g_value_set_int (value, zoom_region->y_align_policy);
+		break;
+	case ZOOM_REGION_BORDERCOLOR_PROP:
+		g_value_set_long (value, zoom_region->border_color);
+		break;
+	case ZOOM_REGION_VIEWPORT_PROP: {
+		RectBounds *rect = g_new (RectBounds, 1);
 
-	if (GTK_IS_WIDGET (zoom_region->priv->w) && 
-	    GDK_IS_DRAWABLE (gtk_widget_get_window (zoom_region->priv->w)))
-	{
-	    gdk_drawable_get_size (
-		GDK_DRAWABLE (
-		    gtk_widget_get_window (zoom_region->priv->w)),
-		&paint_area.width, &paint_area.height);
-	    paint_area.x = 0;
-	    paint_area.y = 0;
-	    clip = &paint_area;
-	    paint_area = zoom_region_clip_to_source (
-		zoom_region, paint_area);
+		*rect = zoom_region->viewport;
+		g_value_set_pointer (value, rect);
+	}
+		break;
+	case ZOOM_REGION_TIMING_TEST_PROP:
+		g_value_set_int (value, zoom_region->timing_iterations);
+		break;
+	case ZOOM_REGION_TIMING_OUTPUT_PROP:
+		g_value_set_boolean (value, zoom_region->timing_output);
+		break;
+	case ZOOM_REGION_TIMING_PAN_RATE_PROP:
+		g_value_set_int (value, zoom_region->timing_pan_rate);
+		break;
+	case ZOOM_REGION_EXIT_MAGNIFIER:
+		g_value_set_boolean (value, zoom_region->exit_magnifier);
+		break;
+	default:
+		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 	}
-	/* 
-	 * if we update the cursor now, it causes flicker if the client 
-	 * subsequently calls setROI, so we wait for a redraw.
-	 * Perhaps we should cue a redraw on idle instead?
-	 */
-
-	return TRUE;
 }
 
-gboolean
-impl_dbus_zoom_region_set_contrast (ZoomRegion *zoom_region, gdouble R, gdouble G, gdouble B)
+static void
+zoom_region_set_property (GObject      *object,
+			  guint         prop_id,
+			  const GValue *value,
+			  GParamSpec   *pspec)
 {
+	ZoomRegion *zoom_region = ZOOM_REGION (object);
 	gfloat t;
 
 #ifdef ZOOM_REGION_DEBUG
 	g_assert (zoom_region->alive);
 #endif
-	DBG (fprintf (stderr, "Set contrast: \t%f,%f %f\n", R, G, B));
-
-	/* if the contrast values are the same, this is a NOOP */
-	if (zoom_region->contrast_r == R &&
-	    zoom_region->contrast_g == G &&
-	    zoom_region->contrast_b == B)
-		return TRUE;
-
-	zoom_region->contrast_r = CLAMP_B_C (R);
-	zoom_region->contrast_g = CLAMP_B_C (G);
-	zoom_region->contrast_b = CLAMP_B_C (B);
+	DBG (fprintf (stderr, "Set zoom-region property: %s\n", g_param_spec_get_name (pspec)));
 
-	zoom_region_update_current (zoom_region);
+	switch (prop_id) {
+	case ZOOM_REGION_MANAGED_PROP:
+		zoom_region->is_managed = g_value_get_boolean (value);
+		break;
+	case ZOOM_REGION_POLL_MOUSE_PROP:
+		zoom_region->poll_mouse = g_value_get_boolean (value);
+		if (zoom_region->poll_mouse)
+		{
+		    g_message ("Adding polling timer");
+		    zoom_region->priv->update_pointer_id =
+			g_timeout_add_full (G_PRIORITY_DEFAULT_IDLE,
+					    200,
+					    zoom_region_update_pointer_timeout,
+					    zoom_region,
+					    NULL);
+		}
+		else if (zoom_region->priv->update_pointer_id)
+		{
+		    g_message ("Removing polling timer");
+		    g_source_remove (zoom_region->priv->update_pointer_id);
+		    zoom_region->priv->update_pointer_id = 0;
+		}
+		break;
+	case ZOOM_REGION_DRAW_CURSOR_PROP:
+		zoom_region->draw_cursor = g_value_get_boolean (value);
+		if (!zoom_region->draw_cursor)
+			zoom_region_unpaint_cursor (zoom_region, NULL);
+		break;
+	case ZOOM_REGION_INVERT_PROP:
+		zoom_region->invert = g_value_get_boolean (value);
+		zoom_region_update_current (zoom_region);
+		break;
+	case ZOOM_REGION_SMOOTHSCROLL_PROP:
+		zoom_region->smooth_scroll_policy = g_value_get_uint (value);
+		break;
+	case ZOOM_REGION_COLORBLIND_PROP:
+		zoom_region->color_blind_filter = g_value_get_uint (value);
+		zoom_region_update_current (zoom_region);
+		break;
+	case ZOOM_REGION_SMOOTHING_PROP:
+		zoom_region->smoothing = g_value_dup_string (value);
+		if (!strncmp (zoom_region->smoothing, "bilinear", 8))
+			zoom_region->priv->gdk_interp_type = GDK_INTERP_BILINEAR;
+		else
+			zoom_region->priv->gdk_interp_type = GDK_INTERP_NEAREST;
+		zoom_region_update_current (zoom_region);
+		break;
+	case ZOOM_REGION_TESTPATTERN_PROP:
+		zoom_region->priv->test = g_value_get_boolean (value);
+		if (zoom_region->priv->source_drawable) {
+			g_object_unref (zoom_region->priv->source_drawable);
+			zoom_region->priv->source_drawable = NULL;
+		}
+		zoom_region_update_current (zoom_region);
+		break;
+	case ZOOM_REGION_CONTRASTR_PROP:
+		zoom_region->contrast_r =
+			CLAMP_B_C (g_value_get_float (value));
+		zoom_region_update_current (zoom_region);
+		break;
+	case ZOOM_REGION_CONTRASTG_PROP:
+		zoom_region->contrast_g =
+			CLAMP_B_C (g_value_get_float (value));
+		zoom_region_update_current (zoom_region);
+		break;
+	case ZOOM_REGION_CONTRASTB_PROP:
+		zoom_region->contrast_b =
+			CLAMP_B_C (g_value_get_float (value));
+		zoom_region_update_current (zoom_region);
+		break;
+	case ZOOM_REGION_BRIGHTR_PROP:
+		zoom_region->bright_r =
+			CLAMP_B_C (g_value_get_float (value));
+		zoom_region_update_current (zoom_region);
+		break;
+	case ZOOM_REGION_BRIGHTG_PROP:
+		zoom_region->bright_g =
+			CLAMP_B_C (g_value_get_float (value));
+		zoom_region_update_current (zoom_region);
+		break;
+	case ZOOM_REGION_BRIGHTB_PROP:
+		zoom_region->bright_b =
+			CLAMP_B_C (g_value_get_float (value));
+		zoom_region_update_current (zoom_region);
+		break;
+	case ZOOM_REGION_XSCALE_PROP:
+		(void) zoom_region_update_scale (zoom_region,
+						 g_value_get_float (value),
+						 zoom_region->yscale);
+		break;
+	case ZOOM_REGION_YSCALE_PROP:
+		(void) zoom_region_update_scale (zoom_region,
+						 zoom_region->xscale,
+						 g_value_get_float (value));
+		break;
+	case ZOOM_REGION_BORDERSIZE_PROP:
+		zoom_region->border_size_left =
+			zoom_region->border_size_top =
+			zoom_region->border_size_right =
+			zoom_region->border_size_bottom =
+			g_value_get_long (value);
+		zoom_region_update_borders (zoom_region);
+		break;
+	case ZOOM_REGION_BORDERSIZELEFT_PROP:
+		zoom_region->border_size_left = g_value_get_long (value);
+		zoom_region_update_borders (zoom_region);
+		break;
+	case ZOOM_REGION_BORDERSIZETOP_PROP:
+		zoom_region->border_size_top = g_value_get_long (value);
+		zoom_region_update_borders (zoom_region);
+		break;
+	case ZOOM_REGION_BORDERSIZERIGHT_PROP:
+		zoom_region->border_size_right = g_value_get_long (value);
+		zoom_region_update_borders (zoom_region);
+		break;
+	case ZOOM_REGION_BORDERSIZEBOTTOM_PROP:
+		zoom_region->border_size_bottom = g_value_get_long (value);
+		zoom_region_update_borders (zoom_region);
+		break;
+	case ZOOM_REGION_BORDERCOLOR_PROP:
+		zoom_region->border_color = g_value_get_long (value);
+		zoom_region_paint_border (zoom_region);
+		break;
+	case ZOOM_REGION_XALIGN_PROP:
+		zoom_region->x_align_policy = g_value_get_int (value);
+		zoom_region_align (zoom_region);
+		break;
+	case ZOOM_REGION_YALIGN_PROP:
+		/* TODO: enums here */
+		zoom_region->y_align_policy = g_value_get_int (value);
+		zoom_region_align (zoom_region);
+		break;
+	case ZOOM_REGION_VIEWPORT_PROP: {
+		RectBounds *bounds = g_value_get_pointer (value);
 
-	return TRUE;
+		zoom_region_set_viewport (zoom_region, bounds);
+	}
+		break;
+	case ZOOM_REGION_TIMING_TEST_PROP:
+		zoom_region->timing_iterations = g_value_get_int (value);
+		timing_test = TRUE;
+		break;
+	case ZOOM_REGION_TIMING_OUTPUT_PROP:
+		zoom_region->timing_output = g_value_get_boolean (value);
+		break;
+	case ZOOM_REGION_TIMING_PAN_RATE_PROP:
+		zoom_region->timing_pan_rate = g_value_get_int (value);
+		timing_test = TRUE;
+		break;
+	case ZOOM_REGION_EXIT_MAGNIFIER:
+		zoom_region->exit_magnifier = g_value_get_boolean (value);
+		break;
+	default:
+		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+	}
 }
 
-GArray*
-impl_dbus_zoom_region_get_contrast (ZoomRegion *zoom_region)
+static gboolean
+zoom_region_expose (GtkWidget      *w,
+		    GdkEventExpose *event)
 {
-	GArray *ret;
-	
-	ret = g_array_new (FALSE, FALSE, sizeof (gdouble));
-	
-	g_array_append_val (ret, zoom_region->contrast_r);
-	g_array_append_val (ret, zoom_region->contrast_g);
-	g_array_append_val (ret, zoom_region->contrast_b);
-	
-	return ret;
-}
+	ZoomRegion *zoom_region = ZOOM_REGION (w);
+	DEBUG_RECT ("expose", event->area);
 
-gboolean
-impl_dbus_zoom_region_set_brightness (ZoomRegion *zoom_region, gdouble R, gdouble G, gdouble B)
-{
-	gfloat t;
+	if (!gtk_widget_get_visible (w))
+		return FALSE;
 
 #ifdef ZOOM_REGION_DEBUG
 	g_assert (zoom_region->alive);
 #endif
-	DBG (fprintf (stderr, "Set brightness: \t%f,%f %f\n", R, G, B));
-
-	/* if the contrast values are the same, this is a NOOP */
-	if (zoom_region->bright_r == R &&
-	    zoom_region->bright_g == G &&
-	    zoom_region->bright_b == B)
-		return TRUE;
-
-	zoom_region->bright_r = CLAMP_B_C (R);
-	zoom_region->bright_g = CLAMP_B_C (G);
-	zoom_region->bright_b = CLAMP_B_C (B);
+	if (zoom_region->priv->pixmap == NULL)
+	{
+		ZoomRegionPixmapCreationError ret;
+		/* TODO: scale down if this fails here */
+		while ((ret = zoom_region_create_pixmap (zoom_region)) ==
+		       ZOOM_REGION_ERROR_TOO_BIG) {
+			zoom_region->xscale -= 1.0;
+			zoom_region->yscale -= 1.0;
+			zoom_region->priv->pixmap = NULL;
+			g_warning ("Scale factor too big to fit in memory; shrinking.");
+		}
+		if (ret == ZOOM_REGION_ERROR_NO_TARGET_DRAWABLE)
+			g_warning ("create-pixmap: no target drawable");
+		else
+			zoom_region_update_pixmap (zoom_region, event->area,
+						   NULL);
+	}
+	zoom_region_paint (zoom_region, &event->area);
 
-	zoom_region_update_current (zoom_region);
-	
 	return TRUE;
 }
 
-GArray*
-impl_dbus_zoom_region_get_brightness (ZoomRegion *zoom_region)
-{
-	GArray *ret;
-	
-	ret = g_array_new (FALSE, FALSE, sizeof (gdouble));
-	
-	g_array_append_val (ret, zoom_region->bright_r);
-	g_array_append_val (ret, zoom_region->bright_g);
-	g_array_append_val (ret, zoom_region->bright_b);
-	
-	return ret;
-}
-
-/* could be called multiple times */
-static void
-zoom_region_dispose (GObject *object)
-{
-	ZoomRegion *zoom_region = ZOOM_REGION (object);
-
-	zoom_region_do_dispose (zoom_region);
-
-	BONOBO_CALL_PARENT (G_OBJECT_CLASS, dispose, (object));
-}
-
 static void
 zoom_region_class_init (ZoomRegionClass *klass)
 {
 	GObjectClass * object_class = (GObjectClass *) klass;
-	POA_GNOME_Magnifier_ZoomRegion__epv *epv = &klass->epv;
-	parent_class = g_type_class_peek (BONOBO_TYPE_OBJECT); /* needed by BONOBO_CALL_PARENT! */
+	GtkWidgetClass *widget_class = (GtkWidgetClass *) klass;
 
 	object_class->dispose = zoom_region_dispose;
 	object_class->finalize = zoom_region_finalize;
-	
-	epv->setMagFactor = impl_zoom_region_set_mag_factor;
-	epv->getMagFactor = impl_zoom_region_get_mag_factor;
-	epv->getProperties = impl_zoom_region_get_properties;
-	epv->setROI = impl_zoom_region_set_roi;
-	epv->setPointerPos = impl_zoom_region_set_pointer_pos;
-	epv->updatePointer = impl_zoom_region_update_pointer;
-	epv->markDirty = impl_zoom_region_mark_dirty;
-	epv->getROI = impl_zoom_region_get_roi;
-	epv->moveResize = impl_zoom_region_move_resize;
-	epv->dispose = impl_zoom_region_dispose;
-	epv->setContrast = impl_zoom_region_set_contrast;
-	epv->getContrast = impl_zoom_region_get_contrast;
-	epv->setBrightness = impl_zoom_region_set_brightness;
-	epv->getBrightness = impl_zoom_region_get_brightness;
-
-	reset_timing_stats();
-#ifdef DEBUG_CLIENT_CALLS
-	client_debug = (g_getenv ("MAG_CLIENT_DEBUG") != NULL);
-#endif
-}
-
-static void
-zoom_region_properties_init (ZoomRegion *zoom_region)
-{
-	BonoboArg *def;
-	
-	zoom_region->properties =
-		bonobo_property_bag_new_closure (
-			g_cclosure_new_object (
-				G_CALLBACK (zoom_region_get_property),
-				G_OBJECT (zoom_region)),
-			g_cclosure_new_object (
-				G_CALLBACK (zoom_region_set_property),
-				G_OBJECT (zoom_region)));
-
-	def = bonobo_arg_new (BONOBO_ARG_BOOLEAN);
-	BONOBO_ARG_SET_BOOLEAN (def, TRUE);
-	
-	bonobo_property_bag_add (zoom_region->properties,
-				 "is-managed",
-				 ZOOM_REGION_MANAGED_PROP,
-				 BONOBO_ARG_BOOLEAN,
-				 def,
-				 "If false, zoom region does not auto-update, but is drawn into directly by the client",
-				 Bonobo_PROPERTY_READABLE |
-				 Bonobo_PROPERTY_WRITEABLE);
-
-	bonobo_arg_release (def);
-	def = bonobo_arg_new (BONOBO_ARG_BOOLEAN);
-	BONOBO_ARG_SET_BOOLEAN (def, TRUE);
-	
-	bonobo_property_bag_add (zoom_region->properties,
-				 "poll-mouse",
-				 ZOOM_REGION_POLL_MOUSE_PROP,
-				 BONOBO_ARG_BOOLEAN,
-				 NULL,
-				 "If false, zoom region does not poll for pointer location, but is (exclusively) given it by the client",
-				 Bonobo_PROPERTY_READABLE |
-				 Bonobo_PROPERTY_WRITEABLE);
-
-	bonobo_arg_release (def);
-	def = bonobo_arg_new (BONOBO_ARG_BOOLEAN);
-	BONOBO_ARG_SET_BOOLEAN (def, TRUE);
-	
-	bonobo_property_bag_add (zoom_region->properties,
-				 "draw-cursor",
-				 ZOOM_REGION_DRAW_CURSOR_PROP,
-				 BONOBO_ARG_BOOLEAN,
-				 NULL,
-				 "If false, zoom region does not draw the cursor.",
-				 Bonobo_PROPERTY_READABLE |
-				 Bonobo_PROPERTY_WRITEABLE);
-
-	bonobo_arg_release (def);
-	def = bonobo_arg_new (BONOBO_ARG_SHORT);
-	BONOBO_ARG_SET_SHORT (def, GNOME_Magnifier_ZoomRegion_SCROLL_FASTEST);
-	
-	bonobo_property_bag_add (zoom_region->properties,
-				 "smooth-scroll-policy",
-				 ZOOM_REGION_SMOOTHSCROLL_PROP,
-				 BONOBO_ARG_SHORT,
-				 def,
-				 "scrolling policy, slower versus faster",
-				 Bonobo_PROPERTY_READABLE |
-				 Bonobo_PROPERTY_WRITEABLE);
-
-	bonobo_arg_release (def);
-	def = bonobo_arg_new (BONOBO_ARG_SHORT);
-	BONOBO_ARG_SET_SHORT (
-		def,
-		GNOME_Magnifier_ZoomRegion_COLORBLIND_FILTER_T_NO_FILTER);
-	
-	bonobo_property_bag_add (zoom_region->properties,
-				 "color-blind-filter",
-				 ZOOM_REGION_COLORBLIND_PROP,
-				 BONOBO_ARG_SHORT,
-				 def,
-				 "color blind filter to apply in an image",
-				 Bonobo_PROPERTY_READABLE |
-				 Bonobo_PROPERTY_WRITEABLE);
-
-	bonobo_arg_release (def);
-	def = bonobo_arg_new (BONOBO_ARG_BOOLEAN);
-	BONOBO_ARG_SET_BOOLEAN (def, FALSE);
-
-	bonobo_property_bag_add (zoom_region->properties,
-				 "use-test-pattern",
-				 ZOOM_REGION_TESTPATTERN_PROP,
-				 BONOBO_ARG_BOOLEAN,
-				 def,
-				 "use test pattern for source",
-				 Bonobo_PROPERTY_READABLE |
-				 Bonobo_PROPERTY_WRITEABLE);
-
-	bonobo_arg_release (def);
-	def = bonobo_arg_new (BONOBO_ARG_BOOLEAN);
-	BONOBO_ARG_SET_BOOLEAN (def, TRUE);
-	
-	bonobo_property_bag_add (zoom_region->properties,
-				 "inverse-video",
-				 ZOOM_REGION_INVERT_PROP,
-				 BONOBO_ARG_BOOLEAN,
-				 def,
-				 "inverse video display",
-				 Bonobo_PROPERTY_READABLE |
-				 Bonobo_PROPERTY_WRITEABLE);
-
-	bonobo_arg_release (def);
-
-	bonobo_property_bag_add (zoom_region->properties,
-				 "smoothing-type",
-				 ZOOM_REGION_SMOOTHING_PROP,
-				 BONOBO_ARG_STRING,
-				 NULL,
-				 "image smoothing algorithm used",
-				 Bonobo_PROPERTY_READABLE |
-				 Bonobo_PROPERTY_WRITEABLE);
-
-	def = bonobo_arg_new (BONOBO_ARG_FLOAT);
-	BONOBO_ARG_SET_FLOAT (def, 0.0);
-
-	bonobo_property_bag_add (zoom_region->properties,
-				 "red-contrast",
-				 ZOOM_REGION_CONTRASTR_PROP,
-				 BONOBO_ARG_FLOAT,
-				 def,
-				 "red image contrast ratio",
-				 Bonobo_PROPERTY_READABLE |
-				 Bonobo_PROPERTY_WRITEABLE);
-	bonobo_arg_release (def);
-
-	def = bonobo_arg_new (BONOBO_ARG_FLOAT);
-	BONOBO_ARG_SET_FLOAT (def, 0.0);
-
-	bonobo_property_bag_add (zoom_region->properties,
-				 "green-contrast",
-				 ZOOM_REGION_CONTRASTG_PROP,
-				 BONOBO_ARG_FLOAT,
-				 def,
-				 "green image contrast ratio",
-				 Bonobo_PROPERTY_READABLE |
-				 Bonobo_PROPERTY_WRITEABLE);
-	bonobo_arg_release (def);
-
-	def = bonobo_arg_new (BONOBO_ARG_FLOAT);
-	BONOBO_ARG_SET_FLOAT (def, 0.0);
-
-	bonobo_property_bag_add (zoom_region->properties,
-				 "blue-contrast",
-				 ZOOM_REGION_CONTRASTB_PROP,
-				 BONOBO_ARG_FLOAT,
-				 def,
-				 "blue image contrast ratio",
-				 Bonobo_PROPERTY_READABLE |
-				 Bonobo_PROPERTY_WRITEABLE);
-	bonobo_arg_release (def);
-
-	def = bonobo_arg_new (BONOBO_ARG_FLOAT);
-	BONOBO_ARG_SET_FLOAT (def, 0.0);
-
-	bonobo_property_bag_add (zoom_region->properties,
-				 "red-brightness",
-				 ZOOM_REGION_BRIGHTR_PROP,
-				 BONOBO_ARG_FLOAT,
-				 def,
-				 "red image brightness ratio",
-				 Bonobo_PROPERTY_READABLE |
-				 Bonobo_PROPERTY_WRITEABLE);
-	bonobo_arg_release (def);
-
-	def = bonobo_arg_new (BONOBO_ARG_FLOAT);
-	BONOBO_ARG_SET_FLOAT (def, 0.0);
-
-	bonobo_property_bag_add (zoom_region->properties,
-				 "green-brightness",
-				 ZOOM_REGION_BRIGHTG_PROP,
-				 BONOBO_ARG_FLOAT,
-				 def,
-				 "green image brightness ratio",
-				 Bonobo_PROPERTY_READABLE |
-				 Bonobo_PROPERTY_WRITEABLE);
-	bonobo_arg_release (def);
-
-	def = bonobo_arg_new (BONOBO_ARG_FLOAT);
-	BONOBO_ARG_SET_FLOAT (def, 0.0);
-
-	bonobo_property_bag_add (zoom_region->properties,
-				 "blue-brightness",
-				 ZOOM_REGION_BRIGHTB_PROP,
-				 BONOBO_ARG_FLOAT,
-				 def,
-				 "blue image brightness ratio",
-				 Bonobo_PROPERTY_READABLE |
-				 Bonobo_PROPERTY_WRITEABLE);
-	bonobo_arg_release (def);
-
-	def = bonobo_arg_new (BONOBO_ARG_FLOAT);
-	BONOBO_ARG_SET_FLOAT (def, 2.0);
-
-	bonobo_property_bag_add (zoom_region->properties,
-				 "mag-factor-x",
-				 ZOOM_REGION_XSCALE_PROP,
-				 BONOBO_ARG_FLOAT,
-				 def,
-				 "x scale factor",
-				 Bonobo_PROPERTY_READABLE |
-				 Bonobo_PROPERTY_WRITEABLE);
-
-	bonobo_arg_release (def);
-	def = bonobo_arg_new (BONOBO_ARG_FLOAT);
-	BONOBO_ARG_SET_FLOAT (def, 2.0);
-
-	bonobo_property_bag_add (zoom_region->properties,
-				 "mag-factor-y",
-				 ZOOM_REGION_YSCALE_PROP,
-				 BONOBO_ARG_FLOAT,
-				 def,
-				 "y scale factor",
-				 Bonobo_PROPERTY_READABLE |
-				 Bonobo_PROPERTY_WRITEABLE);
-
-	bonobo_arg_release (def);
-	def = bonobo_arg_new (BONOBO_ARG_LONG);
-	BONOBO_ARG_SET_LONG (def, 0);
-
-	bonobo_property_bag_add (zoom_region->properties,
-				 "border-size",
-				 ZOOM_REGION_BORDERSIZE_PROP,
-				 BONOBO_ARG_LONG,
-				 def,
-				 "size of zoom-region borders, in pixels",
-				 Bonobo_PROPERTY_READABLE |
-				 Bonobo_PROPERTY_WRITEABLE);
-
-	bonobo_arg_release (def);
-	def = bonobo_arg_new (BONOBO_ARG_LONG);
-	BONOBO_ARG_SET_LONG (def, 0);
-	
-	bonobo_property_bag_add (zoom_region->properties,
-				 "border-size-left",
-				 ZOOM_REGION_BORDERSIZELEFT_PROP,
-				 BONOBO_ARG_LONG,
-				 def,
-				 "size of left zoom-region border, in pixels",
-				 Bonobo_PROPERTY_READABLE |
-				 Bonobo_PROPERTY_WRITEABLE);
-
-	bonobo_arg_release (def);
-	def = bonobo_arg_new (BONOBO_ARG_LONG);
-	BONOBO_ARG_SET_LONG (def, 0);
-	
-	bonobo_property_bag_add (zoom_region->properties,
-				 "border-size-top",
-				 ZOOM_REGION_BORDERSIZETOP_PROP,
-				 BONOBO_ARG_LONG,
-				 def,
-				 "size of top zoom-region border, in pixels",
-				 Bonobo_PROPERTY_READABLE |
-				 Bonobo_PROPERTY_WRITEABLE);
-
-	bonobo_arg_release (def);
-	def = bonobo_arg_new (BONOBO_ARG_LONG);
-	BONOBO_ARG_SET_LONG (def, 0);
-	
-	bonobo_property_bag_add (zoom_region->properties,
-				 "border-size-right",
-				 ZOOM_REGION_BORDERSIZERIGHT_PROP,
-				 BONOBO_ARG_LONG,
-				 def,
-				 "size of right zoom-region border, in pixels",
-				 Bonobo_PROPERTY_READABLE |
-				 Bonobo_PROPERTY_WRITEABLE);
-
-	bonobo_arg_release (def);
-	def = bonobo_arg_new (BONOBO_ARG_LONG);
-	BONOBO_ARG_SET_LONG (def, 0);
-	
-	bonobo_property_bag_add (zoom_region->properties,
-				 "border-size-bottom",
-				 ZOOM_REGION_BORDERSIZEBOTTOM_PROP,
-				 BONOBO_ARG_LONG,
-				 def,
-				 "size of bottom zoom-region border, in "
-				 "pixels",
-				 Bonobo_PROPERTY_READABLE |
-				 Bonobo_PROPERTY_WRITEABLE);
-
-	bonobo_arg_release (def);
-	def = bonobo_arg_new (BONOBO_ARG_LONG);
-	BONOBO_ARG_SET_LONG (def, 0x00000000);
-	
-	bonobo_property_bag_add (zoom_region->properties,
-				 "border-color",
-				 ZOOM_REGION_BORDERCOLOR_PROP,
-				 BONOBO_ARG_LONG,
-				 def,
-				 "border color, as RGBA32",
-				 Bonobo_PROPERTY_READABLE |
-				 Bonobo_PROPERTY_WRITEABLE);
-
-	bonobo_arg_release (def);
-	def = bonobo_arg_new (BONOBO_ARG_INT);
-	BONOBO_ARG_SET_INT (def, 0);
-
-	bonobo_property_bag_add (zoom_region->properties,
-				 "x-alignment",
-				 ZOOM_REGION_XALIGN_PROP,
-				 BONOBO_ARG_INT,
-				 def,
-				 "x-alignment policy for this region",
-				 Bonobo_PROPERTY_READABLE |
-				 Bonobo_PROPERTY_WRITEABLE);
-
-	bonobo_arg_release (def);
-	def = bonobo_arg_new (BONOBO_ARG_INT);
-	BONOBO_ARG_SET_INT (def, 0);
-
-	bonobo_property_bag_add (zoom_region->properties,
-				 "y-alignment",
-				 ZOOM_REGION_YALIGN_PROP,
-				 BONOBO_ARG_INT,
-				 def,
-				 "y-alignment policy for this region",
-				 Bonobo_PROPERTY_READABLE |
-				 Bonobo_PROPERTY_WRITEABLE);
-	bonobo_arg_release (def);
-
-	bonobo_property_bag_add (zoom_region->properties,
-				 "viewport",
-				 ZOOM_REGION_VIEWPORT_PROP,
-				 TC_GNOME_Magnifier_RectBounds,
-				 NULL,
-				 "viewport bounding box",
-				 Bonobo_PROPERTY_READABLE |
-				 Bonobo_PROPERTY_WRITEABLE);
-
-	def = bonobo_arg_new (BONOBO_ARG_INT);
-	BONOBO_ARG_SET_INT (def, 0);
-
-	bonobo_property_bag_add (zoom_region->properties,
-				 "timing-iterations",
-				 ZOOM_REGION_TIMING_TEST_PROP,
-				 BONOBO_ARG_INT,
-				 def,
-				 "timing iterations",
-				 Bonobo_PROPERTY_READABLE |
-				 Bonobo_PROPERTY_WRITEABLE);
-	bonobo_arg_release (def);
-
-	def = bonobo_arg_new (BONOBO_ARG_BOOLEAN);
-	BONOBO_ARG_SET_BOOLEAN (def, FALSE);
-	
-	bonobo_property_bag_add (zoom_region->properties,
-				 "timing-output",
-				 ZOOM_REGION_TIMING_OUTPUT_PROP,
-				 BONOBO_ARG_BOOLEAN,
-				 def,
-				 "timing output",
-				 Bonobo_PROPERTY_READABLE |
-				 Bonobo_PROPERTY_WRITEABLE);
-
-	bonobo_arg_release (def);
-
-	def = bonobo_arg_new (BONOBO_ARG_INT);
-	BONOBO_ARG_SET_INT (def, 0);
-
-	bonobo_property_bag_add (zoom_region->properties,
-				 "timing-pan-rate",
-				 ZOOM_REGION_TIMING_PAN_RATE_PROP,
-				 BONOBO_ARG_INT,
-				 def,
-				 "timing pan rate",
-				 Bonobo_PROPERTY_READABLE |
-				 Bonobo_PROPERTY_WRITEABLE);
-	bonobo_arg_release (def);
-
-	def = bonobo_arg_new (BONOBO_ARG_BOOLEAN);
-	BONOBO_ARG_SET_BOOLEAN (def, FALSE);
-	
-	bonobo_property_bag_add (zoom_region->properties,
-				 "exit-magnifier",
-				 ZOOM_REGION_EXIT_MAGNIFIER,
-				 BONOBO_ARG_BOOLEAN,
-				 def,
-				 "timing output",
-				 Bonobo_PROPERTY_READABLE |
-				 Bonobo_PROPERTY_WRITEABLE);
-
-	bonobo_arg_release (def);
-
-}
-
-static void
-zoom_region_private_init (ZoomRegionPrivate *priv)
-{
-	GdkRectangle rect = {0, 0, 0, 0};
-	GNOME_Magnifier_RectBounds rectbounds = {0, 0, 0, 0};
-	priv->parent = NULL;
-	priv->w = NULL;
-	priv->default_gc = NULL;
-	priv->paint_cursor_gc = NULL;
-	priv->crosswire_gc = NULL;
-	priv->q = NULL;
-	priv->scaled_pixbuf = NULL;
-	priv->source_pixbuf_cache = NULL;
-	priv->source_drawable = NULL;
-	priv->pixmap = NULL;
-	priv->cursor_backing_rect = rect;
-	priv->cursor_backing_pixels = NULL;
-	priv->gdk_interp_type = GDK_INTERP_NEAREST;
-	priv->expose_handler_id = 0;
-	priv->test = FALSE;
-	priv->last_cursor_pos.x = 0;
-	priv->last_cursor_pos.y = 0;
-	priv->last_drawn_crosswire_pos.x = 0;
-	priv->last_drawn_crosswire_pos.y = 0;
-	priv->exposed_bounds = rectbounds;
-	priv->source_area = rectbounds;
-	priv->update_pointer_id = 0;
-	priv->update_handler_id = 0;
+	object_class->get_property = zoom_region_get_property;
+	object_class->set_property = zoom_region_set_property;
+
+	widget_class->expose_event = zoom_region_expose;
+
+	g_object_class_install_property (object_class,
+					 ZOOM_REGION_MANAGED_PROP,
+					 g_param_spec_boolean ("is-managed",
+							       "IsManaged",
+							       "If false, zoom region does not auto-update, but is drawn into directly by the client",
+							       TRUE,
+							       G_PARAM_READWRITE));
+	g_object_class_install_property (object_class,
+					 ZOOM_REGION_POLL_MOUSE_PROP,
+					 g_param_spec_boolean ("poll-mouse",
+							       "PollMouse",
+							       "If false, zoom region does not poll for pointer location, but is (exclusively) given it by the client",
+							       TRUE,
+							       G_PARAM_READWRITE));
+	g_object_class_install_property (object_class,
+					 ZOOM_REGION_DRAW_CURSOR_PROP,
+					 g_param_spec_boolean ("draw-cursor",
+							       "DrawCursor",
+							       "If false, zoom region does not draw the cursor.",
+							       TRUE,
+							       G_PARAM_READWRITE));
+	g_object_class_install_property (object_class,
+					 ZOOM_REGION_SMOOTHSCROLL_PROP,
+					 g_param_spec_uint ("smooth-scroll-policy",
+							    "SmoothScrollPolicy",
+							    "scrolling policy, slower versus faster",
+							    SCROLL_FASTEST, SCROLL_SMOOTHEST, SCROLL_FASTEST,
+							    G_PARAM_READWRITE));
+	g_object_class_install_property (object_class,
+					 ZOOM_REGION_COLORBLIND_PROP,
+					 g_param_spec_uint ("color-blind-filter",
+							    "ColorBlibndFilter",
+							    "color blind filter to apply in an image",
+							    COLORBLIND_FILTER_T_NO_FILTER,
+							    COLORBLIND_FILTER_T_MONOCHRONE_OTHERS,
+							    COLORBLIND_FILTER_T_NO_FILTER,
+							    G_PARAM_READWRITE));
+	g_object_class_install_property (object_class,
+					 ZOOM_REGION_TESTPATTERN_PROP,
+					 g_param_spec_boolean ("use-test-pattern",
+							       "UseTestPattern",
+							       "use test pattern for source",
+							       FALSE,
+							       G_PARAM_READWRITE));
+	g_object_class_install_property (object_class,
+					 ZOOM_REGION_INVERT_PROP,
+					 g_param_spec_boolean ("inverse-video",
+							       "InverseVideo",
+							       "inverse video display",
+							       TRUE,
+							       G_PARAM_READWRITE));
+	g_object_class_install_property (object_class,
+					 ZOOM_REGION_SMOOTHING_PROP,
+					 g_param_spec_string ("smoothing-type",
+							      "SmoothingType",
+							      "image smoothing algorithm used",
+							      NULL,
+							      G_PARAM_READWRITE));
+	g_object_class_install_property (object_class,
+					 ZOOM_REGION_CONTRASTR_PROP,
+					 g_param_spec_float ("red-contrast",
+							     "RedContrast",
+							     "red image contrast ratio",
+							     0., G_MAXFLOAT, 0.,
+							     G_PARAM_READWRITE));
+	g_object_class_install_property (object_class,
+					 ZOOM_REGION_CONTRASTG_PROP,
+					 g_param_spec_float ("green-contrast",
+							     "GreenContrast",
+							     "green image contrast ratio",
+							     0., G_MAXFLOAT, 0.,
+							     G_PARAM_READWRITE));
+	g_object_class_install_property (object_class,
+					 ZOOM_REGION_CONTRASTB_PROP,
+					 g_param_spec_float ("blue-contrast",
+							     "BlueContrast",
+							     "blue image contrast ratio",
+							     0., G_MAXFLOAT, 0.,
+							     G_PARAM_READWRITE));
+	g_object_class_install_property (object_class,
+					 ZOOM_REGION_BRIGHTR_PROP,
+					 g_param_spec_float ("red-brightness",
+							     "RedBrightness",
+							     "red image brightness ratio",
+							     0., G_MAXFLOAT, 0.,
+							     G_PARAM_READWRITE));
+	g_object_class_install_property (object_class,
+					 ZOOM_REGION_BRIGHTG_PROP,
+					 g_param_spec_float ("green-brightness",
+							     "GreenBrightness",
+							     "green image brightness ratio",
+							     0., G_MAXFLOAT, 0.,
+							     G_PARAM_READWRITE));
+	g_object_class_install_property (object_class,
+					 ZOOM_REGION_BRIGHTB_PROP,
+					 g_param_spec_float ("blue-brightness",
+							     "BlueBrightness",
+							     "blue image brightness ratio",
+							     0., G_MAXFLOAT, 0.,
+							     G_PARAM_READWRITE));
+	g_object_class_install_property (object_class,
+					 ZOOM_REGION_XSCALE_PROP,
+					 g_param_spec_float ("mag-factor-x",
+							     "MagFactorX",
+							     "x scale factor",
+							     0., G_MAXFLOAT, 2.0,
+							     G_PARAM_READWRITE));
+	g_object_class_install_property (object_class,
+					 ZOOM_REGION_YSCALE_PROP,
+					 g_param_spec_float ("mag-factor-y",
+							     "MagFactorY",
+							     "y scale factor",
+							     0., G_MAXFLOAT, 2.0,
+							     G_PARAM_READWRITE));
+	g_object_class_install_property (object_class,
+					 ZOOM_REGION_BORDERSIZE_PROP,
+					 g_param_spec_long ("border-size",
+							    "BorderSize",
+							    "size of zoom-region borders, in pixels",
+							    0, G_MAXLONG, 0,
+							    G_PARAM_READWRITE));
+	g_object_class_install_property (object_class,
+					 ZOOM_REGION_BORDERSIZELEFT_PROP,
+					 g_param_spec_long ("border-size-left",
+							    "BorderSizeLeft",
+							    "size of left zoom-region border, in pixels",
+							    0, G_MAXLONG, 0,
+							    G_PARAM_READWRITE));
+	g_object_class_install_property (object_class,
+					 ZOOM_REGION_BORDERSIZETOP_PROP,
+					 g_param_spec_long ("border-size-top",
+							    "BorderSizeTop",
+							    "size of top zoom-region border, in pixels",
+							    0, G_MAXLONG, 0,
+							    G_PARAM_READWRITE));
+	g_object_class_install_property (object_class,
+					 ZOOM_REGION_BORDERSIZERIGHT_PROP,
+					 g_param_spec_long ("border-size-right",
+							    "BorderSizeRight",
+							    "size of right zoom-region border, in pixels",
+							    0, G_MAXLONG, 0,
+							    G_PARAM_READWRITE));
+	g_object_class_install_property (object_class,
+					 ZOOM_REGION_BORDERSIZEBOTTOM_PROP,
+					 g_param_spec_long ("border-size-bottom",
+							    "BorderSizeBottom",
+							    "size of bottom zoom-region border, in pixels",
+							    0, G_MAXLONG, 0,
+							    G_PARAM_READWRITE));
+	g_object_class_install_property (object_class,
+					 ZOOM_REGION_BORDERCOLOR_PROP,
+					 g_param_spec_long ("border-color",
+							    "BorderColor",
+							    "border color, as RGBA32",
+							    0, G_MAXLONG, 0x00000000,
+							    G_PARAM_READWRITE));
+	g_object_class_install_property (object_class,
+					 ZOOM_REGION_XALIGN_PROP,
+					 g_param_spec_int ("x-alignment",
+							   "XAlignment",
+							   "x-alignment policy for this region",
+							   0, G_MAXINT, 0,
+							   G_PARAM_READWRITE));
+	g_object_class_install_property (object_class,
+					 ZOOM_REGION_YALIGN_PROP,
+					 g_param_spec_int ("y-alignment",
+							   "YAlignment",
+							   "y-alignment policy for this region",
+							   0, G_MAXINT, 0,
+							   G_PARAM_READWRITE));
+	g_object_class_install_property (object_class,
+					 ZOOM_REGION_VIEWPORT_PROP,
+					 g_param_spec_pointer ("viewport",
+							       "Viewport",
+							       "viewport bounding box",
+							       G_PARAM_READWRITE));
+	g_object_class_install_property (object_class,
+					 ZOOM_REGION_TIMING_TEST_PROP,
+					 g_param_spec_int ("timing-iterations",
+							   "TimingIterations",
+							   "timing iterations",
+							   0, G_MAXINT, 0,
+							   G_PARAM_READWRITE));
+	g_object_class_install_property (object_class,
+					 ZOOM_REGION_TIMING_OUTPUT_PROP,
+					 g_param_spec_boolean ("timing-output",
+							       "TimingOutput",
+							       "timing output",
+							       FALSE, G_PARAM_READWRITE));
+	g_object_class_install_property (object_class,
+					 ZOOM_REGION_TIMING_PAN_RATE_PROP,
+					 g_param_spec_int ("timing-pan-rate",
+							   "TimingPanRate",
+							   "timing pan rate",
+							   0, G_MAXINT, 0,
+							   G_PARAM_READWRITE));
+	g_object_class_install_property (object_class,
+					 ZOOM_REGION_EXIT_MAGNIFIER,
+					 g_param_spec_boolean ("exit-magnifier",
+							       "ExitMagnifier",
+							       "exit magnifier",
+							       FALSE, G_PARAM_READWRITE));
+
+	g_type_class_add_private (klass, sizeof (ZoomRegionPrivate));
 }
 
 static void
@@ -4301,112 +3609,57 @@ zoom_region_init (ZoomRegion *zoom_region)
 {
 	DBG(g_message ("initializing region %p", zoom_region));
 
-	zoom_region_properties_init (zoom_region);
+	zoom_region->priv = ZOOM_REGION_GET_PRIVATE (zoom_region);
 	zoom_region->draw_cursor = TRUE;
-	zoom_region->smooth_scroll_policy =
-		GNOME_Magnifier_ZoomRegion_SCROLL_SMOOTH;
-	zoom_region->color_blind_filter =
-		GNOME_Magnifier_ZoomRegion_COLORBLIND_FILTER_T_NO_FILTER;
-	zoom_region->contrast_r = 0.0;
-	zoom_region->contrast_g = 0.0;
-	zoom_region->contrast_b = 0.0;
-	zoom_region->bright_r = 0.0;
-	zoom_region->bright_g = 0.0;
-	zoom_region->bright_b = 0.0;
-	zoom_region->invert = FALSE;
-	zoom_region->cache_source = FALSE;
-	zoom_region->border_size_left = 0;
-	zoom_region->border_size_top = 0;
-	zoom_region->border_size_right = 0;
-	zoom_region->border_size_bottom = 0;
-	zoom_region->border_color = 0;
-	zoom_region->roi.x1 = 0;
-	zoom_region->roi.x1 = 0;
-	zoom_region->roi.x2 = 1;
-	zoom_region->roi.x2 = 1;
-	zoom_region->x_align_policy = GNOME_Magnifier_ZoomRegion_ALIGN_CENTER;
-	zoom_region->y_align_policy = GNOME_Magnifier_ZoomRegion_ALIGN_CENTER;
+	zoom_region->smooth_scroll_policy = SCROLL_SMOOTH;
+	zoom_region->color_blind_filter = COLORBLIND_FILTER_T_NO_FILTER;
+	zoom_region->x_align_policy = ALIGN_CENTER;
+	zoom_region->y_align_policy = ALIGN_CENTER;
 	zoom_region->coalesce_func = _coalesce_update_rects;
-	zoom_region->poll_mouse = TRUE; 
-	zoom_region->priv = g_malloc (sizeof (ZoomRegionPrivate));
-	zoom_region_private_init (zoom_region->priv);
-	bonobo_object_add_interface (BONOBO_OBJECT (zoom_region),
-				     BONOBO_OBJECT (zoom_region->properties));
-	zoom_region->timing_output = FALSE;
+	zoom_region->poll_mouse = TRUE;
 #ifdef ZOOM_REGION_DEBUG
 	zoom_region->alive = TRUE;
 #endif
 	zoom_region->priv->update_pointer_id =
-	    g_timeout_add_full (G_PRIORITY_DEFAULT_IDLE,
-				200,
-				zoom_region_update_pointer_timeout,
-				zoom_region,
-				NULL);
+		g_timeout_add_full (G_PRIORITY_DEFAULT_IDLE,
+				    200,
+				    zoom_region_update_pointer_timeout,
+				    zoom_region,
+				    NULL);
 }
 
 ZoomRegion *
-zoom_region_new (void)
+zoom_region_new (GDBusConnection *connection,
+		 GtkWidget       *parent)
 {
-	ZoomRegionClass *klass = NULL;
-	GError *error = NULL;
 	ZoomRegion *_this_zoom_region = g_object_new (zoom_region_get_type(), NULL);
+	GError *error = NULL;
+
+	dbus_connection = connection;
+	_this_zoom_region->priv->parent = MAGNIFIER (parent);
+	zoom_region_init_window (_this_zoom_region);
+
 	_this_zoom_region->object_path = g_strdup_printf("/org/freedesktop/gnome/ZoomRegion/%i", zoom_region_number);
 
-	klass = ZOOM_REGION_GET_CLASS (_this_zoom_region);
-	
-	klass->connection = dbus_g_bus_get (DBUS_BUS_SESSION, &error);
-	if (klass->connection == NULL) {
-		g_warning ("Unable to connect to dbus: %s", error->message);
+	if (!introspection_data)
+		introspection_data = g_dbus_node_info_new_for_xml (introspection_xml, NULL);
+
+	_this_zoom_region->priv->dbus_object_id =
+		g_dbus_connection_register_object (connection,
+						   _this_zoom_region->object_path,
+						   introspection_data->interfaces[0],
+						   &interface_vtable,
+						   _this_zoom_region, NULL,
+						   &error);
+	if (error) {
+		g_printerr ("Failed to register zoom-region object: %s\n", error->message);
 		g_error_free (error);
+		g_object_unref (_this_zoom_region);
+
 		return NULL;
 	}
-	
-	dbus_g_object_type_install_info (ZOOM_REGION_TYPE, &dbus_glib_impl_dbus_zoom_region_object_info);
-	
-	dbus_g_connection_register_g_object (klass->connection, _this_zoom_region->object_path,
-					     G_OBJECT (_this_zoom_region));
-						  
-	zoom_region_number++;
-						  
-	return _this_zoom_region;
-}
 
-/* this one really shuts down the object - called once only */
-static void
-zoom_region_finalize (GObject *region)
-{
-	ZoomRegion *zoom_region = (ZoomRegion *) region;
-
-	DBG(g_message ("finalizing region %p", zoom_region));
+	zoom_region_number++;
 
-	if (zoom_region->priv && zoom_region->priv->q) 
-	{
-		g_list_free (zoom_region->priv->q);
-		zoom_region->priv->q = NULL;
-	}
-	if (GTK_IS_WIDGET (zoom_region->priv->w))
-		gtk_container_remove (GTK_CONTAINER (((Magnifier *) zoom_region->priv->parent)->priv->canvas), GTK_WIDGET (zoom_region->priv->w));
-	if (GTK_IS_WIDGET (zoom_region->priv->border))
-		gtk_container_remove (GTK_CONTAINER (((Magnifier *) zoom_region->priv->parent)->priv->canvas), GTK_WIDGET (zoom_region->priv->border));
-	if (zoom_region->priv->source_pixbuf_cache) 
-	    g_object_unref (zoom_region->priv->source_pixbuf_cache);
-	if (zoom_region->priv->scaled_pixbuf) 
-	    g_object_unref (zoom_region->priv->scaled_pixbuf);
-	if (zoom_region->priv->pixmap) 
-	    g_object_unref (zoom_region->priv->pixmap);
-	zoom_region->priv->pixmap = NULL;
-	zoom_region->priv->parent = NULL;
-	if (zoom_region->priv->cursor_backing_pixels) 
-	    g_object_unref (zoom_region->priv->cursor_backing_pixels);
-	g_free (zoom_region->priv);
-	zoom_region->priv = NULL;
-#ifdef ZOOM_REGION_DEBUG
-	zoom_region->alive = FALSE;
-#endif
-	BONOBO_CALL_PARENT (G_OBJECT_CLASS, finalize, (region));
+	return _this_zoom_region;
 }
-
-BONOBO_TYPE_FUNC_FULL (ZoomRegion, 
-		       GNOME_Magnifier_ZoomRegion,
-		       BONOBO_TYPE_OBJECT,
-		       zoom_region);
diff --git a/magnifier/zoom-region.h b/magnifier/zoom-region.h
index f678fcd..00b57ff 100644
--- a/magnifier/zoom-region.h
+++ b/magnifier/zoom-region.h
@@ -23,13 +23,11 @@
 #ifndef ZOOM_REGION_H_
 #define ZOOM_REGION_H_
 
+#include <glib.h>
+#include <glib-object.h>
+#include <gtk/gtk.h>
 
-#ifdef __cplusplus
-extern "C" {
-#endif /* __cplusplus */
-
-#include <bonobo/bonobo-object.h>
-#include "GNOME_Magnifier.h"
+G_BEGIN_DECLS
 
 #define ZOOM_REGION_TYPE         (zoom_region_get_type ())
 #define ZOOM_REGION(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), ZOOM_REGION_TYPE, ZoomRegion))
@@ -38,13 +36,53 @@ extern "C" {
 #define IS_ZOOM_REGION_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), ZOOM_REGION_TYPE))
 #define ZOOM_REGION_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), ZOOM_REGION_TYPE, ZoomRegionClass))
 
+typedef struct {
+	gint32 x1;
+	gint32 y1;
+	gint32 x2;
+	gint32 y2;
+} RectBounds;
+
+typedef struct {
+	gint32 x;
+	gint32 y;
+} Point;
+
+typedef enum {
+	ALIGN_CENTER,
+	ALIGN_MIN,
+	ALIGN_MAX
+} AlignPolicy;
+
+typedef enum {
+	SCROLL_FASTEST,
+	SCROLL_FAST,
+	SCROLL_NORMAL,
+	SCROLL_SMOOTH,
+	SCROLL_SMOOTHEST
+} ScrollingPolicy;
+
+typedef enum {
+	COLORBLIND_FILTER_T_NO_FILTER,
+	COLORBLIND_FILTER_T_SELECTIVE_SATURATE_RED,
+	COLORBLIND_FILTER_T_SELECTIVE_SATURATE_GREEN,
+	COLORBLIND_FILTER_T_SELECTIVE_SATURATE_BLUE,
+	COLORBLIND_FILTER_T_SELECTIVE_DESSATURATE_RED,
+	COLORBLIND_FILTER_T_SELECTIVE_DESSATURATE_GREEN,
+	COLORBLIND_FILTER_T_SELECTIVE_DESSATURATE_BLUE,
+	COLORBLIND_FILTER_T_HUE_SHIFT_POSITIVE,
+	COLORBLIND_FILTER_T_HUE_SHIFT_NEGATIVE,
+	COLORBLIND_FILTER_T_SELECTIVE_SATURATE,
+	COLORBLIND_FILTER_T_SELECTIVE_DESSATURATE,
+	COLORBLIND_FILTER_T_MONOCHRONE_OTHERS
+} ColorBlindFilter;
+
 typedef GList * (*CoalesceFunc)(GList *, int);
 
 typedef struct _ZoomRegionPrivate ZoomRegionPrivate;
 
 typedef struct {
-        BonoboObject parent;
-	BonoboPropertyBag *properties;
+        GtkDrawingArea parent;
 	gboolean invert;
 	gboolean is_managed;
 	gboolean draw_cursor;
@@ -67,11 +105,11 @@ typedef struct {
 	guint32 border_color; /* A-RGB, 8 bits each, MSB==alpha */
 	gint x_align_policy;  /* TODO: enums here */
 	gint y_align_policy;
-	GNOME_Magnifier_ZoomRegion_ScrollingPolicy smooth_scroll_policy;
-	GNOME_Magnifier_ZoomRegion_ColorBlindFilter color_blind_filter;
+	ScrollingPolicy smooth_scroll_policy;
+	ColorBlindFilter color_blind_filter;
         /* bounds of viewport, in target magnifier window coords */
-	GNOME_Magnifier_RectBounds roi;
-	GNOME_Magnifier_RectBounds viewport; 
+	RectBounds roi;
+	RectBounds viewport;
 	ZoomRegionPrivate *priv;
 	CoalesceFunc coalesce_func;
 	gint timing_iterations;
@@ -85,66 +123,24 @@ typedef struct {
 } ZoomRegion;
 
 typedef struct {
-        BonoboObjectClass                    parent_class;
-        POA_GNOME_Magnifier_ZoomRegion__epv  epv;
-        DBusGConnection                     *connection;
+        GtkDrawingAreaClass                    parent_class;
 } ZoomRegionClass;
 
-GType     zoom_region_get_type (void);
-ZoomRegion *zoom_region_new     (void);
-
-/* D-BUS methods */
-gboolean	impl_dbus_zoom_region_set_mag_factor (ZoomRegion *zoom_region, const gdouble mag_factor_x,
-			const gdouble mag_factor_y);
-GArray*		impl_dbus_zoom_region_get_mag_factor (ZoomRegion *zoom_region);
-gboolean	impl_dbus_zoom_region_set_roi (ZoomRegion *zoom_region, const gint32 **roi);
-gboolean	impl_dbus_zoom_region_update_pointer (ZoomRegion *zoom_region);
-gboolean	impl_dbus_zoom_region_mark_dirty (ZoomRegion *zoom_region, gint32 **bounds);
-GArray*		impl_dbus_zoom_region_get_roi (ZoomRegion *zoom_region);
-gboolean	impl_dbus_zoom_region_move_resize (ZoomRegion *zoom_region, const gint32 **viewport);
-gboolean	impl_dbus_zoom_region_dispose (ZoomRegion *zoom_region);
-gboolean	impl_dbus_zoom_region_set_pointer_pos (ZoomRegion *zoom_region, gint32 mouse_x, gint32 mouse_y);
-gboolean	impl_dbus_zoom_region_set_contrast (ZoomRegion *zoom_region, gdouble R, gdouble G, gdouble B);
-GArray*		impl_dbus_zoom_region_get_contrast (ZoomRegion *zoom_region);
-gboolean	impl_dbus_zoom_region_set_brightness (ZoomRegion *zoom_region, gdouble R, gdouble G, gdouble B);
-GArray*		impl_dbus_zoom_region_get_brightness (ZoomRegion *zoom_region);
-gboolean	impl_dbus_zoom_region_set_managed (ZoomRegion *zoom_region, gboolean managed);
-gboolean	impl_dbus_zoom_region_get_managed (ZoomRegion *zoom_region);
-gboolean	impl_dbus_zoom_region_set_poll_mouse (ZoomRegion *zoom_region, gboolean poll_mouse);
-gboolean	impl_dbus_zoom_region_get_poll_mouse (ZoomRegion *zoom_region);
-gboolean	impl_dbus_zoom_region_set_draw_cursor (ZoomRegion *zoom_region, gboolean draw_cursor);
-gboolean	impl_dbus_zoom_region_get_draw_cursor (ZoomRegion *zoom_region);
-gboolean	impl_dbus_zoom_region_set_invert (ZoomRegion *zoom_region, gboolean invert);
-gboolean	impl_dbus_zoom_region_get_invert (ZoomRegion *zoom_region);
-gboolean	impl_dbus_zoom_region_set_smoothscroll (ZoomRegion *zoom_region, gshort smoothscroll);
-gshort		impl_dbus_zoom_region_get_smoothscroll (ZoomRegion *zoom_region);
-gboolean	impl_dbus_zoom_region_set_colorblind (ZoomRegion *zoom_region, gshort colorblind);
-gshort		impl_dbus_zoom_region_get_colorblind (ZoomRegion *zoom_region);
-gboolean	impl_dbus_zoom_region_set_smoothing (ZoomRegion *zoom_region, gchar *smoothing);
-gchar*		impl_dbus_zoom_region_get_smoothing (ZoomRegion *zoom_region);
-gboolean	impl_dbus_zoom_region_set_testpattern (ZoomRegion *zoom_region, gboolean test);
-gboolean	impl_dbus_zoom_region_get_testpattern (ZoomRegion *zoom_region);
-gboolean	impl_dbus_zoom_region_set_bordersizes (ZoomRegion *zoom_region, gint32 **bordersizes);
-GArray*		impl_dbus_zoom_region_get_bordersizes (ZoomRegion *zoom_region);
-gboolean	impl_dbus_zoom_region_set_bordercolor (ZoomRegion *zoom_region, guint32 bordercolor);
-guint32		impl_dbus_zoom_region_get_bordercolor (ZoomRegion *zoom_region);
-gboolean	impl_dbus_zoom_region_set_xalign (ZoomRegion *zoom_region, gint32 align);
-gint32		impl_dbus_zoom_region_get_xalign (ZoomRegion *zoom_region);
-gboolean	impl_dbus_zoom_region_set_yalign (ZoomRegion *zoom_region, gint32 align);
-gint32		impl_dbus_zoom_region_get_yalign (ZoomRegion *zoom_region);
-gboolean	impl_dbus_zoom_region_set_viewport (ZoomRegion *zoom_region, gint32 **viewport);
-GArray*		impl_dbus_zoom_region_get_viewport (ZoomRegion *zoom_region);
-gboolean	impl_dbus_zoom_region_set_timing_test (ZoomRegion *zoom_region, gint32 timing_iterations);
-gint32		impl_dbus_zoom_region_get_timing_test (ZoomRegion *zoom_region);
-gboolean	impl_dbus_zoom_region_set_timing_output (ZoomRegion *zoom_region, gboolean timing_output);
-gboolean	impl_dbus_zoom_region_get_timing_output (ZoomRegion *zoom_region);
-gboolean	impl_dbus_zoom_region_set_timing_pan_rate (ZoomRegion *zoom_region, gint32 timing_pan_rate);
-gint32		impl_dbus_zoom_region_get_timing_pan_rate (ZoomRegion *zoom_region);
-gboolean	impl_dbus_zoom_region_set_exit_magnifier (ZoomRegion *zoom_region, gboolean exit_magnifier);
-gboolean	impl_dbus_zoom_region_get_exit_magnifier (ZoomRegion *zoom_region);
-
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
+GType       zoom_region_get_type       (void) G_GNUC_CONST;
+ZoomRegion *zoom_region_new            (GDBusConnection *connection,
+					GtkWidget       *parent);
+void        zoom_region_update_cursor  (ZoomRegion      *zoom_region,
+					int              dx,
+					int              dy,
+					GdkRectangle    *clip_rect);
+void        zoom_region_mark_dirty     (ZoomRegion      *zoom_region,
+					RectBounds      *roi_dirty);
+void        zoom_region_set_roi        (ZoomRegion      *zoom_region,
+					RectBounds      *bounds);
+gboolean    zoom_region_set_mag_factor (ZoomRegion      *zoom_region,
+					gdouble          mag_factor_x,
+					gdouble          mag_factor_y);
+
+G_END_DECLS
 
 #endif /* ZOOM_REGION_H_ */
diff --git a/test/Makefile.am b/test/Makefile.am
index 3467183..e0876e1 100644
--- a/test/Makefile.am
+++ b/test/Makefile.am
@@ -1,7 +1,8 @@
 
-noinst_PROGRAMS = control-client mag-test
+#noinst_PROGRAMS = control-client mag-test
+noinst_PROGRAMS = mag-test
 
-control_client_SOURCES = control-client.c
+#control_client_SOURCES = control-client.c
 
 mag_test_SOURCES = mag-test.c
 
@@ -9,10 +10,9 @@ INCLUDES = \
 	$(DEPS_CFLAGS)		\
 	-I$(top_srcdir)		\
 	-I$(top_builddir)	\
-	-I$(top_builddir)/magnifier 	\
-	-I$(top_srcdir)/idl	
+	-I$(top_builddir)/magnifier
 
-LDADD = $(DEPS_LIBS) $(top_builddir)/magnifier/libgnome-mag.la $(X_LIBS) $(POPT_LIBS)
+LDADD = $(DEPS_LIBS) $(X_LIBS) $(POPT_LIBS)
 
 
 
diff --git a/test/mag-test.c b/test/mag-test.c
index db6a166..036ce75 100644
--- a/test/mag-test.c
+++ b/test/mag-test.c
@@ -23,53 +23,22 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
-#include <libbonobo.h>
+#include <gtk/gtk.h>
 #include <gdk/gdk.h>
-#include "GNOME_Magnifier.h"
 
-static GNOME_Magnifier_Magnifier _the_magnifier = NULL;
+typedef enum {
+	ALIGN_CENTER,
+	ALIGN_MIN,
+	ALIGN_MAX
+} AlignPolicy;
 
-static void
-init_rect_bounds (GNOME_Magnifier_RectBounds *bounds,
-		  long x1, long y1, long x2, long y2)
-{
-	bounds->x1 = x1;
-	bounds->y1 = y1;
-	bounds->x2 = x2;
-	bounds->y2 = y2;
-}
-
-static GNOME_Magnifier_Magnifier 
-get_magnifier()
-{
-  CORBA_Object oclient;
-  char *obj_id;
-  CORBA_Environment ev;
-  
-  if (!_the_magnifier)
-  {
-    CORBA_exception_init (&ev);
-    obj_id = "OAFIID:GNOME_Magnifier_Magnifier:0.9";
-
-    oclient = bonobo_activation_activate_from_id (obj_id, 0, NULL, &ev);
-    if (ev._major != CORBA_NO_EXCEPTION) {
-      fprintf (stderr,
-            ("Activation error: during magnifier activation: %s\n"),
-            CORBA_exception_id(&ev));
-      CORBA_exception_free(&ev);
-    }
-
-    if (CORBA_Object_is_nil (oclient, &ev))
-    {
-      g_error ("Could not locate magnifier");
-    }
-
-    _the_magnifier = (GNOME_Magnifier_Magnifier) oclient;
-
-  }
-
-  return _the_magnifier;
-}
+typedef enum {
+	SCROLL_FASTEST,
+	SCROLL_FAST,
+	SCROLL_NORMAL,
+	SCROLL_SMOOTH,
+	SCROLL_SMOOTHEST
+} ScrollingPolicy;
 
 #ifdef WE_USE_THIS_AGAIN
 static GNOME_Magnifier_ZoomRegion
@@ -86,123 +55,160 @@ test_client_magnifier_get_zoomer (GNOME_Magnifier_Magnifier magnifier, int index
 }
 #endif
 
-static void
-init_rectbounds (GNOME_Magnifier_RectBounds *bounds, int x1, int y1, int x2, int y2)
+static GVariant *
+get_rectbounds (int x1, int y1, int x2, int y2)
 {
-	bounds->x1 = x1;
-	bounds->y1 = y1;
-	bounds->x2 = x2;
-	bounds->y2 = y2;
+	GVariant *children[4];
+
+	children[0] = g_variant_new_int32 (x1);
+	children[1] = g_variant_new_int32 (y1);
+	children[2] = g_variant_new_int32 (x2);
+	children[3] = g_variant_new_int32 (y2);
+
+	return g_variant_new_array (G_VARIANT_TYPE_INT32, children, 4);
 }
 
 static void
-test_new_region (GNOME_Magnifier_Magnifier magnifier,
+test_new_region (GDBusProxy *magnifier,
 		 float xscale,
 		 float yscale,
 		 int x1,
 		 int y1,
 		 int x2,
 		 int y2,
-		 GNOME_Magnifier_ZoomRegion_ScrollingPolicy scroll_policy,
+		 ScrollingPolicy scroll_policy,
 		 gchar *smoothing_type,
 		 gboolean is_inverse,
-		 GNOME_Magnifier_ZoomRegion_AlignPolicy align)
+		 AlignPolicy align)
 {
-	GNOME_Magnifier_RectBounds *viewport = GNOME_Magnifier_RectBounds__alloc ();
-	GNOME_Magnifier_RectBounds *roi = GNOME_Magnifier_RectBounds__alloc ();
-	GNOME_Magnifier_ZoomRegion zoomer;
-	Bonobo_PropertyBag properties;
-	CORBA_Environment ev;
+	GVariant *result;
+	const gchar *zoomer_object_path;
+	GDBusProxy *zoomer;
+	GError *error = NULL;
+
+	result = g_dbus_proxy_call_sync (magnifier,
+					 "createZoomRegion",
+					 g_variant_new ("(dd@ai@ai)",
+							xscale, yscale,
+							get_rectbounds (0, 0, 100, 100),
+							get_rectbounds (x1, y1, x2, y2)),
+					 G_DBUS_CALL_FLAGS_NO_AUTO_START,
+					 -1, NULL, &error);
+	if (error) {
+		g_printerr ("Error calling method createZoomRegion: %s\n", error->message);
+		g_error_free (error);
+
+		return;
+	}
 
-	CORBA_exception_init (&ev);
+	g_variant_get (result, "(&o)", &zoomer_object_path);
+	zoomer = g_dbus_proxy_new_sync (g_dbus_proxy_get_connection (magnifier),
+					G_DBUS_PROXY_FLAGS_NONE,
+					NULL,
+					"org.freedesktop.gnome.Magnifier.ZoomRegion",
+					zoomer_object_path,
+					"org.freedesktop.gnome.Magnifier.ZoomRegion",
+					NULL, &error);
+	g_variant_unref (result);
+	if (!zoomer) {
+		g_printerr ("Error creating zoomer proxy: %s\n", error->message);
+		g_error_free (error);
+
+		return;
+	}
+
+	result = g_dbus_proxy_call_sync (magnifier,
+					 "addZoomRegion",
+					 g_variant_new ("(o)",
+							g_dbus_proxy_get_object_path (zoomer)),
+					 G_DBUS_CALL_FLAGS_NO_AUTO_START,
+					 -1, NULL, &error);
+	if (error) {
+		g_printerr ("Error calling method addZoomRegion: %s\n", error->message);
+		g_error_free (error);
+		g_object_unref (zoomer);
+
+		return;
+	}
+	g_variant_unref (result);
+
+	g_dbus_proxy_set_cached_property (zoomer, "Smoothscroll",
+					  g_variant_new_uint32 (scroll_policy));
+	g_dbus_proxy_set_cached_property (zoomer, "Xalign",
+					  g_variant_new_int32 (align));
+	g_dbus_proxy_set_cached_property (zoomer, "Yalign",
+					  g_variant_new_int32 (align));
 
-	init_rectbounds (roi, 0, 0, 100, 100);
-	init_rectbounds (viewport, x1, y1, x2, y2);
-	
-	zoomer = GNOME_Magnifier_Magnifier_createZoomRegion (magnifier,
-							     xscale,
-							     yscale,
-							     roi,
-							     viewport,
-							     &ev);
-	GNOME_Magnifier_Magnifier_addZoomRegion (magnifier,
-						 zoomer,
-						 &ev);
-	
-	properties = GNOME_Magnifier_ZoomRegion_getProperties (zoomer, &ev);
-
-	Bonobo_PropertyBag_setValue (properties, "smooth-scroll-policy",
-				     bonobo_arg_new_from (BONOBO_ARG_INT,
-							  &scroll_policy), &ev);
-	Bonobo_PropertyBag_setValue (properties, "x-alignment",
-				     bonobo_arg_new_from (BONOBO_ARG_INT,
-							  &align), &ev);
-	Bonobo_PropertyBag_setValue (properties, "y-alignment",
-				     bonobo_arg_new_from (BONOBO_ARG_INT,
-							  &align), &ev);
-	
 	if (smoothing_type)
 	{
-		BonoboArg *arg = bonobo_arg_new (BONOBO_ARG_STRING);
-		BONOBO_ARG_SET_STRING (arg, smoothing_type);
-		Bonobo_PropertyBag_setValue (properties, "smoothing-type",
-					     arg, &ev);
+		g_dbus_proxy_set_cached_property (zoomer, "Smoothing",
+						  g_variant_new_string (smoothing_type));
 	}
-	
+
 	if (is_inverse)
-		Bonobo_PropertyBag_setValue (properties, "inverse-video",
-					     bonobo_arg_new_from (BONOBO_ARG_BOOLEAN,
-								  &is_inverse),
-								  &ev);
+		g_dbus_proxy_set_cached_property (zoomer, "Invert",
+						  g_variant_new_boolean (is_inverse));
+	g_object_unref (zoomer);
 }
 
-int main(int argc, char ** argv){
-
-	GNOME_Magnifier_Magnifier magnifier;
-	GNOME_Magnifier_RectBounds *viewport = NULL;
-	CORBA_Environment ev;
-	CORBA_any *rect_any;
-	Bonobo_PropertyBag properties;
+int main(int argc, char ** argv)
+{
+	GDBusProxy *magnifier;
 	int x, y, width, height;
-
-	CORBA_exception_init (&ev);
-	
-	if (!bonobo_init (&argc, argv))
-	{
-		g_error ("Could not initialize Bonobo");
+	GError *error = NULL;
+
+	gtk_init (&argc, &argv);
+
+	magnifier = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SESSION,
+						   G_DBUS_PROXY_FLAGS_NONE,
+						   NULL,
+						   "org.freedesktop.gnome.Magnifier",
+						   "/org/freedesktop/gnome/Magnifier",
+						   "org.freedesktop.gnome.Magnifier",
+						   NULL, &error);
+	if (!magnifier) {
+		g_printerr ("Error creating magnifier proxy: %s\n", error->message);
+		g_error_free (error);
+
+		return 1;
 	}
-	
-	magnifier = get_magnifier ();
 
-	gdk_init (&argc, &argv);
-	properties = GNOME_Magnifier_Magnifier_getProperties (magnifier, &ev);
 	width = gdk_screen_get_width (gdk_screen_get_default ());
 	height = gdk_screen_get_height (gdk_screen_get_default ());
 	x = width / 2;
 	y = 0;
-	viewport = GNOME_Magnifier_RectBounds__alloc ();
-	init_rect_bounds (viewport, x, y, width - x, height);
-	rect_any = bonobo_arg_new_from (TC_GNOME_Magnifier_RectBounds,
-					viewport);
-	bonobo_pbclient_set_value (properties, "target-display-bounds",
-				   rect_any, &ev);
-	bonobo_arg_release (rect_any);
-	bonobo_object_release_unref (properties, NULL);
-	
-	GNOME_Magnifier_Magnifier_clearAllZoomRegions (magnifier, &ev);
-	
-	test_new_region (magnifier, 2.0, 2.0, 0, 0, 400, 200,
-			 GNOME_Magnifier_ZoomRegion_SCROLL_SMOOTHEST,
-			 NULL, FALSE, GNOME_Magnifier_ZoomRegion_ALIGN_CENTER);
-	test_new_region (magnifier, 2.0, 2.0, 0, 200, 400, 400,
-			 GNOME_Magnifier_ZoomRegion_SCROLL_FASTEST,
-			 NULL, FALSE, GNOME_Magnifier_ZoomRegion_ALIGN_CENTER);
-	test_new_region (magnifier, 0.75, 1.5, 0, 400, 200, 600,
-			 GNOME_Magnifier_ZoomRegion_SCROLL_FASTEST,
-			 "bilinear", TRUE, GNOME_Magnifier_ZoomRegion_ALIGN_CENTER);
-	test_new_region (magnifier, 3.0, 3.0, 200, 400, 400, 600,
-			 GNOME_Magnifier_ZoomRegion_SCROLL_FASTEST,
-			 "bilinear", FALSE, GNOME_Magnifier_ZoomRegion_ALIGN_MIN);	
+	g_dbus_proxy_set_cached_property (magnifier,
+					  "TargetSize",
+					  get_rectbounds (x, y, width - x, height));
+
+	g_dbus_proxy_call_sync (magnifier,
+				"clearAllZoomRegions",
+				NULL,
+				G_DBUS_CALL_FLAGS_NO_AUTO_START,
+				-1, NULL, &error);
+	if (!error) {
+		test_new_region (magnifier, 2.0, 2.0, 0, 0, 400, 200,
+				 SCROLL_SMOOTHEST,
+				 NULL, FALSE, ALIGN_CENTER);
+		test_new_region (magnifier, 2.0, 2.0, 0, 200, 400, 400,
+				 SCROLL_FASTEST,
+				 NULL, FALSE, ALIGN_CENTER);
+		test_new_region (magnifier, 0.75, 1.5, 0, 400, 200, 600,
+				 SCROLL_FASTEST,
+				 "bilinear", TRUE, ALIGN_CENTER);
+		test_new_region (magnifier, 3.0, 3.0, 200, 400, 400, 600,
+				 SCROLL_FASTEST,
+				 "bilinear", FALSE, ALIGN_MIN);
+	} else {
+		g_printerr ("Error calling method clearAllZoomRegions: %s\n", error->message);
+		g_error_free (error);
+		g_object_unref (magnifier);
+
+		return 1;
+	}
+
+	g_object_unref (magnifier);
+
 	return 0;
 }