# GnomeCanvas

## Name

GnomeCanvas --

## Synopsis

    #include <libgnomecanvas/libgnomecanvas.h>

    struct      GnomeCanvas;
    typedef     GnomeCanvasBuf;

    GtkWidget*  gnome_canvas_new                (void);
    GtkWidget*  gnome_canvas_new_aa             (void);
    GnomeCanvasGroup* gnome_canvas_root         (GnomeCanvas *canvas);
    void        gnome_canvas_set_scroll_region  (GnomeCanvas *canvas,
                                                 double x1,
                                                 double y1,
                                                 double x2,
                                                 double y2);
    void        gnome_canvas_get_scroll_region  (GnomeCanvas *canvas,
                                                 double *x1,
                                                 double *y1,
                                                 double *x2,
                                                 double *y2);
    void        gnome_canvas_set_center_scroll_region
                                                (GnomeCanvas *canvas,
                                                 gboolean center_scroll_region);
    gboolean    gnome_canvas_get_center_scroll_region
                                                (GnomeCanvas *canvas);
    void        gnome_canvas_set_pixels_per_unit
                                                (GnomeCanvas *canvas,
                                                 double n);
    void        gnome_canvas_scroll_to          (GnomeCanvas *canvas,
                                                 int cx,
                                                 int cy);
    void        gnome_canvas_get_scroll_offsets (GnomeCanvas *canvas,
                                                 int *cx,
                                                 int *cy);
    void        gnome_canvas_update_now         (GnomeCanvas *canvas);
    GnomeCanvasItem* gnome_canvas_get_item_at   (GnomeCanvas *canvas,
                                                 double x,
                                                 double y);
    void        gnome_canvas_request_redraw_uta (GnomeCanvas *canvas,
                                                 ArtUta *uta);
    void        gnome_canvas_request_redraw     (GnomeCanvas *canvas,
                                                 int x1,
                                                 int y1,
                                                 int x2,
                                                 int y2);
    void        gnome_canvas_w2c_affine         (GnomeCanvas *canvas,
                                                 double affine[6]);
    void        gnome_canvas_w2c                (GnomeCanvas *canvas,
                                                 double wx,
                                                 double wy,
                                                 int *cx,
                                                 int *cy);
    void        gnome_canvas_w2c_d              (GnomeCanvas *canvas,
                                                 double wx,
                                                 double wy,
                                                 double *cx,
                                                 double *cy);
    void        gnome_canvas_c2w                (GnomeCanvas *canvas,
                                                 int cx,
                                                 int cy,
                                                 double *wx,
                                                 double *wy);
    void        gnome_canvas_window_to_world    (GnomeCanvas *canvas,
                                                 double winx,
                                                 double winy,
                                                 double *worldx,
                                                 double *worldy);
    void        gnome_canvas_world_to_window    (GnomeCanvas *canvas,
                                                 double worldx,
                                                 double worldy,
                                                 double *winx,
                                                 double *winy);
    int         gnome_canvas_get_color          (GnomeCanvas *canvas,
                                                 const char *spec,
                                                 GdkColor *color);
    gulong      gnome_canvas_get_color_pixel    (GnomeCanvas *canvas,
                                                 guint rgba);
    void        gnome_canvas_set_stipple_origin (GnomeCanvas *canvas,
                                                 GdkGC *gc);
    void        gnome_canvas_set_dither         (GnomeCanvas *canvas,
                                                 GdkRgbDither dither);
    GdkRgbDither gnome_canvas_get_dither        (GnomeCanvas *canvas);

## Description

## Details

### struct GnomeCanvas

    struct GnomeCanvas {

    	GtkLayout layout;

    	/* Root canvas group */
    	GnomeCanvasItem *root;

    	/* Area that needs redrawing, stored as a microtile array */
    	ArtUta *redraw_area;

    	/* The item containing the mouse pointer, or NULL if none */
    	GnomeCanvasItem *current_item;

    	/* Item that is about to become current (used to track deletions and such) */
    	GnomeCanvasItem *new_current_item;

    	/* Item that holds a pointer grab, or NULL if none */
    	GnomeCanvasItem *grabbed_item;

    	/* If non-NULL, the currently focused item */
    	GnomeCanvasItem *focused_item;

    	/* GC for temporary draw pixmap */
    	GdkGC *pixmap_gc;

    	/* Event on which selection of current item is based */
    	GdkEvent pick_event;

    	/* Scrolling region */
    	double scroll_x1, scroll_y1;
    	double scroll_x2, scroll_y2;

    	/* Scaling factor to be used for display */
    	double pixels_per_unit;

    	/* Idle handler ID */
    	guint idle_id;

    	/* Signal handler ID for destruction of the root item */
    	guint root_destroy_id;

    	/* Area that is being redrawn.  Contains (x1, y1) but not (x2, y2).
    	 * Specified in canvas pixel coordinates.
    	 */
    	int redraw_x1, redraw_y1;
    	int redraw_x2, redraw_y2;

    	/* Offsets of the temprary drawing pixmap */
    	int draw_xofs, draw_yofs;

    	/* Internal pixel offsets when zoomed out */
    	int zoom_xofs, zoom_yofs;

    	/* Last known modifier state, for deferred repick when a button is down */
    	int state;

    	/* Event mask specified when grabbing an item */
    	guint grabbed_event_mask;

    	/* Tolerance distance for picking items */
    	int close_enough;

    	/* Whether the canvas should center the scroll region in the middle of
    	 * the window if the scroll region is smaller than the window.
    	 */
    	unsigned int center_scroll_region : 1;

    	/* Whether items need update at next idle loop iteration */
    	unsigned int need_update : 1;

    	/* Whether the canvas needs redrawing at the next idle loop iteration */
    	unsigned int need_redraw : 1;

    	/* Whether current item will be repicked at next idle loop iteration */
    	unsigned int need_repick : 1;

    	/* For use by internal pick_current_item() function */
    	unsigned int left_grabbed_item : 1;

    	/* For use by internal pick_current_item() function */
    	unsigned int in_repick : 1;

    	/* Whether the canvas is in antialiased mode or not */
    	unsigned int aa : 1;

    	/* Which dither mode to use for antialiased mode drawing */
    	GdkRgbDither dither;
    };

### GnomeCanvasBuf

    typedef struct {
    	/* 24-bit RGB buffer for rendering */
    	guchar *buf;

    	/* Rectangle describing the rendering area */
    	ArtIRect rect;

    	/* Rowstride for the buffer */
    	int buf_rowstride;

    	/* Background color, given as 0xrrggbb */
    	guint32 bg_color;

    	/* Invariant: at least one of the following flags is true. */

    	/* Set when the render rectangle area is the solid color bg_color */
    	unsigned int is_bg : 1;

    	/* Set when the render rectangle area is represented by the buf */
    	unsigned int is_buf : 1;
    } GnomeCanvasBuf;

### gnome_canvas_new ()

    GtkWidget*  gnome_canvas_new                (void);

Creates a new empty canvas in non-antialiased mode. If you wish to use the &GnomeCanvasImage item inside this canvas, then you must push the gdk_imlib visual and colormap before calling this function, and they can be popped afterwards.

Returns : | A newly-created canvas.

### gnome_canvas_new_aa ()

    GtkWidget*  gnome_canvas_new_aa             (void);

Creates a new empty canvas in antialiased mode. You should push the GdkRGB visual and colormap before calling this functions, and they can be popped afterwards.

Returns : | A newly-created antialiased canvas.

### gnome_canvas_root ()

    GnomeCanvasGroup* gnome_canvas_root         (GnomeCanvas *canvas);

Queries the root group of a canvas.

`canvas` : | A canvas.
Returns : | The root group of the specified canvas.

### gnome_canvas_set_scroll_region ()

    void        gnome_canvas_set_scroll_region  (GnomeCanvas *canvas,
                                                 double x1,
                                                 double y1,
                                                 double x2,
                                                 double y2);

Sets the scrolling region of a canvas to the specified rectangle. The canvas will then be able to scroll only within this region. The view of the canvas is adjusted as appropriate to display as much of the new region as possible.

`canvas` : | A canvas.
`x1` : | Leftmost limit of the scrolling region.
`y1` : | Upper limit of the scrolling region.
`x2` : | Rightmost limit of the scrolling region.
`y2` : | Lower limit of the scrolling region.

### gnome_canvas_get_scroll_region ()

    void        gnome_canvas_get_scroll_region  (GnomeCanvas *canvas,
                                                 double *x1,
                                                 double *y1,
                                                 double *x2,
                                                 double *y2);

Queries the scrolling region of a canvas.

`canvas` : | A canvas.
`x1` : | Leftmost limit of the scrolling region (return value).
`y1` : | Upper limit of the scrolling region (return value).
`x2` : | Rightmost limit of the scrolling region (return value).
`y2` : | Lower limit of the scrolling region (return value).

### gnome_canvas_set_center_scroll_region ()

    void        gnome_canvas_set_center_scroll_region
                                                (GnomeCanvas *canvas,
                                                 gboolean center_scroll_region);

When the scrolling region of the canvas is smaller than the canvas window, e.g. the allocation of the canvas, it can be either centered on the window or simply made to be on the upper-left corner on the window. This function lets you configure this property.

`canvas` : | A canvas.
`center_scroll_region` : | Whether to center the scrolling region in the canvas window when it is smaller than the canvas' allocation.

### gnome_canvas_get_center_scroll_region ()

    gboolean    gnome_canvas_get_center_scroll_region
                                                (GnomeCanvas *canvas);

Returns whether the canvas is set to center the scrolling region in the window if the former is smaller than the canvas' allocation.

`canvas` : | A canvas.
Returns : | Whether the scroll region is being centered in the canvas window.

### gnome_canvas_set_pixels_per_unit ()

    void        gnome_canvas_set_pixels_per_unit
                                                (GnomeCanvas *canvas,
                                                 double n);

Sets the zooming factor of a canvas by specifying the number of pixels that correspond to one canvas unit.

The anchor point for zooming, i.e. the point that stays fixed and all others zoom inwards or outwards from it, depends on whether the canvas is set to center the scrolling region or not. You can control this using the gnome_canvas_set_center_scroll_region() function. If the canvas is set to center the scroll region, then the center of the canvas window is used as the anchor point for zooming. Otherwise, the upper-left corner of the canvas window is used as the anchor point.

`canvas` : | A canvas.
`n` : | The number of pixels that correspond to one canvas unit.

### gnome_canvas_scroll_to ()

    void        gnome_canvas_scroll_to          (GnomeCanvas *canvas,
                                                 int cx,
                                                 int cy);

Makes a canvas scroll to the specified offsets, given in canvas pixel units. The canvas will adjust the view so that it is not outside the scrolling region. This function is typically not used, as it is better to hook scrollbars to the canvas layout's scrolling adjusments.

`canvas` : | A canvas.
`cx` : | Horizontal scrolling offset in canvas pixel units.
`cy` : | Vertical scrolling offset in canvas pixel units.

### gnome_canvas_get_scroll_offsets ()

    void        gnome_canvas_get_scroll_offsets (GnomeCanvas *canvas,
                                                 int *cx,
                                                 int *cy);

Queries the scrolling offsets of a canvas. The values are returned in canvas pixel units.

`canvas` : | A canvas.
`cx` : | Horizontal scrolling offset (return value).
`cy` : | Vertical scrolling offset (return value).

### gnome_canvas_update_now ()

    void        gnome_canvas_update_now         (GnomeCanvas *canvas);

Forces an immediate update and redraw of a canvas. If the canvas does not have any pending update or redraw requests, then no action is taken. This is typically only used by applications that need explicit control of when the display is updated, like games. It is not needed by normal applications.

`canvas` : | A canvas.

### gnome_canvas_get_item_at ()

    GnomeCanvasItem* gnome_canvas_get_item_at   (GnomeCanvas *canvas,
                                                 double x,
                                                 double y);

Looks for the item that is under the specified position, which must be specified in world coordinates.

`canvas` : | A canvas.
`x` : | X position in world coordinates.
`y` : | Y position in world coordinates.
Returns : | The sought item, or NULL if no item is at the specified coordinates.

### gnome_canvas_request_redraw_uta ()

    void        gnome_canvas_request_redraw_uta (GnomeCanvas *canvas,
                                                 ArtUta *uta);

Informs a canvas that the specified area, given as a microtile array, needs to be repainted. To be used only by item implementations.

`canvas` : | A canvas.
`uta` : | Microtile array that specifies the area to be redrawn. It will be freed by this function, so the argument you pass will be invalid after you call this function.

### gnome_canvas_request_redraw ()

    void        gnome_canvas_request_redraw     (GnomeCanvas *canvas,
                                                 int x1,
                                                 int y1,
                                                 int x2,
                                                 int y2);

Convenience function that informs a canvas that the specified rectangle needs to be repainted. This function converts the rectangle to a microtile array and feeds it to gnome_canvas_request_redraw_uta(). The rectangle includes `x1` and `y1`, but not `x2` and `y2`. To be used only by item implementations.

`canvas` : | A canvas.
`x1` : | Leftmost coordinate of the rectangle to be redrawn.
`y1` : | Upper coordinate of the rectangle to be redrawn.
`x2` : | Rightmost coordinate of the rectangle to be redrawn, plus 1.
`y2` : | Lower coordinate of the rectangle to be redrawn, plus 1.

### gnome_canvas_w2c_affine ()

    void        gnome_canvas_w2c_affine         (GnomeCanvas *canvas,
                                                 double affine[6]);

Gets the affine transform that converts from world coordinates to canvas pixel coordinates.

`canvas` : | A canvas.
`affine` : | An affine transformation matrix (return value).

### gnome_canvas_w2c ()

    void        gnome_canvas_w2c                (GnomeCanvas *canvas,
                                                 double wx,
                                                 double wy,
                                                 int *cx,
                                                 int *cy);

Converts world coordinates into canvas pixel coordinates.

`canvas` : | A canvas.
`wx` : | World X coordinate.
`wy` : | World Y coordinate.
`cx` : | X pixel coordinate (return value).
`cy` : | Y pixel coordinate (return value).

### gnome_canvas_w2c_d ()

    void        gnome_canvas_w2c_d              (GnomeCanvas *canvas,
                                                 double wx,
                                                 double wy,
                                                 double *cx,
                                                 double *cy);

Converts world coordinates into canvas pixel coordinates. This version

`canvas` : | A canvas.
`wx` : | World X coordinate.
`wy` : | World Y coordinate.
`cx` : | X pixel coordinate (return value).
`cy` : | Y pixel coordinate (return value).

### gnome_canvas_c2w ()

    void        gnome_canvas_c2w                (GnomeCanvas *canvas,
                                                 int cx,
                                                 int cy,
                                                 double *wx,
                                                 double *wy);

Converts canvas pixel coordinates to world coordinates.

`canvas` : | A canvas.
`cx` : | Canvas pixel X coordinate.
`cy` : | Canvas pixel Y coordinate.
`wx` : | X world coordinate (return value).
`wy` : | Y world coordinate (return value).

### gnome_canvas_window_to_world ()

    void        gnome_canvas_window_to_world    (GnomeCanvas *canvas,
                                                 double winx,
                                                 double winy,
                                                 double *worldx,
                                                 double *worldy);

Converts window-relative coordinates into world coordinates. You can use this when you need to convert mouse coordinates into world coordinates, for example.

`canvas` : | A canvas.
`winx` : | Window-relative X coordinate.
`winy` : | Window-relative Y coordinate.
`worldx` : | X world coordinate (return value).
`worldy` : | Y world coordinate (return value).

### gnome_canvas_world_to_window ()

    void        gnome_canvas_world_to_window    (GnomeCanvas *canvas,
                                                 double worldx,
                                                 double worldy,
                                                 double *winx,
                                                 double *winy);

Converts world coordinates into window-relative coordinates.

`canvas` : | A canvas.
`worldx` : | World X coordinate.
`worldy` : | World Y coordinate.
`winx` : | X window-relative coordinate.
`winy` : | Y window-relative coordinate.

### gnome_canvas_get_color ()

    int         gnome_canvas_get_color          (GnomeCanvas *canvas,
                                                 const char *spec,
                                                 GdkColor *color);

Allocates a color based on the specified X color specification. As a convenience to item implementations, it returns TRUE if the color was allocated, or FALSE if the specification was NULL. A NULL color specification is considered as "transparent" by the canvas.

`canvas` : | A canvas.
`spec` : | X color specification, or NULL for "transparent".
`color` : | Returns the allocated color.
Returns : | TRUE if `spec` is non-NULL and the color is allocated. If `spec` is NULL, then returns FALSE.

### gnome_canvas_get_color_pixel ()

    gulong      gnome_canvas_get_color_pixel    (GnomeCanvas *canvas,
                                                 guint rgba);

Allocates a color from the RGBA value passed into this function. The alpha opacity value is discarded, since normal X colors do not support it.

`canvas` : | A canvas.
`rgba` : | RGBA color specification.
Returns : | Allocated pixel value corresponding to the specified color.

### gnome_canvas_set_stipple_origin ()

    void        gnome_canvas_set_stipple_origin (GnomeCanvas *canvas,
                                                 GdkGC *gc);

Sets the stipple origin of the specified GC as is appropriate for the canvas, so that it will be aligned with other stipple patterns used by canvas items. This is typically only needed by item implementations.

`canvas` : | A canvas.
`gc` : | GC on which to set the stipple origin.

### gnome_canvas_set_dither ()

    void        gnome_canvas_set_dither         (GnomeCanvas *canvas,
                                                 GdkRgbDither dither);

Controls dithered rendering for antialiased canvases. The value of dither should be GDK_RGB_DITHER_NONE, GDK_RGB_DITHER_NORMAL, or GDK_RGB_DITHER_MAX. The default canvas setting is GDK_RGB_DITHER_NORMAL.

`canvas` : | A canvas.
`dither` : | Type of dithering used to render an antialiased canvas.

### gnome_canvas_get_dither ()

    GdkRgbDither gnome_canvas_get_dither        (GnomeCanvas *canvas);

Returns the type of dithering used to render an antialiased canvas.

`canvas` : | A canvas.
Returns : | The dither setting.