magnifier-main.c

在Linux下实现magnification功能

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

	if (!IS_MAGNIFIER (magnifier))
		return FALSE;
	
	regions = GNOME_Magnifier_Magnifier_getZoomRegions (
		BONOBO_OBJREF (magnifier),
		&ev);

#ifdef DEBUG_REFRESH
	fprintf (stderr, "refreshing %d regions\n", regions->_length);
#endif

	properties = GNOME_Magnifier_Magnifier_getProperties (BONOBO_OBJREF (magnifier), &ev);

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

	bonobo_object_release_unref (properties, NULL);

	return TRUE;
}

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;
  int x = 0, y = 0, fullwidth, fullheight;
  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");
  g_option_context_set_ignore_unknown_options (context, TRUE);
  g_option_context_parse(context, &argc, &argv, NULL);
  g_option_context_free(context);

  if (global_options.print_version) {
	  g_print ("%s\n", VERSION);
	  return 0;
  }

  /** 
   * slight hack, we set $DISPLAY if --target-display is set.
   * this is because I don't think GTK+ works well with across multiple 
   * servers yet.
   **/
  if (global_options.target_display) {
	  gchar *string;
	  string = g_strconcat ("DISPLAY=", global_options.target_display, NULL);
	  putenv (string);
  } else {
		  global_options.target_display = getenv ("DISPLAY");
		  if (!global_options.target_display) {
			  fprintf (stderr, _("Can't open display, DISPLAY is not set"));
			  exit (1);
		  }
  }  

  if (!global_options.source_display) {
		  global_options.source_display = global_options.target_display;
  }

  if (global_options.timing_pan_rate && global_options.timing_iterations == 0)
  {
    g_error ("Must specify timing_iterations when running pan test");
  }

  /* FIXME */
  gtk_init (&argc, &argv);

  if (global_options.ignore_damage)
  {
      g_setenv ("MAGNIFIER_IGNORE_DAMAGE", "1", TRUE);
  }
#ifdef HAVE_COMPOSITE
  if (global_options.ignore_composite) {
	  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.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);

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

  fullwidth = screen_width = gdk_screen_get_width (
	  gdk_display_get_screen (magnifier->target_display,
				  magnifier->target_screen_num));
  fullheight = screen_height = gdk_screen_get_height (
	  gdk_display_get_screen (magnifier->target_display,
				  magnifier->target_screen_num));

  if (global_options.vertical_split) {
	  screen_width /= 2;
	  x = screen_width;
  }
  if (global_options.horizontal_split) {
	  screen_height /= 2;
	  y = screen_height;
  }

  fprintf (stderr, "initial viewport %d %d\n", (int) screen_width,
	   (int) screen_height);

  init_rect_bounds (viewport, x, y, x + screen_width, y + screen_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);

  if (global_options.vertical_split || global_options.horizontal_split) 
  {
#ifdef HAVE_COMPOSITE
	  if (!g_getenv ("MAGNIFIER_IGNORE_COMPOSITE"))
		  init_rect_bounds (viewport, 0, 0, fullwidth, fullheight);
	  else
#endif /* HAVE_COMPOSITE */
		  init_rect_bounds (viewport, 0, 0, fullwidth-x, fullheight-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);
  } else if (global_options.fullscreen) {
	  init_rect_bounds (viewport, 0, 0, fullwidth, fullheight);
	  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);
  }

  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, 100, 100);
	  init_rect_bounds (viewport, 0, 0, screen_width, screen_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);

	  if (strcmp (global_options.smoothing_type, "none"))
		  bonobo_pbclient_set_string (properties, "smoothing-type",
					      global_options.smoothing_type, &ev);

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

  if (global_options.timing_pan_rate)
  {
	  GNOME_Magnifier_ZoomRegionList *zoom_regions;
	  GNOME_Magnifier_RectBounds roi;
	  roi.x1 = 100;
	  roi.x2 = 100 + (screen_width / global_options.zoom_factor);
	  roi.y1 = 0;
	  roi.y2 = screen_height / global_options.zoom_factor;
	  
	  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);
	  }
  }
  else if (global_options.timing_iterations)
  {
	  refresh_handle = g_timeout_add (global_options.refresh_time,
					  magnifier_main_test_image,
					  magnifier);
  }
  else
  {
	  if (global_options.ignore_damage ||
	      !gmag_events_source_has_damage_extension (magnifier)) 
	  {
	  	  refresh_handle = g_timeout_add (
	  		  global_options.refresh_time,
	  		  magnifier_main_refresh_all, magnifier);
	  }
	  
	  pan_handle = g_timeout_add (
		  global_options.mouse_poll_time,
		  magnifier_main_pan_image, magnifier);
  }
  
  bonobo_main ();
  
  if (refresh_handle)
	  g_source_remove (refresh_handle);
  
  if (pan_handle)
	  g_source_remove (pan_handle);

  return 0;
}