GNOME.org
 

[gnome-mag] d-bus changes that where not committed last time

commit 78430636689160bc03f6b13859d0c437f4ccad5a
Author: Carlos Eduardo Rodrigues DiÃgenes <cerdiogenes gmail com>
Date:   Sat Jan 23 12:03:50 2010 -0200

    d-bus changes that where not committed last time

 Makefile.am                   |    2 +-
 configure.in                  |    9 ++
 magnifier/Makefile.am         |   30 +++++-
 magnifier/magnifier-main.c    |   16 ++-
 magnifier/magnifier-private.h |   30 +++---
 magnifier/magnifier.c         |  254 ++++++++++++++++++++++++++++++++++++++---
 magnifier/magnifier.h         |  109 +++++++++++-------
 magnifier/zoom-region.c       |  233 +++++++++++++++++++++++++++++++++++++-
 magnifier/zoom-region.h       |   27 ++++-
 test/control-client.c         |    4 +-
 10 files changed, 623 insertions(+), 91 deletions(-)
---
diff --git a/Makefile.am b/Makefile.am
index 0bc7d6c..5a45d0e 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -1,6 +1,6 @@
 # Process this file with automake to create Makefile.in.
 
-SUBDIRS = idl magnifier test $(CB_DIR) po cursors docs
+SUBDIRS = idl xml magnifier test $(CB_DIR) po cursors docs
 
 pkgconfigdir = $(libdir)/pkgconfig
 pkgconfig_DATA= gnome-mag-1.0.pc
diff --git a/configure.in b/configure.in
index 2a147e1..73cc787 100644
--- a/configure.in
+++ b/configure.in
@@ -250,6 +250,7 @@ PKG_CHECK_MODULES(DEPS, [
 	glib-2.0		>= 2.11.1
 	gtk+-2.0		>= 2.1.0
 	gdk-pixbuf-2.0		>= 2.1.0
+	dbus-glib-1
 ])
 AC_SUBST(DEPS_LIBS)
 AC_SUBST(DEPS_CFLAGS)
@@ -291,6 +292,13 @@ 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.])
+if test -z "$DEFAULT_GMAG_INTROSPECTION_PATH"; then
+          DEFAULT_GMAG_INTROSPECTION_PATH=gnome-mag/dbus
+fi
+
 AC_OUTPUT([
 Makefile
 gnome-mag-1.0.pc
@@ -298,6 +306,7 @@ gnome-mag-1.0-uninstalled.pc
 po/Makefile.in
 idl/Makefile
 magnifier/Makefile
+xml/Makefile
 cursors/Makefile
 cursors/1_32/Makefile
 test/Makefile
diff --git a/magnifier/Makefile.am b/magnifier/Makefile.am
index c410a2c..2828ee7 100644
--- a/magnifier/Makefile.am
+++ b/magnifier/Makefile.am
@@ -6,7 +6,7 @@ bin_PROGRAMS = magnifier
 
 libgnome_mag_la_SOURCES = \
 	GNOME_Magnifier-common.c \
-	GNOME_Magnifier-stubs.c
+	GNOME_Magnifier-stubs.c 
 
 libgnome_mag_la_DEPENDENCIES = \
 	GNOME_Magnifier.h
@@ -32,6 +32,7 @@ magnifier_SOURCES = magnifier-main.c \
 	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 \
@@ -85,9 +86,18 @@ $(server_in_files): $(server_in_files).in
 server_in_files = GNOME_Magnifier.server.in
 serverinfo_DATA = $(server_in_files:.server.in=.server)
 
+servicedir	= $(datadir)/dbus-1/services
+service_in_files= org.freedesktop.gnome.Magnifier.service.in
+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 
+EXTRA_DIST = $(server_in_files).in
 
 $(IDL_OUT) : $(IDL) $(ORBIT_IDL)
 	$(ORBIT_IDL) $(IDLFLAGS) $(IDL)
@@ -96,6 +106,22 @@ DONT_DIST_SOURCE = $(IDL_OUT)
 
 CLEANFILES += $(server_in_files) $(serverinfo_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 $< > $@
+
+zoom-region-server.h: $(top_srcdir)/xml/org.freedesktop.gnome.ZoomRegion.xml
+	dbus-binding-tool --prefix=impl_dbus_zoom_region --mode=glib-server $< > $@
+
+zoom-region-client.h: $(top_srcdir)/xml/org.freedesktop.gnome.ZoomRegion.xml
+	dbus-binding-tool --prefix=impl_dbus_zoom_region --mode=glib-client $< > $@
+
 dist-hook:
 	for file in $(DONT_DIST_SOURCE) ; do \
 	    rm -f $(distdir)/$$file ; \
diff --git a/magnifier/magnifier-main.c b/magnifier/magnifier-main.c
index a2f89a1..5c41f6b 100644
--- a/magnifier/magnifier-main.c
+++ b/magnifier/magnifier-main.c
@@ -27,6 +27,8 @@
 #include "gmag-graphical-server.h"
 #include "GNOME_Magnifier.h"
 
+#include <unistd.h>
+
 #include <string.h>
 #include <stdlib.h>
 #include <sys/time.h>
@@ -179,7 +181,7 @@ magnifier_main_test_image (gpointer data)
 	CORBA_Environment ev;
 	GNOME_Magnifier_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) {
@@ -373,7 +375,7 @@ main (int argc, char** argv)
   guint pan_handle = 0, refresh_handle = 0;
   CORBA_Environment ev;
   Bonobo_PropertyBag properties;
-
+  
   Magnifier *magnifier;
   
   if (!bonobo_init (&argc, argv)) {
@@ -403,7 +405,7 @@ main (int argc, char** argv)
 	  string = g_strconcat ("DISPLAY=", global_options.target_display, NULL);
 	  putenv (string);
   } else {
-		  global_options.target_display = getenv ("DISPLAY");
+		  global_options.target_display = g_getenv ("DISPLAY");
 		  if (!global_options.target_display) {
 			  fprintf (stderr, _("Can't open display: DISPLAY is not set"));
 			  exit (1);
@@ -436,15 +438,15 @@ main (int argc, char** argv)
   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.target_display)
-	  bonobo_pbclient_set_string (properties, "target-display-screen",
-				      global_options.target_display, NULL);
-
   if (global_options.cursor_set)
 	  bonobo_pbclient_set_string (properties, "cursor-set",
 				      global_options.cursor_set, NULL);
diff --git a/magnifier/magnifier-private.h b/magnifier/magnifier-private.h
index 318362f..a518975 100644
--- a/magnifier/magnifier-private.h
+++ b/magnifier/magnifier-private.h
@@ -28,22 +28,22 @@ G_BEGIN_DECLS
 #include <gtk/gtk.h>
 
 struct _MagnifierPrivate {
-	GtkWidget *w;
-	GtkWidget *canvas;
-	GdkWindow *root;
-	GdkWindow *overlay;
-	GdkPixmap *source_drawable;
+	GtkWidget   *w;
+	GtkWidget   *canvas;
+	GdkWindow   *root;
+	GdkWindow   *overlay;
+	GdkPixmap   *source_drawable;
 	GdkDrawable *cursor;
-        int cursor_default_size_x;
-        int cursor_default_size_y;
-	gboolean crosswire;
-	GdkBitmap *cursor_mask;
- 	int cursor_x;
-	int cursor_y;
-	int cursor_hotspot_x;
-	int cursor_hotspot_y;
-        gboolean use_source_cursor;
-        GHashTable *cursorlist;
+        int          cursor_default_size_x;
+        int          cursor_default_size_y;
+	gboolean     crosswire;
+	GdkBitmap   *cursor_mask;
+ 	int          cursor_x;
+	int          cursor_y;
+	int          cursor_hotspot_x;
+	int          cursor_hotspot_y;
+        gboolean     use_source_cursor;
+        GHashTable  *cursorlist;
 };
 
 G_END_DECLS
diff --git a/magnifier/magnifier.c b/magnifier/magnifier.c
index c51d6c1..88e1254 100644
--- a/magnifier/magnifier.c
+++ b/magnifier/magnifier.c
@@ -28,6 +28,7 @@
 #include "gmag-cursor.h"
 #include "gmag-graphical-server.h"
 #include "GNOME_Magnifier.h"
+#include "magnifier-server.h"
 
 #include <stdlib.h>
 #include <string.h>
@@ -36,6 +37,8 @@
 #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>
@@ -84,19 +87,20 @@ enum {
 typedef struct
 {
 	GNOME_Magnifier_RectBounds rectbounds;
+	RectBounds dbus_rectbounds;
 	GNOME_Magnifier_RectBounds viewport;
-	gboolean is_managed;
-	gint scroll_policy;
-	gfloat contrast;
-	gfloat zx;
-	gfloat zy;
-	gint32 xalign;
-	gint32 yalign;
-	guint32 border_color;
-	gint32 border_size;
-	gchar *smoothing_type;
-	gboolean inverse;
-
+	RectBounds dbus_viewport;
+	gboolean   is_managed;
+	gint       scroll_policy;
+	gfloat     contrast;
+	gfloat     zx;
+	gfloat     zy;
+	gint32     xalign;
+	gint32     yalign;
+	guint32    border_color;
+	gint32     border_size;
+	gchar     *smoothing_type;
+	gboolean   inverse;
 } MagnifierZoomRegionSaveProps;
 
 #ifdef DEBUG_CLIENT_CALLS
@@ -128,6 +132,8 @@ static void magnifier_init_window (Magnifier *magnifier, GdkScreen *screen);
 static void magnifier_adjust_source_size (Magnifier *magnifier);
 static gboolean _is_override_redirect = FALSE;
 
+static GHashTable *zoom_hash = NULL;
+
 static Window*
 mag_login_helper_get_raise_windows (LoginHelper *helper)
 {
@@ -149,7 +155,6 @@ 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;
@@ -484,8 +489,8 @@ magnifier_adjust_source_size (Magnifier *magnifier)
 				  magnifier->target_bounds.y2) /
 		(double) rect_bounds.y2;
 
-	/* we make our 'source' rectangle the largest available subsection which we aren't occupying */
 	if (magnifier_full_screen_capable (magnifier)) {
+	/* we make our 'source' rectangle the largest available subsection which we aren't occupying */
 		magnifier->source_bounds = rect_bounds;
 	} else if (MAX (hfract_left, hfract_right) >
 		   MAX (vfract_top, vfract_bottom)) {  /* vertical split,
@@ -534,6 +539,17 @@ magnifier_unref_zoom_region (gpointer data, gpointer user_data)
 	    Bonobo_Unknown_unref (zoom_region, &ev);
 }
 
+static void
+magnifier_dbus_unref_zoom_region (gpointer data, gpointer user_data)
+{
+/*	Magnifier *magnifier = user_data; NOT USED */
+	ZoomRegion *zoom_region = data;
+	
+	DBG(g_message ("unreffing zoom region"));
+
+	impl_dbus_zoom_region_dispose (zoom_region);
+}
+
 static GSList*
 magnifier_zoom_regions_save (Magnifier *magnifier)
 {
@@ -582,6 +598,7 @@ magnifier_zoom_regions_save (Magnifier *magnifier)
     }   
 
     magnifier->zoom_regions = NULL;
+    magnifier->zoom_regions_dbus = NULL;
 
     return save_props;
 }
@@ -960,6 +977,40 @@ magnifier_get_property (BonoboPropertyBag *bag,
 }
 
 static void
+magnifier_set_target_size (gpointer data)
+{
+	Magnifier *magnifier = (Magnifier *) data;
+
+	magnifier->target_bounds.x1 = 150;
+	magnifier->target_bounds.y1 = 150;
+	magnifier->target_bounds.x2 = 300;
+	magnifier->target_bounds.y2 = 300;
+
+	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);
+}
+
+static void
 magnifier_set_property (BonoboPropertyBag *bag,
 			BonoboArg *arg,
 			guint arg_id,
@@ -1199,9 +1250,12 @@ magnifier_do_dispose (Magnifier *magnifier)
 	bonobo_activation_active_server_unregister (
 		MAGNIFIER_OAFIID, BONOBO_OBJREF (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 ();
 }
@@ -1258,6 +1312,141 @@ impl_magnifier_full_screen_capable (PortableServer_Servant servant,
 	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)
+{
+	magnifier_set_target_size (magnifier);
+
+	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)
+{
+	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;
+}
+
+gboolean
+impl_dbus_magnifier_dispose (Magnifier *magnifier)
+{
+	magnifier_do_dispose (magnifier);
+	
+	return TRUE;
+}
+
 static void
 impl_magnifier_set_source_display (PortableServer_Servant servant,
 				   const CORBA_char *display,
@@ -1475,6 +1664,7 @@ impl_magnifier_clear_all_zoom_regions (PortableServer_Servant servant,
 			magnifier_unref_zoom_region, magnifier);
 	g_list_free (magnifier->zoom_regions);
 	magnifier->zoom_regions = NULL;
+	magnifier->zoom_regions_dbus = NULL;
 }
 
 static void
@@ -1497,8 +1687,7 @@ magnifier_class_init (MagnifierClass *klass)
 	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->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;
@@ -1526,7 +1715,6 @@ magnifier_properties_init (Magnifier *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));
@@ -1710,6 +1898,7 @@ 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");
@@ -1746,6 +1935,8 @@ magnifier_init (Magnifier *magnifier)
 #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);
 }
 
 GdkDrawable *
@@ -1782,6 +1973,10 @@ 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;
@@ -1806,10 +2001,33 @@ magnifier_new (gboolean override_redirect)
 	    } 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;
 }
 
diff --git a/magnifier/magnifier.h b/magnifier/magnifier.h
index fcd8527..0127d10 100644
--- a/magnifier/magnifier.h
+++ b/magnifier/magnifier.h
@@ -38,45 +38,62 @@ extern "C" {
 
 #include <login-helper/login-helper.h>
 
+#include <dbus/dbus-glib.h>
+
 #define MAGNIFIER_TYPE         (magnifier_get_type ())
 #define MAGNIFIER(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), MAGNIFIER_TYPE, Magnifier))
 #define MAGNIFIER_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST((k), MAGNIFIER_TYPE, MagnifierClass))
-#define IS_MAGNIFIER(o)       (G_TYPE_CHECK_INSTANCE_TYPE ((o), MAGNIFIER_TYPE))
-#define IS_MAGNIFIER_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), MAGNIFIER_TYPE))
+#define IS_MAGNIFIER(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), MAGNIFIER_TYPE))
+#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 {
-        BonoboObject parent;
-	BonoboPropertyBag *property_bag;
-	GdkDisplay *source_display;
-	GdkDisplay *target_display;
-	gchar *source_display_name;
-	gchar *target_display_name;
-	int source_screen_num;
-	int target_screen_num;
-	GList *zoom_regions;
-        gboolean source_initialized;
-	gint crosswire_size;
-	gint crosswire_length;
-	guint32 crosswire_color;
-	gboolean crosswire_clip;
-	gchar *cursor_set;
-	gint cursor_size_x;
-	gint cursor_size_y;
-	guint32 cursor_color;
-	float cursor_scale_factor;
+	gint32 x1;
+	gint32 y1;
+	gint32 x2;
+	gint32 y2;
+} RectBounds;
+
+typedef struct {
+	gint32 x;
+	gint32 y;
+} Point;
+
+typedef struct {
+        BonoboObject       parent;
+        BonoboPropertyBag *property_bag;
+	GdkDisplay        *source_display;
+	GdkDisplay        *target_display;
+	gchar             *source_display_name;
+	gchar             *target_display_name;
+	int                source_screen_num;
+	int                target_screen_num;
+	GList             *zoom_regions;
+	GList		  *zoom_regions_dbus;
+        gboolean           source_initialized;
+	gint               crosswire_size;
+	gint               crosswire_length;
+	guint32            crosswire_color;
+	gboolean           crosswire_clip;
+	gchar             *cursor_set;
+	gint               cursor_size_x;
+	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;
-	MagnifierPrivate *priv;
+	GNOME_Magnifier_Point	   cursor_hotspot;
+	MagnifierPrivate  *priv;
 } Magnifier;
 
 typedef struct {
-        BonoboObjectClass parent_class;
-        POA_GNOME_Magnifier_Magnifier__epv epv;
+        BonoboObjectClass                   parent_class;
+        POA_GNOME_Magnifier_Magnifier__epv  epv;
+        DBusGConnection                    *connection;
 } MagnifierClass;
 
 /*
@@ -129,27 +146,27 @@ typedef struct {
  */
 
 typedef struct timing {
-	GTimer *process;
-	GTimer *frame;
-	GTimer *scale;
-	GTimer *idle;
+	GTimer  *process;
+	GTimer  *frame;
+	GTimer  *scale;
+	GTimer  *idle;
 	gdouble scale_val;
 	gdouble idle_val;
 	gdouble frame_val;
-	int   dx;
-	int   dy;
+	int     dx;
+	int     dy;
 	gdouble scale_total;
 	gdouble idle_total;
 	gdouble frame_total;
-	int   dx_total;
-	int   dy_total;
-	long  update_pixels_total;
-	long  num_scale_samples;
-	long  num_idle_samples;
-	long  num_frame_samples;
-	long  num_line_samples;
+	int     dx_total;
+	int     dy_total;
+	long    update_pixels_total;
+	long    num_scale_samples;
+	long    num_idle_samples;
+	long    num_frame_samples;
+	long    num_line_samples;
 	gdouble last_frame_val;
-	int   last_dy;
+	int     last_dy;
 } TimingStruct;
 
 TimingStruct mag_timing;
@@ -168,6 +185,20 @@ void         magnifier_set_cursor_pixmap_by_name (Magnifier *magnifier,
 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);
+
+
 #ifdef __cplusplus
 }
 #endif /* __cplusplus */
diff --git a/magnifier/zoom-region.c b/magnifier/zoom-region.c
index add7a0a..0c8e12b 100644
--- a/magnifier/zoom-region.c
+++ b/magnifier/zoom-region.c
@@ -48,6 +48,7 @@
 #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
 
@@ -148,6 +149,8 @@ static gboolean timing_start = FALSE;
 
 static gboolean can_coalesce = TRUE ; /* change this when event coalescing is working */
 
+static int zoom_region_number = 0;
+
 #define CLAMP_B_C(v) (t = (v), CLAMP (t, -1, 1));
 
 static void zoom_region_sync (ZoomRegion *region);
@@ -209,6 +212,15 @@ _debug_announce_rect (char *msg, GdkRectangle rect)
 		 msg, rect.x, rect.y, rect.x + rect.width, rect.y + rect.height);
 }
 
+static void
+_set_bounds (RectBounds *struct_bounds, const gint32 **vector_bounds)
+{
+	struct_bounds->x1 = (*vector_bounds)[0];
+	struct_bounds->y1 = (*vector_bounds)[1];
+	struct_bounds->x2 = (*vector_bounds)[2];
+	struct_bounds->y2 = (*vector_bounds)[3];
+}
+
 static gboolean
 _diff_pixbufs (const GdkPixbuf *a, const GdkPixbuf *b)
 {
@@ -706,7 +718,7 @@ zoom_region_update_scale (ZoomRegion *zoom_region, gdouble x, gdouble y)
 		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);
 
-		return CORBA_FALSE;
+		return FALSE;
 	}
 
 	zoom_region_get_move_x_y (zoom_region, &x_move, &y_move);
@@ -715,7 +727,7 @@ zoom_region_update_scale (ZoomRegion *zoom_region, gdouble x, gdouble y)
 	zoom_region_recompute_exposed_bounds (zoom_region);
 	zoom_region_update_current (zoom_region);
 
-	return CORBA_TRUE;
+	return TRUE;
 }
 
 static void
@@ -3196,6 +3208,200 @@ impl_zoom_region_dispose (PortableServer_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 float mag_factor_x, const float 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;
+}
+
+gboolean
+impl_dbus_zoom_region_get_mag_factor (ZoomRegion *zoom_region)
+{
+	return TRUE;
+}
+
+gboolean
+impl_dbus_zoom_region_set_roi (ZoomRegion *zoom_region, const gint32 **roi)
+{
+	RectBounds *bounds = g_malloc(sizeof(RectBounds));
+	_set_bounds (bounds, roi);
+
+	#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));
+
+	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 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 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);
+	}
+	
+	return TRUE;
+}
+
+gboolean
+impl_dbus_zoom_region_update_pointer (ZoomRegion *zoom_region)
+{
+	return TRUE;
+}
+
+gboolean
+impl_dbus_zoom_region_mark_dirty (ZoomRegion *zoom_region)
+{
+	return TRUE;
+}
+
+gboolean
+impl_dbus_zoom_region_get_roi (ZoomRegion *zoom_region)
+{
+	return TRUE;
+}
+
+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;
+}
+
+gboolean
+impl_dbus_zoom_region_set_pointer_pos (ZoomRegion *zoom_region) {
+	return TRUE;
+}
+
+gboolean
+impl_dbus_zoom_region_set_contrast (ZoomRegion *zoom_region)
+{
+	return TRUE;
+}
+
+gboolean
+impl_dbus_zoom_region_get_contrast (ZoomRegion *zoom_region)
+{
+	return TRUE;
+}
+
+gboolean
+impl_dbus_zoom_region_set_brightness (ZoomRegion *zoom_region)
+{
+	return TRUE;
+}
+
+gboolean
+impl_dbus_zoom_region_get_brightness (ZoomRegion *zoom_region)
+{
+	return TRUE;
+}
 
 /* could be called multiple times */
 static void
@@ -3711,7 +3917,28 @@ zoom_region_init (ZoomRegion *zoom_region)
 ZoomRegion *
 zoom_region_new (void)
 {
-	return g_object_new (zoom_region_get_type(), NULL);
+	ZoomRegionClass *klass = NULL;
+	GError *error = NULL;
+	ZoomRegion *_this_zoom_region = g_object_new (zoom_region_get_type(), NULL);
+	_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);
+		g_error_free (error);
+		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 */
diff --git a/magnifier/zoom-region.h b/magnifier/zoom-region.h
index 546652e..ef22889 100644
--- a/magnifier/zoom-region.h
+++ b/magnifier/zoom-region.h
@@ -34,8 +34,9 @@ extern "C" {
 #define ZOOM_REGION_TYPE         (zoom_region_get_type ())
 #define ZOOM_REGION(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), ZOOM_REGION_TYPE, ZoomRegion))
 #define ZOOM_REGION_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST((k), ZOOM_REGION_TYPE, ZoomRegionClass))
-#define IS_ZOOM_REGION(o)       (G_TYPE_CHECK__INSTANCE_TYPE ((o), ZOOM_REGION_TYPE))
-#define IS_ZOOM_REGION_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), ZOOM_REGION_TYPE))
+#define IS_ZOOM_REGION(o)        (G_TYPE_CHECK__INSTANCE_TYPE ((o), ZOOM_REGION_TYPE))
+#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 GList * (*CoalesceFunc)(GList *, int);
 
@@ -49,6 +50,7 @@ typedef struct {
 	gboolean draw_cursor;
 	gboolean cache_source;
 	gchar *smoothing;
+	gchar *object_path;
 	gfloat contrast;
 	gfloat xscale;
 	gfloat yscale;
@@ -83,13 +85,30 @@ typedef struct {
 } ZoomRegion;
 
 typedef struct {
-        BonoboObjectClass parent_class;
-        POA_GNOME_Magnifier_ZoomRegion__epv epv;
+        BonoboObjectClass                    parent_class;
+        POA_GNOME_Magnifier_ZoomRegion__epv  epv;
+        DBusGConnection                     *connection;
 } 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 float mag_factor_x,
+		const float mag_factor_y);
+gboolean 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);
+gboolean 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);
+gboolean impl_dbus_zoom_region_set_contrast (ZoomRegion *zoom_region);
+gboolean impl_dbus_zoom_region_get_contrast (ZoomRegion *zoom_region);
+gboolean impl_dbus_zoom_region_set_brightness (ZoomRegion *zoom_region);
+gboolean impl_dbus_zoom_region_get_brightness (ZoomRegion *zoom_region);
+
 #ifdef __cplusplus
 }
 #endif /* __cplusplus */
diff --git a/test/control-client.c b/test/control-client.c
index 0e63419..ff6741e 100644
--- a/test/control-client.c
+++ b/test/control-client.c
@@ -358,8 +358,8 @@ int main(int argc, char ** argv){
 		rect_any->_type = TC_GNOME_Magnifier_RectBounds;
 		rect_any->_value = ORBit_copy_value (rectangle, TC_GNOME_Magnifier_RectBounds);
 		properties = GNOME_Magnifier_Magnifier_getProperties (magnifier, &ev);
-		Bonobo_PropertyBag_setValue (properties, "target-display-bounds", rect_any, NULL);
-		bonobo_object_release_unref (properties, NULL);
+		Bonobo_PropertyBag_setValue (properties, "target-display-bounds", rect_any, &ev);
+		bonobo_object_release_unref (properties, &ev);
 		break;
         case 'X':
 		if (zoom_region == CORBA_OBJECT_NIL) return -1;
[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]