goocanvas.Canvas.convert_bounds_to_item_space

convert_bounds_to_item_space(item,
                             bounds);

Converts the bound in device space to a bounding box in item space. This is useful in the item paint() methods to convert the bounds to be painted to the item's coordinate space.

goocanvas.Canvas.convert_from_item_space

convert_from_item_space(item,
                        x,
                        y);

Converts a coordinate from the given item's coordinate space to the canvas coordinate space, applying all transformation matrices including the item's own transformation matrix, if it has one.

goocanvas.Canvas.convert_from_pixel

convert_from_pixel(x,
                   y);

Converts a coordinate from pixels to the canvas coordinate space. The pixel coordinate space specifies pixels from the top-left of the entire canvas window, according to the current scale setting. See set_scale(). The canvas view coordinate space is specified in the call to set_bounds().

goocanvas.Canvas.convert_to_item_space

convert_to_item_space(item,
                      x,
                      y);

Converts a coordinate from the canvas coordinate space to the given item's coordinate space, applying all transformation matrices including the item's own transformation matrix, if it has one.

goocanvas.Canvas.convert_to_pixel

convert_to_pixel(x,
                 y);

Converts a coordinate from the canvas coordinate space to pixels. The canvas coordinate space is specified in the call to set_bounds The pixel coordinate space specifies pixels from the top-left of the entire canvas window, according to the current scale setting. See set_scale

goocanvas.Canvas.create_cairo_context

create_cairo_context();

Creates a cairo context, initialized with the default canvas settings.

goocanvas.Canvas.create_item

create_item(model);

Creates a new canvas item for the given item model, and recursively creates items for any children. It uses the create_item virtual method if it has been set. Subclasses of GooCanvas can define this method if they want to use custom views for items. It emits the "item-created" signal after creating the view, so application code can connect signal handlers to the new view if desired.

goocanvas.Canvas.get_bounds

get_bounds();

Gets the bounds of the canvas, in canvas units. By default, canvas units are pixels, though the GooCanvas:units property can be used to change the units to points, inches or millimeters.

goocanvas.Canvas.get_default_line_width

get_default_line_width();

Gets the default line width, which depends on the current units setting.

goocanvas.Canvas.get_item

get_item(model);

Gets the canvas item associated with the given goocanvas.ItemModel. This is only useful when set_root_item_model has been used to set a model for the canvas.

For simple applications you can use get_item to set up signal handlers for your items, e.g.

                item = canvas.get_item (my_item)
                item.connect ("button_press_event", on_my_item_button_press)

More complex applications may want to use the GooCanvas::item-created signal to hook up their signal handlers.

goocanvas.Canvas.get_item_at

get_item_at(x,
            y,
            is_pointer_event);

Gets the item at the given point.

goocanvas.Canvas.get_items_at

get_items_at(x,
             y,
             is_pointer_event);

Gets all items at the given point.

goocanvas.Canvas.get_items_in_area

get_items_in_area(area,
                  inside_area,
                  allow_overlaps,
                  include_containers);

Gets a list of items inside or outside a given area.

goocanvas.Canvas.get_root_item

get_root_item();

Gets the root item of the canvas, usually a goocanvas.Group.

goocanvas.Canvas.get_root_item_model

get_root_item_model();

Gets the root item model of the canvas, usually a goocanvas.GroupModel.

goocanvas.Canvas.get_scale

get_scale();

Gets the current scale of the canvas, i.e. the number of pixels to use for each device unit.

goocanvas.Canvas.get_static_root_item

get_static_root_item();

Gets the static root item of the canvas.

goocanvas.Canvas.get_static_root_item_model

get_static_root_item_model();

Gets the static root item model of the canvas.

goocanvas.Canvas.grab_focus

grab_focus(item);

Grabs the keyboard focus for the given item.

goocanvas.Canvas.keyboard_grab

keyboard_grab(item,
              owner_events,
              time);

Grabs the keyboard focus for the given item.

goocanvas.Canvas.keyboard_ungrab

keyboard_grab(item,
              time);

Ungrabs the pointer, if the given item view has the pointer grab.

goocanvas.Canvas.pointer_grab

pointer_grab(item,
             event_mask,
             cursor,
             time);

Attempts to grab the pointer for the given item.

goocanvas.Canvas.pointer_ungrab

pointer_ungrab(item,
               time);

Ungrabs the pointer, if the given item view has the pointer grab.

goocanvas.Canvas.register_widget_item

register_widget_item(witem);

Registers a widget item with the canvas, so that the canvas can do the necessary actions to move and resize the widget as needed.

This function should only be used by goocanvas.Widget and subclass implementations.

goocanvas.Canvas.render

render(cr,
       bounds,
       scale);

Renders all or part of a canvas to the given cairo context.

goocanvas.Canvas.request_item_redraw

request_item_redraw(bounds,
                    is_static);

Requests that the given bounds be redrawn.

goocanvas.Canvas.request_redraw

request_redraw(bounds);

Requests that the given bounds be redrawn.

goocanvas.Canvas.request_update

request_update();

Schedules an update of the goocanvas.Canvas. This will be performed in the idle loop, after all pending events have been handled, but before the canvas has been repainted.

goocanvas.Canvas.scroll_to

scroll_to(left,
          top);

Scrolls the canvas, placing the given point as close to the top-left of the view as possible.

goocanvas.Canvas.set_bounds

set_bounds(left,
           top,
           right,
           bottom);

Sets the bounds of the goocanvas.Canvas in device units. By default, device units are the same as pixels, though set_scale can be used to specify a different scale.

goocanvas.Canvas.set_root_item

set_root_item(item);

Sets the root item of the canvas. Any existing canvas items are removed.

goocanvas.Canvas.set_root_item_model

set_root_item_model(model);

Sets the root item of the canvas. A hierarchy of canvas items will be created, corresponding to the hierarchy of items in the model. Any current canvas items will be removed.

goocanvas.Canvas.set_scale

set_scale(pixel_per_unit);

Sets the current scale of the canvas, i.e. the number of pixels to use for each device unit.

goocanvas.Canvas.set_static_root_item

set_static_root_item(item);

Sets the static root item. Any existing static items are removed.

goocanvas.Canvas.set_static_root_item_model

set_static_root_item_model(model);

Sets the static root item model. Any existing static items are removed.

goocanvas.Canvas.unregister_item

unregister_item(model);

This function should be called in the finalize method of goocanvas.Item objects, to remove the canvas item from the GooCanvas's hash table.

goocanvas.Canvas.unregister_widget_item

unregister_widget_item(witem);

Unregisters a widget item from the canvas, when the item is no longer in the canvas.

This function should only be used by goocanvas.Widget and ubclass implementations.

goocanvas.Canvas.update

update();

Updates any items that need updating. This is only intended to be used by subclasses of goocanvas.Canvas or goocanvas.Item implementation.

The "item-created" goocanvas.Canvas Signal

callback(canvas,
         item,
         model,
         user_param,
         ...);

The 'item-created" signal is emitted when the a new canvas item is created. Applications can set up signal handlers for the new items here.

The "set-scroll-adjustments" goocanvas.Canvas Signal

callback(canvas,
         hadjustment,
         vadjustment,
         user_param,
         ...);

The 'set-scroll-adjustments" signal is emitted when the GooCanvas is placed inside a gtk.ScrolledWindow, to connect up the adjustments so scrolling works properly. It isn't useful for applications.