goo_canvas_item_translate ()

void
goo_canvas_item_translate (GooCanvasItem *item,
                           gdouble tx,
                           gdouble ty);

Translates the origin of the item's coordinate system by the given amounts.

goo_canvas_item_scale ()

void
goo_canvas_item_scale (GooCanvasItem *item,
                       gdouble sx,
                       gdouble sy);

Scales the item's coordinate system by the given amounts.

goo_canvas_item_rotate ()

void
goo_canvas_item_rotate (GooCanvasItem *item,
                        gdouble degrees,
                        gdouble cx,
                        gdouble cy);

Rotates the item's coordinate system by the given amount, about the given origin.

goo_canvas_item_skew_x ()

void
goo_canvas_item_skew_x (GooCanvasItem *item,
                        gdouble degrees,
                        gdouble cx,
                        gdouble cy);

Skews the item's coordinate system along the x axis by the given amount, about the given origin.

goo_canvas_item_skew_y ()

void
goo_canvas_item_skew_y (GooCanvasItem *item,
                        gdouble degrees,
                        gdouble cx,
                        gdouble cy);

Skews the item's coordinate system along the y axis by the given amount, about the given origin.

goo_canvas_item_get_transform ()

gboolean
goo_canvas_item_get_transform (GooCanvasItem *item,
                               cairo_matrix_t *transform);

Gets the transformation matrix of an item.

goo_canvas_item_set_transform ()

void
goo_canvas_item_set_transform (GooCanvasItem *item,
                               const cairo_matrix_t *transform);

Sets the transformation matrix of an item.

goo_canvas_item_get_simple_transform ()

gboolean
goo_canvas_item_get_simple_transform (GooCanvasItem *item,
                                      gdouble *x,
                                      gdouble *y,
                                      gdouble *scale,
                                      gdouble *rotation);

This function can be used to get the position, scale and rotation of an item, providing that the item has a simple transformation matrix (e.g. set with goo_canvas_item_set_simple_transform(), or using a combination of simple translate, scale and rotate operations). If the item has a complex transformation matrix the results will be incorrect.

goo_canvas_item_set_simple_transform ()

void
goo_canvas_item_set_simple_transform (GooCanvasItem *item,
                                      gdouble x,
                                      gdouble y,
                                      gdouble scale,
                                      gdouble rotation);

A convenience function to set the item's transformation matrix.

goo_canvas_item_get_bounds ()

void
goo_canvas_item_get_bounds (GooCanvasItem *item,
                            GooCanvasBounds *bounds);

Gets the bounds of the item.

Note that the bounds includes the entire fill and stroke extents of the item, whether they are painted or not.

goo_canvas_item_is_visible ()

gboolean
goo_canvas_item_is_visible (GooCanvasItem *item);

Checks if the item is visible.

This entails checking the item's own visibility setting, as well as those of its ancestors.

Note that the item may be scrolled off the screen and so may not be actually visible to the user.

goo_canvas_item_get_is_static ()

gboolean
goo_canvas_item_get_is_static (GooCanvasItem *item);

Returns TRUE if the item is static. Static items do not move or change size when the canvas is scrolled or the scale changes.

goo_canvas_item_set_is_static ()

void
goo_canvas_item_set_is_static (GooCanvasItem *item,
                               gboolean is_static);

Notifies the item that it is static. Static items do not move or change size when the canvas is scrolled or the scale changes.

Container items such as GooCanvasGroup should call this function when children are added, to notify children whether they are static or not. Containers should also pass on any changes in their own status to children.

goo_canvas_item_animate ()

void
goo_canvas_item_animate (GooCanvasItem *item,
                         gdouble x,
                         gdouble y,
                         gdouble scale,
                         gdouble degrees,
                         gboolean absolute,
                         gint duration,
                         gint step_time,
                         GooCanvasAnimateType type);

Animates an item from its current position to the given offsets, scale and rotation.

goo_canvas_item_stop_animation ()

void
goo_canvas_item_stop_animation (GooCanvasItem *item);

Stops any current animation for the given item, leaving it at its current position.

goo_canvas_item_raise ()

void
goo_canvas_item_raise (GooCanvasItem *item,
                       GooCanvasItem *above);

Raises an item in the stacking order.

goo_canvas_item_lower ()

void
goo_canvas_item_lower (GooCanvasItem *item,
                       GooCanvasItem *below);

Lowers an item in the stacking order.

goo_canvas_item_remove ()

void
goo_canvas_item_remove (GooCanvasItem *item);

Removes an item from its parent. If the item is in a canvas it will be removed.

This would normally also result in the item being freed.

goo_canvas_item_get_canvas ()

GooCanvas *
goo_canvas_item_get_canvas (GooCanvasItem *item);

Returns the GooCanvas containing the given GooCanvasItem.

goo_canvas_item_set_canvas ()

void
goo_canvas_item_set_canvas (GooCanvasItem *item,
                            GooCanvas *canvas);

This function is only intended to be used when implementing new canvas items, specifically container items such as GooCanvasGroup.

It sets the canvas of the item.

goo_canvas_item_get_parent ()

GooCanvasItem *
goo_canvas_item_get_parent (GooCanvasItem *item);

Gets the parent of the given item.

goo_canvas_item_set_parent ()

void
goo_canvas_item_set_parent (GooCanvasItem *item,
                            GooCanvasItem *parent);

This function is only intended to be used when implementing new canvas items (specifically container items such as GooCanvasGroup). It sets the parent of the child item.

goo_canvas_item_get_model ()

GooCanvasItemModel *
goo_canvas_item_get_model (GooCanvasItem *item);

Gets the model of the given canvas item.

goo_canvas_item_set_model ()

void
goo_canvas_item_set_model (GooCanvasItem *item,
                           GooCanvasItemModel *model);

Sets the model of the given canvas item.

goo_canvas_item_is_container ()

gboolean
goo_canvas_item_is_container (GooCanvasItem *item);

Tests to see if the given item is a container.

goo_canvas_item_get_n_children ()

gint
goo_canvas_item_get_n_children (GooCanvasItem *item);

Gets the number of children of the container.

goo_canvas_item_get_child ()

GooCanvasItem *
goo_canvas_item_get_child (GooCanvasItem *item,
                           gint child_num);

Gets the child item at the given stack position.

goo_canvas_item_find_child ()

gint
goo_canvas_item_find_child (GooCanvasItem *item,
                            GooCanvasItem *child);

Attempts to find the given child item with the container's stack.

goo_canvas_item_add_child ()

void
goo_canvas_item_add_child (GooCanvasItem *item,
                           GooCanvasItem *child,
                           gint position);

Adds a child item to a container item at the given stack position.

goo_canvas_item_move_child ()

void
goo_canvas_item_move_child (GooCanvasItem *item,
                            gint old_position,
                            gint new_position);

Moves a child item to a new stack position within the container.

goo_canvas_item_remove_child ()

void
goo_canvas_item_remove_child (GooCanvasItem *item,
                              gint child_num);

Removes the child item at the given position.

goo_canvas_item_get_transform_for_child ()

gboolean
goo_canvas_item_get_transform_for_child
                               (GooCanvasItem *item,
                                GooCanvasItem *child,
                                cairo_matrix_t *transform);

Gets the transformation matrix of an item combined with any special transform needed for the given child. These special transforms are used by layout items such as GooCanvasTable.

goo_canvas_item_get_style ()

GooCanvasStyle *
goo_canvas_item_get_style (GooCanvasItem *item);

Gets the item's style. If the item doesn't have its own style it will return its parent's style.

goo_canvas_item_set_style ()

void
goo_canvas_item_set_style (GooCanvasItem *item,
                           GooCanvasStyle *style);

Sets the item's style, by copying the properties from the given style.

goo_canvas_item_request_update ()

void
goo_canvas_item_request_update (GooCanvasItem *item);

This function is only intended to be used when implementing new canvas items.

It requests that an update of the item is scheduled. It will be performed as soon as the application is idle, and before the canvas is redrawn.

goo_canvas_item_ensure_updated ()

void
goo_canvas_item_ensure_updated (GooCanvasItem *item);

This function is only intended to be used when implementing new canvas items.

It updates the canvas immediately, if an update is scheduled. This ensures that all item bounds are up-to-date.

goo_canvas_item_update ()

void
goo_canvas_item_update (GooCanvasItem *item,
                        gboolean entire_tree,
                        cairo_t *cr,
                        GooCanvasBounds *bounds);

This function is only intended to be used when implementing new canvas items, specifically container items such as GooCanvasGroup.

Updates the item, if needed, and any children.

goo_canvas_item_get_requested_area ()

gboolean
goo_canvas_item_get_requested_area (GooCanvasItem *item,
                                    cairo_t *cr,
                                    GooCanvasBounds *requested_area);

This function is only intended to be used when implementing new canvas items, specifically layout items such as GooCanvasTable.

It gets the requested area of a child item.

goo_canvas_item_get_requested_area_for_width ()

gboolean
goo_canvas_item_get_requested_area_for_width
                               (GooCanvasItem *item,
                                cairo_t *cr,
                                gdouble width,
                                GooCanvasBounds *requested_area);

This function is only intended to be used when implementing new canvas items, specifically layout items such as GooCanvasTable.

It gets the requested area of a child item, assuming it is allocated the given width. This is useful for text items whose requested height may change depending on the allocated width.

Since: 2.0.1

goo_canvas_item_get_requested_height ()

gdouble
goo_canvas_item_get_requested_height (GooCanvasItem *item,
                                      cairo_t *cr,
                                      gdouble width);

This function is only intended to be used when implementing new canvas items, specifically layout items such as GooCanvasTable.

It gets the requested height of a child item, assuming it is allocated the given width. This is useful for text items whose requested height may change depending on the allocated width.

goo_canvas_item_allocate_area ()

void
goo_canvas_item_allocate_area (GooCanvasItem *item,
                               cairo_t *cr,
                               const GooCanvasBounds *requested_area,
                               const GooCanvasBounds *allocated_area,
                               gdouble x_offset,
                               gdouble y_offset);

This function is only intended to be used when implementing new canvas items, specifically layout items such as GooCanvasTable.

It allocates an area to a child GooCanvasItem.

Note that the parent layout item will use a transform to move each of its children for the layout, so there is no need for the child item to reposition itself. It only needs to recalculate its device bounds.

To help recalculate the item's device bounds, the x_offset and y_offset of the child item's allocated position from its requested position are provided. Simple items can just add these to their bounds.

goo_canvas_item_get_items_at ()

GList *
goo_canvas_item_get_items_at (GooCanvasItem *item,
                              gdouble x,
                              gdouble y,
                              cairo_t *cr,
                              gboolean is_pointer_event,
                              gboolean parent_is_visible,
                              GList *found_items);

This function is only intended to be used when implementing new canvas items, specifically container items such as GooCanvasGroup.

It gets the items at the given point.

goo_canvas_item_paint ()

void
goo_canvas_item_paint (GooCanvasItem *item,
                       cairo_t *cr,
                       const GooCanvasBounds *bounds,
                       gdouble scale);

This function is only intended to be used when implementing new canvas items, specifically container items such as GooCanvasGroup.

It paints the item and all children if they intersect the given bounds.

Note that the scale argument may be different to the current scale in the GooCanvasItem, e.g. when the canvas is being printed.

goo_canvas_item_class_install_child_property ()

void
goo_canvas_item_class_install_child_property
                               (GObjectClass *iclass,
                                guint property_id,
                                GParamSpec *pspec);

This function is only intended to be used when implementing new canvas items, specifically layout container items such as GooCanvasTable.

It installs a child property on a canvas item class.

goo_canvas_item_class_list_child_properties ()

GParamSpec **
goo_canvas_item_class_list_child_properties
                               (GObjectClass *iclass,
                                guint *n_properties);

This function is only intended to be used when implementing new canvas items, specifically layout container items such as GooCanvasTable.

It returns all child properties of a canvas item class.

goo_canvas_item_class_find_child_property ()

GParamSpec *
goo_canvas_item_class_find_child_property
                               (GObjectClass *iclass,
                                const gchar *property_name);

This function is only intended to be used when implementing new canvas items, specifically layout container items such as GooCanvasTable.

It finds a child property of a canvas item class by name.

goo_canvas_item_get_child_property ()

void
goo_canvas_item_get_child_property (GooCanvasItem *item,
                                    GooCanvasItem *child,
                                    const gchar *property_name,
                                    GValue *value);

Gets a child property of child .

goo_canvas_item_set_child_property ()

void
goo_canvas_item_set_child_property (GooCanvasItem *item,
                                    GooCanvasItem *child,
                                    const gchar *property_name,
                                    const GValue *value);

Sets a child property of child .

goo_canvas_item_get_child_properties ()

void
goo_canvas_item_get_child_properties (GooCanvasItem *item,
                                      GooCanvasItem *child,
                                      ...);

Gets the values of one or more child properties of child .

goo_canvas_item_get_child_properties_valist ()

void
goo_canvas_item_get_child_properties_valist
                               (GooCanvasItem *item,
                                GooCanvasItem *child,
                                va_list var_args);

Gets the values of one or more child properties of child .

goo_canvas_item_set_child_properties ()

void
goo_canvas_item_set_child_properties (GooCanvasItem *item,
                                      GooCanvasItem *child,
                                      ...);

Sets the values of one or more child properties of child .

goo_canvas_item_set_child_properties_valist ()

void
goo_canvas_item_set_child_properties_valist
                               (GooCanvasItem *item,
                                GooCanvasItem *child,
                                va_list var_args);

Sets the values of one or more child properties of child .

GooCanvasItem

typedef struct _GooCanvasItem GooCanvasItem;

GooCanvasItem is a typedef used for objects that implement the GooCanvasItem interface.

(There is no actual GooCanvasItem struct, since it is only an interface. But using 'GooCanvasItem' is more helpful than using 'GObject'.)

struct GooCanvasItemIface

struct GooCanvasItemIface {
  /* Virtual methods that group items must implement. */
  GooCanvas*		(* get_canvas)			(GooCanvasItem		*item);
  void			(* set_canvas)			(GooCanvasItem		*item,
							 GooCanvas		*canvas);
  gint			(* get_n_children)		(GooCanvasItem		*item);
  GooCanvasItem* (* get_child)			(GooCanvasItem		*item,
							 gint			 child_num);
  void			(* request_update)		(GooCanvasItem		*item);

  /* Virtual methods that group items may implement. */
  void			(* add_child)			(GooCanvasItem		*item,
							 GooCanvasItem		*child,
							 gint			 position);
  void			(* move_child)			(GooCanvasItem		*item,
							 gint			 old_position,
							 gint			 new_position);
  void			(* remove_child)		(GooCanvasItem		*item,
							 gint			 child_num);
  void			(* get_child_property)		(GooCanvasItem		*item,
							 GooCanvasItem		*child,
							 guint			 property_id,
							 GValue			*value,
							 GParamSpec		*pspec);
  void			(* set_child_property)		(GooCanvasItem		*item,
							 GooCanvasItem		*child,
							 guint			 property_id,
							 const GValue		*value,
							 GParamSpec		*pspec);
  gboolean		(* get_transform_for_child) (GooCanvasItem		*item,
							 GooCanvasItem		*child,
							 cairo_matrix_t		*transform);

  /* Virtual methods that all canvas items must implement. */
  GooCanvasItem* (* get_parent)			(GooCanvasItem		*item);
  void			(* set_parent)			(GooCanvasItem		*item,
							 GooCanvasItem		*parent);
  void			(* get_bounds)			(GooCanvasItem		*item,
							 GooCanvasBounds *bounds);
  GList*		(* get_items_at)		(GooCanvasItem		*item,
							 gdouble		 x,
							 gdouble		 y,
							 cairo_t		*cr,
							 gboolean		 is_pointer_event,
							 gboolean		 parent_is_visible,
							 GList                  *found_items);
  void			(* update)			(GooCanvasItem		*item,
							 gboolean		 entire_tree,
							 cairo_t		*cr,
							 GooCanvasBounds *bounds);
  void			(* paint)			(GooCanvasItem		*item,
							 cairo_t		*cr,
							 const GooCanvasBounds *bounds,
							 gdouble		 scale);

  gboolean		(* get_requested_area)		(GooCanvasItem		*item,
							 cairo_t		*cr,
							 GooCanvasBounds *requested_area);
  void			(* allocate_area)		(GooCanvasItem		*item,
							 cairo_t		*cr,
							 const GooCanvasBounds *requested_area,
							 const GooCanvasBounds *allocated_area,
							 gdouble		 x_offset,
							 gdouble		 y_offset);

  /* Virtual methods that canvas items may implement. */
  gboolean		(* get_transform)		(GooCanvasItem		*item,
							 cairo_matrix_t		*transform);
  void			(* set_transform)		(GooCanvasItem		*item,
							 const cairo_matrix_t *transform);
  GooCanvasStyle* (* get_style)			(GooCanvasItem		*item);
  void			(* set_style)			(GooCanvasItem		*item,
							 GooCanvasStyle		*style);
  gboolean		(* is_visible)			(GooCanvasItem		*item);
  gdouble               (* get_requested_height) (GooCanvasItem		*item,
							 cairo_t		*cr,
							 gdouble		 width);

  /* Virtual methods that model/view items must implement. */
  GooCanvasItemModel* (* get_model)			(GooCanvasItem		*item);
  void			(* set_model)			(GooCanvasItem		*item,
							 GooCanvasItemModel *model);


  /* Signals. */
  gboolean		(* enter_notify_event)		(GooCanvasItem		*item,
							 GooCanvasItem		*target,
							 GdkEventCrossing *event);
  gboolean		(* leave_notify_event)		(GooCanvasItem		*item,
							 GooCanvasItem		*target,
							 GdkEventCrossing *event);
  gboolean		(* motion_notify_event)		(GooCanvasItem		*item,
							 GooCanvasItem		*target,
							 GdkEventMotion		*event);
  gboolean		(* button_press_event)		(GooCanvasItem		*item,
							 GooCanvasItem		*target,
							 GdkEventButton		*event);
  gboolean		(* button_release_event) (GooCanvasItem		*item,
							 GooCanvasItem		*target,
							 GdkEventButton		*event);
  gboolean		(* focus_in_event)		(GooCanvasItem		*item,
							 GooCanvasItem		*target,
							 GdkEventFocus		*event);
  gboolean		(* focus_out_event)		(GooCanvasItem		*item,
							 GooCanvasItem		*target,
							 GdkEventFocus		*event);
  gboolean		(* key_press_event)		(GooCanvasItem		*item,
							 GooCanvasItem		*target,
							 GdkEventKey		*event);
  gboolean		(* key_release_event)		(GooCanvasItem		*item,
							 GooCanvasItem		*target,
							 GdkEventKey		*event);
  gboolean		(* grab_broken_event)		(GooCanvasItem		*item,
							 GooCanvasItem		*target,
							 GdkEventGrabBroken *event);
  void			(* child_notify)		(GooCanvasItem		*item,
							 GParamSpec		*pspec);
  gboolean		(* query_tooltip)		(GooCanvasItem		*item,
							 gdouble		 x,
							 gdouble		 y,
							 gboolean		 keyboard_tooltip,
							 GtkTooltip		*tooltip);

  gboolean		(* get_is_static)		(GooCanvasItem		*item);
  void			(* set_is_static)		(GooCanvasItem		*item,
							 gboolean		 is_static);

  void			(* animation_finished)		(GooCanvasItem           *item,
							 gboolean                 stopped);

  gboolean		(* scroll_event)		(GooCanvasItem		*item,
							 GooCanvasItem		*target,
							 GdkEventScroll		*event);

  gboolean              (* get_requested_area_for_width)(GooCanvasItem		*item,
							 cairo_t		*cr,
							 gdouble		 width,
							 GooCanvasBounds *requested_area);
};

GooCanvasItemIFace holds the virtual methods that make up the GooCanvasItem interface.

Simple canvas items only need to implement the get_parent(), set_parent(), get_bounds(), get_items_at(), update() and paint() methods (and also get_requested_area() and allocate_area() if they are going to be used inside a layout container like GooCanvasTable).

Items that support transforms should also implement get_transform() and set_transform(). Items that support styles should implement get_style() and set_style().

Container items must implement get_canvas(), set_canvas(), get_n_children(), get_child() and request_update(). Containers that support dynamic changes to their children should implement add_child(), move_child() and remove_child(). Layout containers like GooCanvasTable may implement get_child_property(), set_child_property() and get_transform_for_child().

The “can-focus” property

  “can-focus”                gboolean

If the item can take the keyboard focus.

Flags: Read / Write

Default value: FALSE

The “description” property

  “description”              gchar *

A description of the item for use by assistive technologies.

Flags: Read / Write

Default value: NULL

The “parent” property

  “parent”                   GooCanvasItem *

The parent item.

Flags: Read / Write

The “pointer-events” property

  “pointer-events”           GooCanvasPointerEvents

Specifies when the item receives pointer events.

Flags: Read / Write

Default value: GOO_CANVAS_EVENTS_VISIBLE_MASK | GOO_CANVAS_EVENTS_PAINTED_MASK | GOO_CANVAS_EVENTS_FILL_MASK | GOO_CANVAS_EVENTS_STROKE_MASK

The “title” property

  “title”                    gchar *

A short context-rich description of the item for use by assistive technologies.

Flags: Read / Write

Default value: NULL

The “tooltip” property

  “tooltip”                  gchar *

The tooltip to display for the item, or NULL to display no tooltip.

Note that this property has no effect unless the “has-tooltip” property is set to TRUE on the GooCanvas containing this item.

Flags: Read / Write

Default value: NULL

The “transform” property

  “transform”                GooCairoMatrix *

The transformation matrix of the item.

Flags: Read / Write

The “visibility” property

  “visibility”               GooCanvasItemVisibility

When the canvas item is visible.

Flags: Read / Write

Default value: GOO_CANVAS_ITEM_VISIBLE

The “visibility-threshold” property

  “visibility-threshold”     gdouble

The scale threshold at which the item becomes visible.

Flags: Read / Write

Allowed values: >= 0

Default value: 0

The “animation-finished” signal

void
user_function (GooCanvasItem *item,
               gboolean       stopped,
               gpointer       user_data)

Emitted when the item animation has finished.

Flags: Run Last

The “button-press-event” signal

gboolean
user_function (GooCanvasItem *item,
               GooCanvasItem *target_item,
               GdkEvent      *event,
               gpointer       user_data)

Emitted when a mouse button is pressed in an item.

Flags: Run Last

The “button-release-event” signal

gboolean
user_function (GooCanvasItem *item,
               GooCanvasItem *target_item,
               GdkEvent      *event,
               gpointer       user_data)

Emitted when a mouse button is released in an item.

Flags: Run Last

The “child-notify” signal

void
user_function (GooCanvasItem *item,
               GParamSpec    *pspec,
               gpointer       user_data)

Emitted for each child property that has changed. The signal's detail holds the property name.

Flags: No Hooks

The “enter-notify-event” signal

gboolean
user_function (GooCanvasItem *item,
               GooCanvasItem *target_item,
               GdkEvent      *event,
               gpointer       user_data)

Emitted when the mouse enters an item.

Flags: Run Last

The “focus-in-event” signal

gboolean
user_function (GooCanvasItem *item,
               GooCanvasItem *target_item,
               GdkEvent      *event,
               gpointer       user_data)

Emitted when the item receives the keyboard focus.

Flags: Run Last

The “focus-out-event” signal

gboolean
user_function (GooCanvasItem *item,
               GooCanvasItem *target_item,
               GdkEvent      *event,
               gpointer       user_data)

Emitted when the item loses the keyboard focus.

Flags: Run Last

The “grab-broken-event” signal

gboolean
user_function (GooCanvasItem *item,
               GooCanvasItem *target_item,
               GdkEvent      *event,
               gpointer       user_data)

Emitted when the item's keyboard or pointer grab was lost unexpectedly.

Flags: Run Last

The “key-press-event” signal

gboolean
user_function (GooCanvasItem *item,
               GooCanvasItem *target_item,
               GdkEvent      *event,
               gpointer       user_data)

Emitted when a key is pressed and the item has the keyboard focus.

Flags: Run Last

The “key-release-event” signal

gboolean
user_function (GooCanvasItem *item,
               GooCanvasItem *target_item,
               GdkEvent      *event,
               gpointer       user_data)

Emitted when a key is released and the item has the keyboard focus.

Flags: Run Last

The “leave-notify-event” signal

gboolean
user_function (GooCanvasItem *item,
               GooCanvasItem *target_item,
               GdkEvent      *event,
               gpointer       user_data)

Emitted when the mouse leaves an item.

Flags: Run Last

The “motion-notify-event” signal

gboolean
user_function (GooCanvasItem *item,
               GooCanvasItem *target_item,
               GdkEvent      *event,
               gpointer       user_data)

Emitted when the mouse moves within an item.

Flags: Run Last

The “query-tooltip” signal

gboolean
user_function (GooCanvasItem *item,
               gdouble        x,
               gdouble        y,
               gboolean       keyboard_mode,
               GtkTooltip    *tooltip,
               gpointer       user_data)

Emitted when the mouse has paused over the item for a certain amount of time, or the tooltip was requested via the keyboard.

Note that if keyboard_mode is TRUE, the values of x and y are undefined and should not be used.

If the item wants to display a tooltip it should update tooltip and return TRUE.

Flags: Run Last

The “scroll-event” signal

gboolean
user_function (GooCanvasItem *item,
               GooCanvasItem *target_item,
               GdkEvent      *event,
               gpointer       user_data)

Emitted when a button in the 4 to 7 range is pressed. Wheel mice are usually configured to generate button press events for buttons 4 and 5 when the wheel is turned in an item.

Flags: Run Last