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

//FIXME this looks weirdvoidsheet_release_selected_objects (Sheet *sheet){	GList *list, *copy;	GooCanvasGroup *group;	gint   item_nbr;		g_return_if_fail (sheet != NULL);	g_return_if_fail (IS_SHEET (sheet));	group = sheet->priv->selected_group;	copy = g_list_copy (sheet->priv->selected_objects);		// Remove all the selected_objects into selected_group	for (list = copy; list; list = list->next) {		item_nbr = goo_canvas_item_find_child (GOO_CANVAS_ITEM (group),		                                      GOO_CANVAS_ITEM (list->data));		goo_canvas_item_remove_child (GOO_CANVAS_ITEM (group),		                              item_nbr);	}	g_list_free (copy);			g_list_free (sheet->priv->selected_objects);	sheet->priv->selected_objects = NULL;}

// Cancel the placement of floating items and remove them.void sheet_item_cancel_floating (Sheet *sheet){	GooCanvasGroup *group;	GList *list;	g_return_if_fail (sheet != NULL);	g_return_if_fail (IS_SHEET (sheet));	group = GOO_CANVAS_GROUP (sheet->priv->floating_group);	if (group == NULL)		return;	if (sheet->state != SHEET_STATE_FLOAT && sheet->state != SHEET_STATE_FLOAT_START)		return;	if (g_signal_handler_is_connected (sheet, sheet->priv->float_handler_id))		g_signal_handler_disconnect (sheet, sheet->priv->float_handler_id);	// TODO verfiy that the following has no nasty sideffects	for (list = sheet->priv->floating_objects; list; list = list->next) {		goo_canvas_item_remove (list->data); // remove from canvas and free	}	g_list_free (sheet->priv->floating_objects);	sheet->priv->floating_objects = NULL;	goo_canvas_item_remove (GOO_CANVAS_ITEM (group));	// Create a new empty group to prepare next floating group	sheet->priv->floating_group = GOO_CANVAS_GROUP (	    goo_canvas_group_new (GOO_CANVAS_ITEM (sheet->object_group), "x", 0.0, "y", 0.0, NULL));	// sheet_clear_ghosts (sheet);	sheet->priv->float_handler_id = 0;	sheet->state = SHEET_STATE_NONE;}

static voidmake_dynamic_link (GstEditorLink * link){  GstElement *srce, *sinke;  GstPadTemplate *src = NULL, *sink = NULL;  if (GST_IS_EDITOR_PAD_SOMETIMES (link->srcpad))    src = GST_PAD_TEMPLATE (link->srcpad->object);  if (GST_IS_EDITOR_PAD_SOMETIMES (link->sinkpad))    sink = GST_PAD_TEMPLATE (link->sinkpad->object);  srce =      GST_ELEMENT (GST_EDITOR_ITEM (goo_canvas_item_get_parent (GOO_CANVAS_ITEM              (link->srcpad)))->object);  sinke =      GST_ELEMENT (GST_EDITOR_ITEM (goo_canvas_item_get_parent (GOO_CANVAS_ITEM              (link->sinkpad)))->object);  g_return_if_fail (src || sink);  if (src)    g_signal_connect_after (srce, "pad-added", G_CALLBACK (on_new_pad), link);  if (sink)    g_signal_connect_after (sinke, "pad-added", G_CALLBACK (on_new_pad), link);  g_print ("dynamic link/n");}

static voidgst_editor_link_resize (GstEditorLink * link){  gdouble x1, y1, x2, y2;  GooCanvas * canvas;  g_object_get (link, "x1", &x1, "y1", &y1, "x2", &x2, "y2", &y2, NULL);  canvas = goo_canvas_item_get_canvas (GOO_CANVAS_ITEM (link));  if (!canvas) {    g_print ("Warning: gst_editor_link_resize canvas null/n");    return;  }  goo_canvas_convert_from_pixels (canvas, &x1, &y1);  goo_canvas_convert_to_item_space (canvas, GOO_CANVAS_ITEM (link), &x1, &y1);  // goo_canvas_item_get_parent(GOO_CANVAS_ITEM (link)),&x1, &y1);  goo_canvas_convert_from_pixels (canvas, &x2, &y2);  goo_canvas_convert_to_item_space (canvas, GOO_CANVAS_ITEM (link), &x2, &y2);  // goo_canvas_item_get_parent(GOO_CANVAS_ITEM (link)), &x2, &y2);  /* we do this in reverse so that with dot-dash lines it gives the illusion of     pulling out a rope from the element */  link->points->coords[2] = x1;  link->points->coords[3] = y1;  link->points->coords[0] = x2;  link->points->coords[1] = y2;  g_object_set (G_OBJECT (link), "points", link->points, NULL);}

PartItem *part_item_canvas_new (Sheet *sheet, Part *part){	PartItem *part_item;	PartItemPriv *priv;	GooCanvasItem *item;	ItemData *item_data;	g_return_val_if_fail (sheet != NULL, NULL);	g_return_val_if_fail (IS_SHEET (sheet), NULL);	g_return_val_if_fail (part != NULL, NULL);	g_return_val_if_fail (IS_PART (part), NULL);	item = g_object_new (TYPE_PART_ITEM, NULL);		g_object_set (item, 	              "parent", sheet->object_group, 	              NULL);		part_item = PART_ITEM (item);	g_object_set (part_item,                   "data", part,                   NULL);	priv = part_item->priv;		priv->label_group = GOO_CANVAS_ITEM (goo_canvas_group_new (	        GOO_CANVAS_ITEM (part_item),	        "width", -1.0,	        "height", -1.0,	        NULL));	g_object_unref (item);		priv->node_group = GOO_CANVAS_ITEM (goo_canvas_group_new (	        GOO_CANVAS_ITEM (part_item), 	        NULL));	g_object_set (GOO_CANVAS_ITEM (priv->node_group),	              "visibility", GOO_CANVAS_ITEM_INVISIBLE, 	              NULL);	item_data = ITEM_DATA (part);	item_data->rotated_handler_id = g_signal_connect_object (G_OBJECT (part), 	                                "rotated",	                                G_CALLBACK (part_rotated_callback),	                                G_OBJECT (part_item), 0);	item_data->flipped_handler_id = g_signal_connect_object (G_OBJECT (part), 	                                "flipped",	                                G_CALLBACK (part_flipped_callback),	                                G_OBJECT (part_item), 0);	item_data->moved_handler_id = g_signal_connect_object (G_OBJECT (part),	                                "moved",	                                G_CALLBACK (part_moved_callback),	                                G_OBJECT (part_item), 0);	item_data->changed_handler_id = g_signal_connect_object (G_OBJECT (part),	                                "changed",	                                G_CALLBACK (part_changed_callback),	                                G_OBJECT (part_item), 0);	return part_item;}

voidgst_editor_link_destroy (GstEditorLink * link){  // g_print ("trying to destroy this half link");  GstEditorBin * padbin;  if (link->srcpad)    padbin = GST_EDITOR_BIN (goo_canvas_item_get_parent (        goo_canvas_item_get_parent (GOO_CANVAS_ITEM (link->srcpad))));  else    padbin = GST_EDITOR_BIN (goo_canvas_item_get_parent (        goo_canvas_item_get_parent (GOO_CANVAS_ITEM (link->sinkpad))));  padbin->links = g_list_remove (padbin->links, link);  if (link->srcpad)    GST_EDITOR_PAD (link->srcpad)->link = NULL;  if (link->sinkpad)    GST_EDITOR_PAD (link->sinkpad)->link = NULL;  // int killnumber;  // killnumber=goo_canvas_item_find_child(goo_canvas_item_get_parent(GOO_CANVAS_ITEM(link)),GOO_CANVAS_ITEM(link));  // g_print ("found child at %d",killnumber);  // ARGH, what am I doing here  // g_realloc(link,sizeof(GooCanvasPolyline));  // g_realloc(link,sizeof(GooCanvasPolyline));  // goo_canvas_item_remove_child(goo_canvas_item_get_parent(GOO_CANVAS_ITEM(link)),killnumber);  goo_canvas_item_remove (GOO_CANVAS_ITEM (link));  if (link->points)    goo_canvas_points_unref (link->points);  // g_print ("ready to crash:)");  // g_free(link);  // g_print ("no warnings until now");  return;}

static voidwire_changed_callback (Wire *wire, WireItem *item){	Coords start_pos, length;	GooCanvasPoints *points;	g_return_if_fail (wire != NULL);	g_return_if_fail (IS_ITEM_DATA (wire));	g_return_if_fail (item != NULL);	g_return_if_fail (IS_WIRE_ITEM (item));	wire_get_pos_and_length (wire, &start_pos, &length);	Sheet *sheet = SHEET (goo_canvas_item_get_canvas (GOO_CANVAS_ITEM (item)));	if (G_UNLIKELY(!sheet)) {		g_warning ("Failed to determine the Sheet the item is glued to. This should never happen. Ever!");	} else {		item_data_snap (ITEM_DATA (wire), sheet->grid);	}	// Move the canvas item and invalidate the bbox cache.	goo_canvas_item_set_simple_transform (GOO_CANVAS_ITEM (item),	                                      start_pos.x,	                                      start_pos.y,	                                      1.0,	                                      0.0);	item->priv->cache_valid = FALSE;	points = goo_canvas_points_new (2);	points->coords[0] = 0;	points->coords[1] = 0;	points->coords[2] = length.x;	points->coords[3] = length.y;	// this does handle cleanup of previous points internally	g_object_set (item->priv->line,	              "points", points,	              NULL);	goo_canvas_points_unref (points);	g_object_set (item->priv->resize1,	              "x", -RESIZER_SIZE,	              "y", -RESIZER_SIZE,	              "width", 2 * RESIZER_SIZE,	              "height", 2 * RESIZER_SIZE,	              NULL);	g_object_set (item->priv->resize2,	              "x", length.x-RESIZER_SIZE,	              "y", length.y-RESIZER_SIZE,	              "width", 2 * RESIZER_SIZE,	              "height", 2 * RESIZER_SIZE,	              NULL);	goo_canvas_item_request_update (GOO_CANVAS_ITEM (item->priv->line));}

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

// Reparent a sheet object without moving it on the sheet.void sheet_item_reparent (SheetItem *item, GooCanvasGroup *group){	g_return_if_fail (item != NULL);	g_return_if_fail (IS_SHEET_ITEM (item));	g_return_if_fail (group != NULL);	g_object_ref (item);	goo_canvas_item_remove (GOO_CANVAS_ITEM (item));	goo_canvas_item_add_child (GOO_CANVAS_ITEM (group), GOO_CANVAS_ITEM (item), -1);	// FIXME are we leaking a ref here?}

static void node_item_init (NodeItem *item){	item->priv = g_new0 (NodeItemPriv, 1);	item->priv->dot_item =	    goo_canvas_ellipse_new (GOO_CANVAS_ITEM (item), 0.0, 0.0, 2.0, 2.0, "fill-color", "black",	                            "visibility", GOO_CANVAS_ITEM_INVISIBLE, NULL);	item->priv->circle_item = goo_canvas_ellipse_new (	    GOO_CANVAS_ITEM (item), 0.0, 0.0, 3.0, 3.0, "stroke-color-rgba", 0x3399FFFF, "line-width",	    1.0, "visibility",	    oregano_options_debug_dots () ? GOO_CANVAS_ITEM_VISIBLE : GOO_CANVAS_ITEM_INVISIBLE, NULL);}

static AtkObject*goo_canvas_item_accessible_ref_child (AtkObject *accessible,				      gint       child_num){  GooCanvasItem *item, *child;  AtkObject *atk_object;  GObject *object;  g_return_val_if_fail (GOO_IS_CANVAS_ITEM_ACCESSIBLE (accessible), NULL);  object = atk_gobject_accessible_get_object (ATK_GOBJECT_ACCESSIBLE (accessible));  if (object == NULL)    return NULL;  item = GOO_CANVAS_ITEM (object);  child = goo_canvas_item_get_child (item, child_num);  if (!child)    return NULL;  atk_object = atk_gobject_accessible_for_object (G_OBJECT (child));  g_object_ref (atk_object);  return atk_object;}

static voidwire_changed_callback (Wire *wire, WireItem *item){	SheetPos start_pos, length;	GooCanvasPoints *points;		wire_get_pos_and_length (wire, &start_pos, &length);	points = goo_canvas_points_new (2);	points->coords[0] = 0;	points->coords[1] = 0;	points->coords[2] = length.x;	points->coords[3] = length.y;	g_object_set (item->priv->line, 	              "points", points, 	              NULL);	goo_canvas_points_unref (points);	g_object_set (item->priv->resize1,	              "x", -RESIZER_SIZE, 	              "y", -RESIZER_SIZE,	              "width", 2 * RESIZER_SIZE, 	              "height", 2 * RESIZER_SIZE, 	              NULL);	g_object_set (item->priv->resize2,	              "x", length.x-RESIZER_SIZE, 	              "y", length.y-RESIZER_SIZE,	              "width", 2 * RESIZER_SIZE, 	              "height", 2 * RESIZER_SIZE, 	              NULL);	goo_canvas_item_request_update (GOO_CANVAS_ITEM (item->priv->line));}

static AtkObject*goo_canvas_item_accessible_get_parent (AtkObject *accessible){  GooCanvasItem *item, *parent;  GooCanvas *canvas;  GObject *object;  g_return_val_if_fail (GOO_IS_CANVAS_ITEM_ACCESSIBLE (accessible), NULL);  if (accessible->accessible_parent)    return accessible->accessible_parent;  object = atk_gobject_accessible_get_object (ATK_GOBJECT_ACCESSIBLE (accessible));  if (object == NULL)    return NULL;  item = GOO_CANVAS_ITEM (object);  parent = goo_canvas_item_get_parent (item);  if (parent)    return atk_gobject_accessible_for_object (G_OBJECT (parent));  canvas = goo_canvas_item_get_canvas (item);  if (canvas)    return gtk_widget_get_accessible (GTK_WIDGET (canvas));  return NULL;}

static gbooleangoo_canvas_item_accessible_grab_focus (AtkComponent    *component){  GooCanvasItem *item;  GooCanvas *canvas;  GtkWidget *toplevel;  GObject *object;  g_return_val_if_fail (GOO_IS_CANVAS_ITEM_ACCESSIBLE (component), FALSE);  object = atk_gobject_accessible_get_object (ATK_GOBJECT_ACCESSIBLE (component));  if (!object)    return FALSE;  item = GOO_CANVAS_ITEM (object);  canvas = goo_canvas_item_get_canvas (item);  if (!canvas)    return FALSE;  goo_canvas_grab_focus (canvas, item);  toplevel = gtk_widget_get_toplevel (GTK_WIDGET (canvas));  if (GTK_WIDGET_TOPLEVEL (toplevel))    gtk_window_present (GTK_WINDOW (toplevel));  return TRUE;}

// Retrieves the bounding box. We use a caching scheme for this// since it's too expensive to calculate it every time we need it.inline static voidget_cached_bounds (PartItem *item, Coords *p1, Coords *p2){	PartItemPriv *priv;	priv = item->priv;	if (!priv->cache_valid) {		Coords start_pos, end_pos;		GooCanvasBounds bounds;				goo_canvas_item_get_bounds (GOO_CANVAS_ITEM (item), &bounds);		start_pos.x = bounds.x1;		start_pos.y = bounds.y1;		end_pos.x = bounds.x2;		end_pos.y = bounds.y2;		priv->bbox_start = start_pos;		priv->bbox_end = end_pos;		priv->cache_valid = TRUE;	}	memcpy (p1, &priv->bbox_start, sizeof (Coords));	memcpy (p2, &priv->bbox_end, sizeof (Coords));}

Sheet *sheet_item_get_sheet (SheetItem *item){	g_return_val_if_fail (item != NULL, NULL);	g_return_val_if_fail (IS_SHEET_ITEM (item), NULL);	return SHEET (goo_canvas_item_get_canvas (GOO_CANVAS_ITEM (item)));}

// Retrieves the bounding box. We use a caching scheme for this// since it's too expensive to calculate it every time we need it.inline static void get_boundingbox (WireItem *item, Coords *p1, Coords *p2){	g_return_if_fail (item != NULL);	g_return_if_fail (IS_WIRE_ITEM (item));	WireItemPriv *priv;	priv = item->priv;	if (!priv->cache_valid) {		Coords start_pos, end_pos;		GooCanvasBounds bounds; //, canvas_bounds;		goo_canvas_item_get_bounds (GOO_CANVAS_ITEM (item), &bounds);		priv->bbox_start.x = bounds.x1;		priv->bbox_start.y = bounds.y1;		priv->bbox_end.x = bounds.x2;		priv->bbox_end.y = bounds.y2;		priv->cache_valid = TRUE;	}	if (p1)		*p1 = priv->bbox_start;	if (p2)		*p2 = priv->bbox_end;}

voidrubberband_info_destroy (RubberbandInfo *rubberband_info){	g_return_if_fail (rubberband_info!=NULL);	goo_canvas_item_remove (GOO_CANVAS_ITEM (rubberband_info->rectangle));	g_free (rubberband_info);}

/* * remove the currently selected items from the sheet * (especially their goocanvas representators) */voidsheet_delete_selection (Sheet *sheet){	GList *copy, *iter;	g_return_if_fail (sheet != NULL);	g_return_if_fail (IS_SHEET (sheet));	if (sheet->state != SHEET_STATE_NONE)		return;	copy = g_list_copy (sheet->priv->selected_objects);	for (iter = copy; iter; iter = iter->next) {		sheet_remove_item_in_sheet (SHEET_ITEM (iter->data), sheet);		goo_canvas_item_remove (GOO_CANVAS_ITEM (iter->data));	}	g_list_free (copy);	// we need to it like this as <sheet_remove_item_in_sheet>	// requires selected_objects, items, floating_objects	// to be not NULL!	g_list_free (sheet->priv->selected_objects);	sheet->priv->selected_objects = NULL;}

static void wire_delete_callback (Wire *wire, WireItem *item){	// no clue why does work but canvas item does not disappear	//	g_clear_object (&item);	//	g_assert (item==NULL);	goo_canvas_item_remove (GOO_CANVAS_ITEM (item));	//	g_object_unref (wire); //FIXME this causes a segfault}

RubberbandInfo *rubberband_info_new (Sheet *sheet){	RubberbandInfo *rubberband_info;	cairo_pattern_t *pattern;	cairo_matrix_t matrix;	NG_DEBUG ("0x%x A", COLOR_A);	NG_DEBUG ("0x%x B", COLOR_B);	NG_DEBUG ("0x%x A PRE", COLOR_A_PRE);	NG_DEBUG ("0x%x B PRE", COLOR_B_PRE);	static guint32 stipple_data[8*8] = {	    COLOR_A_PRE, COLOR_A_PRE, COLOR_A_PRE, COLOR_B_PRE, COLOR_B_PRE, COLOR_B_PRE,COLOR_B_PRE,COLOR_A_PRE,	    COLOR_A_PRE, COLOR_A_PRE, COLOR_B_PRE, COLOR_B_PRE, COLOR_B_PRE, COLOR_B_PRE,COLOR_A_PRE,COLOR_A_PRE,	    COLOR_A_PRE, COLOR_B_PRE, COLOR_B_PRE, COLOR_B_PRE, COLOR_B_PRE, COLOR_A_PRE,COLOR_A_PRE,COLOR_A_PRE,	    COLOR_B_PRE, COLOR_B_PRE, COLOR_B_PRE, COLOR_B_PRE, COLOR_A_PRE, COLOR_A_PRE,COLOR_A_PRE,COLOR_A_PRE,	    	    COLOR_B_PRE, COLOR_B_PRE, COLOR_B_PRE, COLOR_A_PRE, COLOR_A_PRE, COLOR_A_PRE,COLOR_A_PRE,COLOR_B_PRE,	    COLOR_B_PRE, COLOR_B_PRE, COLOR_A_PRE, COLOR_A_PRE, COLOR_A_PRE, COLOR_A_PRE,COLOR_B_PRE,COLOR_B_PRE,	    COLOR_B_PRE, COLOR_A_PRE, COLOR_A_PRE, COLOR_A_PRE, COLOR_A_PRE, COLOR_B_PRE,COLOR_B_PRE,COLOR_B_PRE,	    COLOR_A_PRE, COLOR_A_PRE, COLOR_A_PRE, COLOR_A_PRE, COLOR_B_PRE, COLOR_B_PRE,COLOR_B_PRE,COLOR_B_PRE};/* the stipple patten should look like that *	    1 1 1 0  0 0 0 1 *	    1 1 0 0  0 0 1 1 *	    1 0 0 0  0 1 1 1 *	    0 0 0 0  1 1 1 1 *	     *	    0 0 0 1  1 1 1 0 *	    0 0 1 1  1 1 0 0 *	    0 1 1 1  1 0 0 0 *	    1 1 1 1  0 0 0 0 */	rubberband_info = g_new (RubberbandInfo, 1);	rubberband_info->state = RUBBERBAND_START;		pattern = create_stipple ("lightgrey", (guchar*)stipple_data);		//scale 5x, see http://cairographics.org/manual/cairo-cairo-pattern-t.html#cairo-pattern-t	cairo_matrix_init_scale (&matrix, 1.0, 1.0);	cairo_pattern_set_matrix (pattern, &matrix);		rubberband_info->rectangle = GOO_CANVAS_RECT (goo_canvas_rect_new (	    GOO_CANVAS_ITEM (sheet->object_group),	    10.0, 10.0,	    10.0, 10.0, 	    "stroke-color", "black",	    "line-width", 0.2,	    "fill-pattern", pattern,	    "visibility", GOO_CANVAS_ITEM_INVISIBLE,	    NULL));	cairo_pattern_destroy (pattern);	return rubberband_info;}

voidsheet_stop_rubberband (Sheet *sheet, GdkEventButton *event){	GList *list = NULL;	sheet->priv->rubberband->state = RUBBER_NO;	if (sheet->priv->preserve_selection_items != NULL) {		for (list = sheet->priv->preserve_selection_items; list; list = list->next)			sheet_item_set_preserve_selection (SHEET_ITEM (list->data), FALSE);				g_list_free (sheet->priv->preserve_selection_items);		sheet->priv->preserve_selection_items = NULL;	}	goo_canvas_pointer_ungrab (GOO_CANVAS (sheet),	                           GOO_CANVAS_ITEM (sheet->grid), event->time);		goo_canvas_item_remove (GOO_CANVAS_ITEM (sheet->priv->rubberband->rectangle));	//g_list_free_full (list, g_object_unref); //FIXME}

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}

/* this function is only linked for dynamic links */static voidon_new_pad (GstElement * element, GstPad * pad, GstEditorLink * link){  GstPadTemplate *src = NULL, *sink = NULL;  if (GST_IS_EDITOR_PAD_SOMETIMES (link->srcpad))    src = GST_PAD_TEMPLATE (link->srcpad->object);  if (GST_IS_EDITOR_PAD_SOMETIMES (link->sinkpad))    sink = GST_PAD_TEMPLATE (link->sinkpad->object);  g_message ("new pad");  if (pad->padtemplate) {    g_message ("from a template");    /* can't do pointer comparison -- some templates appear to be from the       elementfactories, some from template factories... have to compare       names */    if (src &&        g_ascii_strcasecmp (            pad->padtemplate->name_template, src->name_template) == 0)      g_object_set (G_OBJECT (GOO_CANVAS_ITEM (link)), "src-pad",          gst_editor_item_get (GST_OBJECT (pad)), NULL);    else if (sink &&             g_ascii_strcasecmp (                 pad->padtemplate->name_template, sink->name_template) == 0)      g_object_set (G_OBJECT (GOO_CANVAS_ITEM (link)), "sink-pad",          gst_editor_item_get (GST_OBJECT (pad)), NULL);    else      return;    g_message ("we made it, now let's link");    /*gst_element_set_state ((GstElement *)       gst_element_get_managing_bin (element), GST_STATE_PAUSED); */    gst_editor_link_link (link);    /*gst_element_set_state ((GstElement *)       gst_element_get_managing_bin (element), GST_STATE_PLAYING); */  }}

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

static voidgoo_canvas_item_accessible_get_extents (AtkComponent *component,					gint         *x,					gint         *y,					gint         *width,					gint         *height,					AtkCoordType  coord_type){  GooCanvasItem *item;  GooCanvas *canvas;  GObject *object;  gint window_x, window_y;  gint toplevel_x, toplevel_y;  GdkRectangle rect;  GdkWindow *window;  g_return_if_fail (GOO_IS_CANVAS_ITEM_ACCESSIBLE (component));  *x = *y = G_MININT;  object = atk_gobject_accessible_get_object (ATK_GOBJECT_ACCESSIBLE (component));  if (!object)    return;  item = GOO_CANVAS_ITEM (object);  canvas = goo_canvas_item_get_canvas (item);  if (!canvas || !GTK_WIDGET (canvas)->window)    return;  goo_canvas_item_accessible_get_item_extents (item, &rect);  *width = rect.width;  *height = rect.height;  if (!goo_canvas_item_accessible_is_item_in_window (item, &rect))    return;  gdk_window_get_origin (GTK_WIDGET (canvas)->window,			 &window_x, &window_y);  *x = rect.x + window_x;  *y = rect.y + window_y;  if (coord_type == ATK_XY_WINDOW)    {      window = gdk_window_get_toplevel (GTK_WIDGET (canvas)->window);      gdk_window_get_origin (window, &toplevel_x, &toplevel_y);      *x -= toplevel_x;      *y -= toplevel_y;    }}

static void textbox_text_changed_callback (ItemData *data, gchar *new_text, SheetItem *item){	TextboxItem *textbox_item;	g_return_if_fail (data != NULL);	g_return_if_fail (IS_ITEM_DATA (data));	g_return_if_fail (item != NULL);	g_return_if_fail (IS_TEXTBOX_ITEM (item));	textbox_item = TEXTBOX_ITEM (item);	g_object_set (textbox_item->priv->text_canvas_item, "text", new_text, NULL);	goo_canvas_item_ensure_updated (GOO_CANVAS_ITEM (textbox_item));}

static gintgoo_canvas_item_accessible_get_n_children (AtkObject *accessible){  GooCanvasItem *item;  GObject *object;  g_return_val_if_fail (GOO_IS_CANVAS_ITEM_ACCESSIBLE (accessible), 0);  object = atk_gobject_accessible_get_object (ATK_GOBJECT_ACCESSIBLE (accessible));  if (object == NULL)    return 0;  item = GOO_CANVAS_ITEM (object);  return goo_canvas_item_get_n_children (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}

static AtkStateSet*goo_canvas_item_accessible_ref_state_set (AtkObject *accessible){  GooCanvasItem *item;  GooCanvas *canvas;  AtkStateSet *state_set;  GObject *object;  gboolean can_focus = FALSE;  g_return_val_if_fail (GOO_IS_CANVAS_ITEM_ACCESSIBLE (accessible), NULL);  state_set = ATK_OBJECT_CLASS (goo_canvas_item_accessible_parent_class)->ref_state_set (accessible);  object = atk_gobject_accessible_get_object (ATK_GOBJECT_ACCESSIBLE (accessible));  if (!object)    {      atk_state_set_add_state (state_set, ATK_STATE_DEFUNCT);      return state_set;    }  item = GOO_CANVAS_ITEM (object);  canvas = goo_canvas_item_get_canvas (item);  if (!canvas)    return state_set;  if (goo_canvas_item_is_visible (item))    {      atk_state_set_add_state (state_set, ATK_STATE_VISIBLE);      if (goo_canvas_item_accessible_is_item_on_screen (item))	atk_state_set_add_state (state_set, ATK_STATE_SHOWING);    }  g_object_get (item, "can-focus", &can_focus, NULL);  if (GTK_WIDGET_CAN_FOCUS (GTK_WIDGET (canvas)) && can_focus)    {      atk_state_set_add_state (state_set, ATK_STATE_FOCUSABLE);      if (GTK_WIDGET_HAS_FOCUS (canvas)	  && canvas->focused_item == item)	atk_state_set_add_state (state_set, ATK_STATE_FOCUSED);    }  return state_set;}