自学教程：C++ GOO_CANVAS函数代码示例

GtkWidget *create_clipping_page (void){  GtkWidget *vbox, *scrolled_win, *canvas;  vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 4);  g_object_set (vbox, "margin", 4, NULL);  gtk_widget_show (vbox);  scrolled_win = gtk_scrolled_window_new (NULL, NULL);  gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_win),				       GTK_SHADOW_IN);  gtk_widget_show (scrolled_win);  gtk_box_pack_start (GTK_BOX (vbox), scrolled_win);  gtk_widget_set_halign (scrolled_win, GTK_ALIGN_FILL);  gtk_widget_set_valign (scrolled_win, GTK_ALIGN_FILL);  gtk_widget_set_hexpand (scrolled_win, TRUE);  gtk_widget_set_vexpand (scrolled_win, TRUE);  canvas = goo_canvas_new ();  gtk_widget_set_size_request (canvas, 600, 450);  goo_canvas_set_bounds (GOO_CANVAS (canvas), 0, 0, 1000, 1000);  gtk_widget_show (canvas);  gtk_container_add (GTK_CONTAINER (scrolled_win), canvas);  setup_canvas (GOO_CANVAS (canvas));  return vbox;}

voidsheet_change_zoom (const Sheet *sheet, gdouble rate){	gdouble scale;		sheet->priv->zoom *= rate;	scale = goo_canvas_get_scale (GOO_CANVAS (sheet));	scale = scale * rate;	goo_canvas_set_scale (GOO_CANVAS (sheet), scale);}

intmain (){  GtkWidget *window, *scrolled_win, *canvas;  GooCanvasItem *root, *rect_item, *text_item;  /* Initialize GTK+. */  gtk_init ();  /* Create the window and widgets. */  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);  gtk_window_set_default_size (GTK_WINDOW (window), 640, 600);  gtk_widget_show (window);  g_signal_connect (window, "delete_event", G_CALLBACK (on_delete_event),		    NULL);  scrolled_win = gtk_scrolled_window_new (NULL, NULL);  gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_win),				       GTK_SHADOW_IN);  gtk_widget_show (scrolled_win);  gtk_container_add (GTK_CONTAINER (window), scrolled_win);  canvas = goo_canvas_new ();  gtk_widget_set_size_request (canvas, 600, 450);  goo_canvas_set_bounds (GOO_CANVAS (canvas), 0, 0, 1000, 1000);  gtk_widget_show (canvas);  gtk_container_add (GTK_CONTAINER (scrolled_win), canvas);  root = goo_canvas_get_root_item (GOO_CANVAS (canvas));  /* Add a few simple items. */  rect_item = goo_canvas_rect_new (root, 100, 100, 400, 400,				   "line-width", 10.0,				   "radius-x", 20.0,				   "radius-y", 10.0,				   "stroke-color", "yellow",				   "fill-color", "red",				   NULL);  text_item = goo_canvas_text_new (root, "Hello World", 300, 300, -1,				   GOO_CANVAS_ANCHOR_CENTER,				   "font", "Sans 24",				   NULL);  goo_canvas_item_rotate (text_item, 45, 300, 300);  /* Connect a signal handler for the rectangle item. */  g_signal_connect (rect_item, "button_press_event",		    G_CALLBACK (on_rect_button_press), NULL);  /* Pass control to the GTK+ main event loop. */  gtk_main ();  return 0;}

voidsetup_canvas (GtkWidget *canvas){  GooCanvasItemModel *root;  root = goo_canvas_group_model_new (NULL, NULL);  goo_canvas_set_root_item_model (GOO_CANVAS (canvas), root);  g_print ("/nTable at default size.../n");  create_table1 (canvas, root, 50, 50, -1, -1, FALSE);  g_print ("/nTable at reduced size.../n");  create_table1 (canvas, root, 250, 50, 30, 30, FALSE);  g_print ("/nTable at enlarged size.../n");  create_table1 (canvas, root, 450, 50, 100, 100, FALSE);  g_print ("/nTable with grid lines at default size.../n");  create_table1 (canvas, root, 50, 250, -1, -1, TRUE);  g_print ("/nTable with grid lines at reduced size.../n");  create_table1 (canvas, root, 250, 250, 30, 30, TRUE);  g_print ("/nTable with grid lines at enlarged size.../n");  create_table1 (canvas, root, 450, 250, 150, 150, TRUE);  g_print ("Multispanning table with grid lines at default size.../n");  create_table2 (canvas, root, 50, 450, -1, -1, TRUE);  g_print ("Multispanning table with grid lines at reduced size.../n");  create_table2 (canvas, root, 250, 450, 30, 30, TRUE);  g_print ("Multispanning table with grid lines at enlarged size.../n");  create_table2 (canvas, root, 450, 450, 150, 150, TRUE);}

GtkWidget *create_focus_page (void){  GtkWidget *vbox, *label, *scrolled_win, *canvas;  vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 4);  gtk_container_set_border_width (GTK_CONTAINER (vbox), 4);  gtk_widget_show (vbox);  label = gtk_label_new ("Use Tab, Shift+Tab or the arrow keys to move the keyboard focus between the canvas items.");  gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);  gtk_widget_show (label);  scrolled_win = gtk_scrolled_window_new (NULL, NULL);  gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_win),				       GTK_SHADOW_IN);  gtk_widget_show (scrolled_win);  gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);  canvas = goo_canvas_new ();  gtk_widget_set_can_focus (canvas, TRUE);  gtk_widget_set_size_request (canvas, 600, 450);  goo_canvas_set_bounds (GOO_CANVAS (canvas), 0, 0, 1000, 1000);  gtk_widget_show (canvas);  gtk_container_add (GTK_CONTAINER (scrolled_win), canvas);  g_signal_connect (canvas, "item_created",		    G_CALLBACK (on_item_created), NULL);  setup_canvas (canvas);  return vbox;}

static voidsetup_canvas (GtkWidget *canvas){  GooCanvasItemModel *root;  root = goo_canvas_group_model_new (NULL, NULL);  goo_canvas_set_root_item_model (GOO_CANVAS (canvas), root);  g_object_unref (root);  create_focus_box (canvas, 110, 80, 50, 30, "red");  create_focus_box (canvas, 300, 160, 50, 30, "orange");  create_focus_box (canvas, 500, 50, 50, 30, "yellow");  create_focus_box (canvas, 70, 400, 50, 30, "blue");  create_focus_box (canvas, 130, 200, 50, 30, "magenta");  create_focus_box (canvas, 200, 160, 50, 30, "green");  create_focus_box (canvas, 450, 450, 50, 30, "cyan");  create_focus_box (canvas, 300, 350, 50, 30, "grey");  create_focus_box (canvas, 900, 900, 50, 30, "gold");  create_focus_box (canvas, 800, 150, 50, 30, "thistle");  create_focus_box (canvas, 600, 800, 50, 30, "azure");  create_focus_box (canvas, 700, 250, 50, 30, "moccasin");  create_focus_box (canvas, 500, 100, 50, 30, "cornsilk");  create_focus_box (canvas, 200, 750, 50, 30, "plum");  create_focus_box (canvas, 400, 800, 50, 30, "orchid");}

static scrollvalue boundedScroll(canvas_goocanvas *gcanvas, scrollvalue d){  /* get size of visible area in canvas units (meters) */  canvas_dimensions dim = gcanvas->get_viewport_dimensions() / 2;  // Data rect minimum and maximum  // limit stops - prevent scrolling beyond these  gdouble min_sy_cu = 0.95 * (gcanvas->bounds.min.y - dim.height);  gdouble min_sx_cu = 0.95 * (gcanvas->bounds.min.x - dim.width);  gdouble max_sy_cu = 0.95 * (gcanvas->bounds.max.y + dim.height);  gdouble max_sx_cu = 0.95 * (gcanvas->bounds.max.x + dim.width);  scrollvalue ret(std::min(std::max(d.x, min_sx_cu), max_sx_cu),                  std::min(std::max(d.y, min_sy_cu), max_sy_cu));  /* adjust to screen center */  GooCanvas *gc = GOO_CANVAS(gcanvas->widget);  gdouble zoom = goo_canvas_get_scale(gc);  gdouble offx = gcanvas->widget->allocation.width / (2 * zoom);  gdouble offy = gcanvas->widget->allocation.height / (2 * zoom);  goo_canvas_scroll_to(gc, ret.x - offx, ret.y - offy);  return ret;}

double canvas_t::set_zoom(double zoom) {  /* Limit a proposed zoom factor to sane ranges.   * Specifically the map is allowed to be no smaller than the viewport. */  canvas_goocanvas *gcanvas = static_cast<canvas_goocanvas *>(this);  /* get size of visible area in pixels and convert to meters of intended */  /* zoom by dividing by zoom (which is basically pix/m) */  const GtkAllocation &dim = widget->allocation;  double limit;  int delta;  if (dim.height < dim.width) {    limit = dim.height;    delta = gcanvas->bounds.max.y - gcanvas->bounds.min.y;  } else {    limit = dim.width;    delta = gcanvas->bounds.max.x - gcanvas->bounds.min.x;  }  limit *= 0.95 / zoom;  if (delta < limit) {    zoom /= (delta / limit);    printf("Can't zoom further out (%f)/n", zoom);  }  goo_canvas_set_scale(GOO_CANVAS(widget), zoom);  return zoom;}

static voidcreate_focus_box (GtkWidget     *canvas,		  gdouble        x,		  gdouble        y,		  gdouble        width,		  gdouble        height,		  gchar         *color){  GooCanvasItem *root, *item;  root = goo_canvas_get_root_item (GOO_CANVAS (canvas));  item = goo_canvas_rect_new (root, x, y, width, height,			      "stroke-pattern", NULL,			      "fill-color", color,			      "line-width", 5.0,			      "can-focus", TRUE,			      NULL);  g_object_set_data (G_OBJECT (item), "id", color);  g_signal_connect (item, "focus_in_event",		    G_CALLBACK (on_focus_in), NULL);  g_signal_connect (item, "focus_out_event",		    G_CALLBACK (on_focus_out), NULL);  g_signal_connect (item, "button_press_event",		    G_CALLBACK (on_button_press), NULL);  g_signal_connect (item, "key_press_event",		    G_CALLBACK (on_key_press), NULL);}

static AtkObject*goo_canvas_accessible_ref_child (AtkObject *object,				 gint       child_num){  GtkAccessible *accessible;  GtkWidget *widget;  GooCanvasItem *root;  AtkObject *atk_object;  /* Canvas only has one child, so return NULL if index is non zero */  if (child_num != 0)    return NULL;  accessible = GTK_ACCESSIBLE (object);  widget = accessible->widget;  /* Check if widget still exists. */  if (widget == NULL)    return NULL;  root = goo_canvas_get_root_item (GOO_CANVAS (widget));  if (!root)    return NULL;  atk_object = atk_gobject_accessible_for_object (G_OBJECT (root));  g_object_ref (atk_object);  return atk_object;}

/** * get the pointer position in goocanvas coordinates * * @attention shall not be called in event callbacks, * except for GDK_MOTION_... where it is useless since * the event itself contains the cursor position */gboolean sheet_get_pointer (Sheet *sheet, gdouble *x, gdouble *y){	if (!sheet_get_pointer_pixel (sheet, x, y))		return FALSE;	goo_canvas_convert_from_pixels (GOO_CANVAS (sheet), x, y);	return TRUE;}

static voidnode_dot_added_callback (Schematic *schematic, Coords *pos, Sheet *sheet){	NodeItem *node_item;	Coords *key;	g_return_if_fail (sheet != NULL);	g_return_if_fail (IS_SHEET (sheet));	node_item = g_hash_table_lookup (sheet->priv->node_dots, pos);	if (node_item == NULL) {		node_item = NODE_ITEM (g_object_new (TYPE_NODE_ITEM, NULL));			g_object_set (node_item,		              "parent", goo_canvas_get_root_item (GOO_CANVAS (sheet)),		              "x", pos->x,		              "y", pos->y,		              NULL);	}	node_item_show_dot (node_item, TRUE);	key = g_new0 (Coords, 1);	key->x = pos->x;	key->y = pos->y;	g_hash_table_insert (sheet->priv->node_dots, key, node_item);}

static DrawCanvasItem *draw_canvas_get_item_at (DrawCanvas *canvas,                         gdouble     x,                         gdouble     y,                         gboolean    is_pointer_event){   GooCanvasItem *item;   g_return_val_if_fail(DRAW_IS_CANVAS(canvas), NULL);   /*    * Fetch the item underneath the pointer. If the item is not a    * DrawCanvasItem or the item is part of a selection group, work our way    * up until we find that top-most grabbable item.    */   item = goo_canvas_get_item_at(GOO_CANVAS(canvas), x, y, is_pointer_event);   for (; item; item = goo_canvas_item_get_parent(item)) {      /*       * TODO: Check if part of a selection/group.       */      if (DRAW_IS_CANVAS_ITEM(item)) {         return DRAW_CANVAS_ITEM(item);      }   }   return NULL;}

voidinit_display(){	int	i;	pcb.scale = 1.0;	for (i = 0; i < pcb.layers; i++) {		pcb.layer[i].canvas = GOO_CANVAS(goo_canvas_new());		gtk_object_ref(GTK_OBJECT(pcb.layer[i].canvas));		goo_canvas_set_bounds(pcb.layer[i].canvas,		    0, 0, pcb.width, pcb.height);		pcb.layer[i].root =		    goo_canvas_get_root_item(pcb.layer[i].canvas);		goo_canvas_image_new(pcb.layer[i].root, pcb.layer[i].img, 0, 0,		    NULL);		init_layer_events(pcb.layer[i].root);		show_overlays(i);	}	pcb.window = gtk_window_new(GTK_WINDOW_TOPLEVEL);	gtk_window_set_default_size(GTK_WINDOW(pcb.window), 800, 600);	gtk_window_set_title(GTK_WINDOW(pcb.window), pcb.filename);	init_window_events(pcb.window);	pcb.scrolled = gtk_scrolled_window_new(NULL, NULL);	gtk_widget_show(pcb.scrolled);	gtk_container_add(GTK_CONTAINER(pcb.window), pcb.scrolled);	redisplay();}

static voidcreate_canvas (GtkTable *table, gint row, gchar *text, gchar *id){  GtkWidget *label, *canvas;  GooCanvasItemModel *root, *rect;  char *view_id;  label = gtk_label_new (text);  gtk_table_attach (table, label, 0, 1, row, row + 1,		    0, 0, 0, 0);  gtk_widget_show (label);  canvas = goo_canvas_new ();  g_signal_connect (canvas, "item_created",		    G_CALLBACK (on_item_created), NULL);  gtk_widget_set_size_request (canvas, 200, 100);  goo_canvas_set_bounds (GOO_CANVAS (canvas), 0, 0, 200, 100);  gtk_table_attach (table, canvas, 1, 2, row, row + 1, 0, 0, 0, 0);  gtk_widget_show (canvas);  root = goo_canvas_group_model_new (NULL, NULL);  goo_canvas_set_root_item_model (GOO_CANVAS (canvas), root);  g_object_unref (root);  rect = goo_canvas_rect_model_new (root, 0, 0, 200, 100,				    "stroke-pattern", NULL,				    "fill-color", "yellow",				    NULL);  view_id = g_strdup_printf ("%s-yellow", id);  g_object_set_data_full (G_OBJECT (rect), "id", view_id, g_free);  rect = goo_canvas_rect_model_new (root, 20, 20, 60, 60,				    "stroke-pattern", NULL,				    "fill-color", "blue",				    NULL);  view_id = g_strdup_printf ("%s-blue", id);  g_object_set_data_full (G_OBJECT (rect), "id", view_id, g_free);  rect = goo_canvas_rect_model_new (root, 120, 20, 60, 60,				    "stroke-pattern", NULL,				    "fill-color", "red",				    NULL);  view_id = g_strdup_printf ("%s-red", id);  g_object_set_data_full (G_OBJECT (rect), "id", view_id, g_free);}

static GtkWidget*create_window (GooCanvasItemModel *model){  GtkWidget *window, *vbox, *label, *scrolled_win, *canvas;  /* Create the window and widgets. */  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);  gtk_window_set_default_size (GTK_WINDOW (window), 640, 600);  gtk_widget_show (window);  g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);  vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 4);  g_object_set (vbox, "margin", 4, NULL);  gtk_widget_show (vbox);  gtk_container_add (GTK_CONTAINER (window), vbox);  label = gtk_label_new ("Use Ctrl+Left Click to move items or Ctrl+Right Click to resize items");  g_object_set (label, "halign", GTK_ALIGN_START, NULL);  gtk_box_pack_start (GTK_BOX (vbox), label);  gtk_widget_show (label);  /* Create top canvas. */  scrolled_win = gtk_scrolled_window_new (NULL, NULL);  gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_win),                                       GTK_SHADOW_IN);  gtk_widget_show (scrolled_win);  gtk_box_pack_start (GTK_BOX (vbox), scrolled_win);  gtk_widget_set_halign (scrolled_win, GTK_ALIGN_FILL);  gtk_widget_set_valign (scrolled_win, GTK_ALIGN_FILL);  gtk_widget_set_hexpand (scrolled_win, TRUE);  gtk_widget_set_vexpand (scrolled_win, TRUE);  canvas = goo_canvas_new ();  g_object_set (G_OBJECT (canvas), "integer-layout", TRUE, NULL);/*  gtk_widget_set_size_request (canvas, 600, 250);*/  goo_canvas_set_bounds (GOO_CANVAS (canvas), 0, 0, 1000, 1000);  gtk_widget_show (canvas);  gtk_container_add (GTK_CONTAINER (scrolled_win), canvas);  g_signal_connect (canvas, "item_created",		    G_CALLBACK (on_item_created), NULL);  goo_canvas_set_root_item_model (GOO_CANVAS (canvas), model);  return window;}

/** /brief Delete the ground track for a satellite. *  /param satmap The satellite map widget. *  /param sat Pointer to the satellite object. *  /param qth Pointer to the QTH data. *  /param obj the satellite object. *  /param clear_ssp Flag indicating whether SSP data should be cleared as well (TRUE=yes); * */voidground_track_delete (GtkSatMap *satmap, sat_t *sat, qth_t *qth, sat_map_obj_t *obj, gboolean clear_ssp){     guint              i,n;     gint               j;     GooCanvasItemModel *line;     GooCanvasItemModel *root;    (void) qth; /* avoid unusued parameter compiler warning */    sat_log_log (SAT_LOG_LEVEL_DEBUG,                     _("%s: Deleting ground track for %s"),                 __FUNCTION__, sat->nickname);     root = goo_canvas_get_root_item_model (GOO_CANVAS (satmap->canvas));     /* remove plylines */     if (obj->track_data.lines != NULL) {          n = g_slist_length (obj->track_data.lines);          for (i = 0; i < n; i++) {               /* get line */               line = GOO_CANVAS_ITEM_MODEL (g_slist_nth_data (obj->track_data.lines, i));               /* find its ID and remove it */               j = goo_canvas_item_model_find_child (root, line);               if (j == -1) {                    sat_log_log (SAT_LOG_LEVEL_ERROR,                                    _("%s: Could not find part %d of ground track"),                                    __FUNCTION__, j);               }               else {                    goo_canvas_item_model_remove_child (root, j);               }          }          g_slist_free (obj->track_data.lines);          obj->track_data.lines = NULL;                    }     /* clear SSP too? */     if (clear_ssp == TRUE) {          if (obj->track_data.latlon != NULL) {               /* free allocated ssp_t */               g_slist_foreach (obj->track_data.latlon, free_ssp, NULL);               /* free the SList itself */               g_slist_free (obj->track_data.latlon);               obj->track_data.latlon = NULL;          }          obj->track_orbit = 0;     }}

static voidcreate_canvas (GtkGrid *grid, gint row, gchar *text, gchar *id){  GtkWidget *label, *canvas;  GooCanvasItem *root, *rect;  char *view_id;  label = gtk_label_new (text);  gtk_grid_attach (grid, label, 0, row, 1, 1);  gtk_widget_show (label);  canvas = goo_canvas_new ();  gtk_widget_set_size_request (canvas, 200, 100);  goo_canvas_set_bounds (GOO_CANVAS (canvas), 0, 0, 200, 100);  gtk_grid_attach (grid, canvas, 1, row, 1, 1);  gtk_widget_show (canvas);  root = goo_canvas_get_root_item (GOO_CANVAS (canvas));  rect = goo_canvas_rect_new (root, 0, 0, 200, 100,			      "stroke-pattern", NULL,			      "fill-color", "yellow",			      NULL);  view_id = g_strdup_printf ("%s-yellow", id);  g_object_set_data_full (G_OBJECT (rect), "id", view_id, g_free);  setup_item_signals (rect);  rect = goo_canvas_rect_new (root, 20, 20, 60, 60,			      "stroke-pattern", NULL,			      "fill-color", "blue",			      NULL);  view_id = g_strdup_printf ("%s-blue", id);  g_object_set_data_full (G_OBJECT (rect), "id", view_id, g_free);  setup_item_signals (rect);  rect = goo_canvas_rect_new (root, 120, 20, 60, 60,			      "stroke-pattern", NULL,			      "fill-color", "red",			      NULL);  view_id = g_strdup_printf ("%s-red", id);  g_object_set_data_full (G_OBJECT (rect), "id", view_id, g_free);  setup_item_signals (rect);}

gbooleanrubberband_update (Sheet *sheet, GdkEvent *event){	GList *iter;	Coords cur, cmin, cmax;	double dx, dy; // TODO maybe keep track of subpixel changes, make em global/part of the rubberband_info struct and reset on finish	double width, height,	       width_ng, height_ng;	RubberbandInfo *rubberband_info;	rubberband_info = sheet->priv->rubberband_info;	g_assert (event->type == GDK_MOTION_NOTIFY);	cur.x = event->motion.x;	cur.y = event->motion.y;	goo_canvas_convert_from_pixels (GOO_CANVAS (sheet), &cur.x, &cur.y);	width  = fabs(rubberband_info->end.x - rubberband_info->start.x);	height = fabs(rubberband_info->end.y - rubberband_info->start.y);	width_ng  = fabs(cur.x - rubberband_info->start.x);	height_ng = fabs(cur.y - rubberband_info->start.y);	dx = fabs (width_ng - width);	dy = fabs (height_ng - height);	NG_DEBUG ("motion :: dx=%lf, dy=%lf :: x=%lf, y=%lf :: w_ng=%lf, h_ng=%lf", dx, dy, cur.x, cur.y, width_ng, height_ng);	// TODO FIXME scroll window if needed (use http://developer.gnome.org/goocanvas/stable/GooCanvas.html#goo-canvas-scroll-to)	if (dx > 0.1 || dy > 0.1) { //a 0.1 change in pixel coords would be the least visible, silently ignore everything else		rubberband_info->end.x = cur.x;		rubberband_info->end.y = cur.y;		cmin.x = MIN(rubberband_info->start.x, rubberband_info->end.x);		cmin.y = MIN(rubberband_info->start.y, rubberband_info->end.y);		cmax.x = cmin.x + width_ng;		cmax.y = cmin.y + height_ng;#if 1		for (iter = sheet->priv->items; iter; iter = iter->next) {			sheet_item_select_in_area (iter->data,			                           &cmin,			                           &cmax);		}#endif		g_object_set (GOO_CANVAS_ITEM (rubberband_info->rectangle),		              "x", cmin.x,		              "y", cmin.y,		              "width", width_ng, 		              "height", height_ng,		              "visibility", GOO_CANVAS_ITEM_VISIBLE,		              NULL);		goo_canvas_item_raise (GOO_CANVAS_ITEM (rubberband_info->rectangle), NULL);	}	return TRUE;}

void sheet_keyboard_ungrab (Sheet *sheet, GdkEvent *event){	g_return_if_fail (sheet);	g_return_if_fail (IS_SHEET (sheet));#ifndef DEBUG_DISABLE_GRABBING	if (sheet->priv->keyboard_grabbed) {		sheet->priv->keyboard_grabbed = FALSE;		goo_canvas_keyboard_ungrab (GOO_CANVAS (sheet), GOO_CANVAS_ITEM (sheet->grid),		                            extract_time (event));	}#endif}

void sheet_setup_rubberband (Sheet *sheet, GdkEventButton *event){	double x, y;	cairo_pattern_t *pattern;	static guchar stipple_data[16] = 	{0, 0, 0, 255,  0, 0, 0, 0,  0, 0, 0, 0,  0, 0, 0, 255 };	x = event->x; //the x coordinate of the pointer relative to the window.	y = event->y; //the y coordinate of the pointer relative to the window.	goo_canvas_convert_from_pixels (GOO_CANVAS (sheet), &x, &y);	sheet->priv->rubberband->start_x = x;	sheet->priv->rubberband->start_y = y;	sheet->priv->rubberband->state = RUBBER_YES;	sheet->priv->rubberband->click_start_state = event->state;	pattern = create_stipple ("lightgrey", stipple_data);	sheet->priv->rubberband->rectangle = goo_canvas_rect_new (		GOO_CANVAS_ITEM (sheet->object_group), 	    x, y, 0.0, 0.0, 	    "stroke-color", "black",	    "line-width", 0.2,	    "fill-pattern", pattern,	    NULL);	goo_canvas_pointer_grab (GOO_CANVAS (sheet), GOO_CANVAS_ITEM (sheet->grid), 		(GDK_POINTER_MOTION_MASK | GDK_BUTTON_RELEASE_MASK),	    NULL, event->time);		// Mark all the selected objects to preserve their selected state	// if SHIFT is pressed while rubberbanding.	if (event->state & GDK_SHIFT_MASK) {		sheet->priv->preserve_selection_items = 			g_list_copy (sheet_preserve_selection (sheet));	}}

void		sheet_get_pointer (Sheet *sheet, gdouble *x, gdouble *y){	GtkWidget        *widget;	GtkAdjustment    *hadjustment;	GtkAdjustment    *vadjustment;	gdouble           value, x1, y1;	gint              _x, _y;	GdkDeviceManager *device_manager;    GdkDevice        *device_pointer;    GdkRectangle      allocation;	// gtk_widget_get_pointer (GTK_WIDGET (sheet), &_x, &_y);	// replaced by a code copied from evince	    if (!gtk_widget_get_realized (GTK_WIDGET (sheet)))    	return;		device_manager = gdk_display_get_device_manager (	                gtk_widget_get_display (GTK_WIDGET (sheet)));    device_pointer = gdk_device_manager_get_client_pointer (device_manager);    gdk_window_get_device_position (gtk_widget_get_window (GTK_WIDGET (sheet)),                    device_pointer,                    &_x, &_y, NULL);	if (!gtk_widget_get_has_window (GTK_WIDGET (sheet)))    	return;		gtk_widget_get_allocation (GTK_WIDGET (sheet), &allocation);		_x -= allocation.x;	_y -= allocation.y;	x1 = (gdouble) _x;	y1 = (gdouble) _y;		widget = gtk_widget_get_parent (GTK_WIDGET (sheet));	hadjustment =  gtk_scrolled_window_get_hadjustment (	                 GTK_SCROLLED_WINDOW (widget));	value = gtk_adjustment_get_value (hadjustment);	x1 += value;	vadjustment =  gtk_scrolled_window_get_vadjustment (	                 GTK_SCROLLED_WINDOW (widget));	value = gtk_adjustment_get_value (vadjustment);	y1 += value;	*x = x1;	*y = y1;	goo_canvas_convert_from_pixels (GOO_CANVAS (sheet), x, y);	snap_to_grid (sheet->grid, x, y);}

/* get scroll position in meters */void canvas_t::scroll_get(int &sx, int &sy) const {  GooCanvas *gc = GOO_CANVAS(widget);  gdouble zoom = goo_canvas_get_scale(gc);  gdouble hs = gtk_adjustment_get_value(gc->hadjustment);  gdouble vs = gtk_adjustment_get_value(gc->vadjustment);  goo_canvas_convert_from_pixels(gc, &hs, &vs);  /* convert to position relative to screen center */  hs += widget->allocation.width/(2*zoom);  vs += widget->allocation.height/(2*zoom);  sx = hs;  sy = vs;}

static GooCanvasItemModel *        create_time_tick (GtkPolarView *pv, gdouble time, gfloat x, gfloat y){    GooCanvasItemModel *item;    time_t             t;    gchar              buff[7];    GtkAnchorType      anchor;    GooCanvasItemModel *root;    guint32            col;    root = goo_canvas_get_root_item_model (GOO_CANVAS (pv->canvas));    col = mod_cfg_get_int (pv->cfgdata,                           MOD_CFG_POLAR_SECTION,                           MOD_CFG_POLAR_TRACK_COL,                           SAT_CFG_INT_POLAR_TRACK_COL);    /* convert julian date to struct tm */    t = (time - 2440587.5)*86400.;    /* format either local time or UTC depending on check box */    if (sat_cfg_get_bool (SAT_CFG_BOOL_USE_LOCAL_TIME))        strftime (buff, 8, "%H:%M", localtime (&t));    else        strftime (buff, 8, "%H:%M", gmtime (&t));    buff[6]='/0';    if (x > pv->cx) {        anchor = GTK_ANCHOR_EAST;        x -= 5;    }    else {        anchor = GTK_ANCHOR_WEST;        x += 5;    }    item = goo_canvas_text_model_new (root, buff,                                      (gdouble) x, (gdouble) y,                                      -1, anchor,                                      "font", "Sans 7",                                      "fill-color-rgba", col,                                      NULL);    goo_canvas_item_model_lower (item, NULL);    return item;}

gboolean sheet_keyboard_grab (Sheet *sheet, GdkEvent *event){	g_return_val_if_fail (sheet, FALSE);	g_return_val_if_fail (IS_SHEET (sheet), FALSE);#ifndef DEBUG_DISABLE_GRABBING	if (sheet->priv->keyboard_grabbed == FALSE &&	    goo_canvas_keyboard_grab (GOO_CANVAS (sheet), GOO_CANVAS_ITEM (sheet->grid),	                              TRUE, /*do not reroute signals through sheet->grid*/	                              extract_time (event)) == GDK_GRAB_SUCCESS) {		sheet->priv->keyboard_grabbed = TRUE;	}	return (sheet->priv->keyboard_grabbed == TRUE);#else	return TRUE;#endif}

gboolean sheet_pointer_grab (Sheet *sheet, GdkEvent *event){	g_return_val_if_fail (sheet, FALSE);	g_return_val_if_fail (IS_SHEET (sheet), FALSE);#ifndef DEBUG_DISABLE_GRABBING	if (sheet->priv->pointer_grabbed == 0 &&	    goo_canvas_pointer_grab (GOO_CANVAS (sheet), GOO_CANVAS_ITEM (sheet->grid),	                             GDK_POINTER_MOTION_MASK | GDK_BUTTON_PRESS_MASK |	                                 GDK_BUTTON_RELEASE_MASK,	                             NULL, extract_time (event)) == GDK_GRAB_SUCCESS) {		sheet->priv->pointer_grabbed = 1;	}	return (sheet->priv->pointer_grabbed == 1);#else	return TRUE;#endif}

GtkWidget *create_events_page (void){  GtkWidget *vbox, *frame, *label, *canvas;  vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 4);  g_object_set (vbox, "margin", 4, NULL);  gtk_widget_show (vbox);  /* Instructions */  label = gtk_label_new ("Move the mouse over the items to check they receive the right motion events./nThe first 2 items in each group are 1) invisible and 2) visible but unpainted.");  gtk_box_pack_start (GTK_BOX (vbox), label);  gtk_widget_show (label);  /* Frame and canvas */  frame = gtk_frame_new (NULL);  gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);  gtk_box_pack_start (GTK_BOX (vbox), frame);  gtk_widget_show (frame);  g_object_set (frame,		"halign", GTK_ALIGN_CENTER,		"valign", GTK_ALIGN_CENTER,		NULL);  canvas = goo_canvas_new ();  gtk_widget_set_size_request (canvas, 600, 450);  goo_canvas_set_bounds (GOO_CANVAS (canvas), 0, 0, 600, 450);  gtk_container_add (GTK_CONTAINER (frame), canvas);  gtk_widget_show (canvas);  create_events_area (canvas, 0, GOO_CANVAS_EVENTS_NONE, "none");  create_events_area (canvas, 1, GOO_CANVAS_EVENTS_VISIBLE_PAINTED, "visible-painted");  create_events_area (canvas, 2, GOO_CANVAS_EVENTS_VISIBLE_FILL, "visible-fill");  create_events_area (canvas, 3, GOO_CANVAS_EVENTS_VISIBLE_STROKE, "visible-stroke");  create_events_area (canvas, 4, GOO_CANVAS_EVENTS_VISIBLE, "visible");  create_events_area (canvas, 5, GOO_CANVAS_EVENTS_PAINTED, "painted");  create_events_area (canvas, 6, GOO_CANVAS_EVENTS_FILL, "fill");  create_events_area (canvas, 7, GOO_CANVAS_EVENTS_STROKE, "stroke");  create_events_area (canvas, 8, GOO_CANVAS_EVENTS_ALL, "all");  return vbox;}