magnifier.c

在Linux下实现magnification功能

						magnifier->priv->w->window,
						&x, &y);
					gdk_drawable_get_size (
						magnifier->priv->w->window,
						&over_w, &over_h);
					gdk_window_move_resize (
						magnifier->priv->overlay,
						x, y, over_w, over_h);
					gdk_window_reparent (
						magnifier->priv->w->window,
						magnifier->priv->overlay,
						0, 0);
#ifdef HAVE_SHAPEINPUT			
					XShapeCombineRectangles (GDK_WINDOW_XDISPLAY (magnifier->priv->w->window), GDK_WINDOW_XID (magnifier->priv->overlay), ShapeInput, 0, 0, NULL, 0, ShapeSet, YXBanded);
#endif /* HAVE_SHAPEINPUT */
#else
#ifdef HAVE_SHAPEINPUT
					XShapeCombineRectangles (GDK_WINDOW_XDISPLAY (magnifier->priv->w->window), GDK_WINDOW_XID (magnifier->priv->w->window), ShapeInput, 0, 0, NULL, 0, ShapeSet, YXBanded);
#endif /* HAVE_SHAPEINPUT */
#endif /* HAVE_OVERLAY */
					return FALSE;
				}
		}
	} else
		return FALSE;
	return TRUE;
#endif
	return FALSE;
}

static gboolean 
magnifier_reset_struts_at_idle (gpointer data)
{
	if (data)
	{
		Magnifier *magnifier = MAGNIFIER (data);
		if (magnifier->priv && GTK_WIDGET_REALIZED (magnifier->priv->w) && 
		    magnifier_check_set_struts (magnifier))
		{
			return FALSE;
		}
	}
	return TRUE;
}

static gboolean
magnifier_check_set_struts (Magnifier *magnifier)
{
#ifdef HAVE_COMPOSITE
	if (!g_getenv ("MAGNIFIER_IGNORE_COMPOSITE"))
		return TRUE;
#endif

	if (magnifier &&
	    magnifier->priv && magnifier->priv->w && GTK_WIDGET_REALIZED (magnifier->priv->w) &&
	    magnifier->priv->w->window) 
	{
		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;
		gint width = gdk_screen_get_width (
			gdk_display_get_screen (magnifier->target_display,
						magnifier->target_screen_num));
		gint height = gdk_screen_get_height (
			gdk_display_get_screen (magnifier->target_display,
						magnifier->target_screen_num));

		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);

		left_margin = wx;
		right_margin = (width - ww) - wx;
		top_margin = wy;
		bottom_margin = (height - wh) - wy;

		/* set the WM_STRUT properties on the appropriate side */
		if (bottom_margin > top_margin && 
		    bottom_margin > left_margin &&
		    bottom_margin > right_margin)
		{
			struts[STRUT_TOP] = wh + wy;
			struts[STRUT_TOP_START] = wx;
			struts[STRUT_TOP_END] = wx + ww;
		} 
		else if (top_margin > bottom_margin && 
			 top_margin > left_margin &&
			 top_margin > right_margin)
		{
			struts[STRUT_BOTTOM] = height - wy;
			struts[STRUT_BOTTOM_START] = wx;
			struts[STRUT_BOTTOM_END] = wx + ww;
		}
		else if (right_margin > left_margin &&
			 right_margin > top_margin &&
			 right_margin > bottom_margin)
		{
			struts[STRUT_LEFT] = wx;
			struts[STRUT_LEFT_START] = wy;
			struts[STRUT_LEFT_END] = wh + wy;
		}
		else 
		{
			struts[STRUT_RIGHT] = width - wx;
			struts[STRUT_RIGHT_START] = wy;
			struts[STRUT_RIGHT_END] = wy + wh;
		}
		
		gdk_error_trap_push ();
		XChangeProperty (GDK_WINDOW_XDISPLAY (widget->window), 
				 GDK_WINDOW_XWINDOW (widget->window), 
				 atom_strut,
				 XA_CARDINAL, 32, PropModeReplace,
				 (guchar *) &struts, 4);
		XChangeProperty (GDK_WINDOW_XDISPLAY (widget->window), 
				 GDK_WINDOW_XWINDOW (widget->window), 
				 atom_strut_partial,
				 XA_CARDINAL, 32, PropModeReplace,
				 (guchar *) &struts, 12); 
		gdk_error_trap_pop ();

#ifdef DEBUG_STRUTS
		g_message ("struts TOP %d (%d - %d)", struts[STRUT_TOP], struts[STRUT_TOP_START], struts[STRUT_TOP_END]);
		g_message ("struts BOTTOM %d (%d - %d)", struts[STRUT_BOTTOM], struts[STRUT_BOTTOM_START], struts[STRUT_BOTTOM_END]);
		g_message ("struts LEFT %d (%d - %d)", struts[STRUT_LEFT], struts[STRUT_LEFT_START], struts[STRUT_LEFT_END]);
		g_message ("struts RIGHT %d (%d - %d)", struts[STRUT_RIGHT], struts[STRUT_RIGHT_START], struts[STRUT_RIGHT_END]);
#endif
		return TRUE;
	}
	return FALSE;
}

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);

		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);

		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_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);
	};
}

static void
magnifier_set_property (BonoboPropertyBag *bag,
			BonoboArg *arg,
			guint arg_id,
			CORBA_Environment *ev,
			gpointer user_data)
{
	Magnifier *magnifier = user_data;
	gchar *full_display_string;

	switch (arg_id) {
	case MAGNIFIER_SOURCE_DISPLAY_PROP:
		full_display_string = BONOBO_ARG_GET_STRING (arg);
		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));
	             /* 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_zoom_regions_restore (magnifier, zoom_region_params);
		    magnifier_warp_cursor_to_screen (magnifier);
		    magnifier_check_set_struts (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);
		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 */
		    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)
		    {
			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); */
		    magnifier_check_set_struts (magnifier);
		}
		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);
		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);
		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);
		magnifier_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);
		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)));
		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_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);
		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_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);
		/* 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);
		break;
	case MAGNIFIER_CROSSWIRE_SIZE_PROP:
		magnifier->crosswire_size = BONOBO_ARG_GET_INT (arg);
		DBG (fprintf (stderr, "Setting crosswire size: \t%d\n", magnifier->crosswire_size));
		/* TODO: notify zoomers */
		break;
	case MAGNIFIER_CROSSWIRE_CLIP_PROP:
		magnifier->crosswire_clip = BONOBO_ARG_GET_BOOLEAN (arg);
		DBG (fprintf (stderr, "Setting crosswire clip: \t%s\n", magnifier->crosswire_clip ? "true" : "false"));
		break;
	case MAGNIFIER_CROSSWIRE_COLOR_PROP:
		magnifier->crosswire_color = BONOBO_ARG_GET_LONG (arg);
		DBG (fprintf (stderr, "Setting crosswire size: \t%ld\n", (long) magnifier->crosswire_color));
		break;
	default:
		bonobo_exception_set (ev, ex_Bonobo_PropertyBag_NotFound);
		break;
	};
}

static void
magnifier_do_dispose (Magnifier *magnifier)
{
	/* FIXME: this is dead ropey code structuring */
	bonobo_activation_active_server_unregister (
		MAGNIFIER_OAFIID, BONOBO_OBJREF (magnifier));

	if (magnifier->zoom_regions)
		g_list_free (magnifier->zoom_regions);
	magnifier->zoom_regions = NULL;
	
	bonobo_main_quit ();
}

static void
magnifier_gobject_dispose (GObject *object)
{
	magnifier_do_dispose (MAGNIFIER (object));

	BONOBO_CALL_PARENT (G_OBJECT_CLASS, dispose, (object));
}

static void
impl_magnifier_set_source_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);
	BONOBO_ARG_SET_STRING (arg, display);
	
	DBG (fprintf (stderr, "Set source display: \t%s\n", display));

	if (strcmp (display, 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",
			  display));
	}
	bonobo_arg_release (arg);
}

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);
	BONOBO_ARG_SET_STRING (arg, display);
	
	DBG (fprintf (stderr, "Set target display: \t%s\n", display));

	if (strcmp (display, 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",
			  display));
	}
	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));