## GooCanvas Types GooCanvas Types — types used in GooCanvas. |

## Synopsis

                        GooCanvasBounds;

    enum                GooCanvasItemVisibility;

    enum                GooCanvasPointerEvents;

    enum                GooCanvasAnimateType;

                        GooCanvasPoints;
    GooCanvasPoints*    goo_canvas_points_new               (int num_points);
    GooCanvasPoints*    goo_canvas_points_ref               (GooCanvasPoints *points);
    void                goo_canvas_points_unref             (GooCanvasPoints *points);

                        GooCanvasLineDash;
    GooCanvasLineDash*  goo_canvas_line_dash_new            (gint num_dashes,
                                                             ...);
    GooCanvasLineDash*  goo_canvas_line_dash_newv           (gint num_dashes,
                                                             double *dashes);
    GooCanvasLineDash*  goo_canvas_line_dash_ref            (GooCanvasLineDash *dash);
    void                goo_canvas_line_dash_unref          (GooCanvasLineDash *dash);

    enum                GooCanvasPathCommandType;
    union               GooCanvasPathCommand;
    GArray*             goo_canvas_parse_path_data          (const gchar *path_data);
    void                goo_canvas_create_path              (GArray *commands,
                                                             cairo_t *cr);

## Description

This section describes the types used throughout GooCanvas.

## Details

### GooCanvasBounds

    typedef struct {
      gdouble x1, y1, x2, y2;
    } GooCanvasBounds;

GooCanvasBounds represents the bounding box of an item in the canvas.

gdouble `x1`; | the left edge.
gdouble `y1`; | the top edge.
gdouble `x2`; | the right edge.
gdouble `y2`; | the bottom edge.

### enum GooCanvasItemVisibility

    typedef enum
    {
      GOO_CANVAS_ITEM_HIDDEN			= 0,
      GOO_CANVAS_ITEM_INVISIBLE			= 1,
      GOO_CANVAS_ITEM_VISIBLE			= 2,
      GOO_CANVAS_ITEM_VISIBLE_ABOVE_THRESHOLD	= 3,
    } GooCanvasItemVisibility;

The GooCanvasItemVisibility enumeration is used to specify when a canvas item is visible.

`GOO_CANVAS_ITEM_HIDDEN` | the item is invisible, and is not allocated any space in layout container items such as GooCanvasTable.
`GOO_CANVAS_ITEM_INVISIBLE` | the item is invisible, but it is still allocated space in layout container items.
`GOO_CANVAS_ITEM_VISIBLE` | the item is visible.
`GOO_CANVAS_ITEM_VISIBLE_ABOVE_THRESHOLD` | the item is visible when the canvas scale setting is greater than or equal to the item's visibility threshold setting.

### enum GooCanvasPointerEvents

    typedef enum
    {
      GOO_CANVAS_EVENTS_VISIBLE_MASK	= 1 << 0,
      GOO_CANVAS_EVENTS_PAINTED_MASK	= 1 << 1,
      GOO_CANVAS_EVENTS_FILL_MASK		= 1 << 2,
      GOO_CANVAS_EVENTS_STROKE_MASK		= 1 << 3,

      GOO_CANVAS_EVENTS_NONE		= 0,
      GOO_CANVAS_EVENTS_VISIBLE_PAINTED	= GOO_CANVAS_EVENTS_VISIBLE_MASK | GOO_CANVAS_EVENTS_PAINTED_MASK | GOO_CANVAS_EVENTS_FILL_MASK | GOO_CANVAS_EVENTS_STROKE_MASK,
      GOO_CANVAS_EVENTS_VISIBLE_FILL	= GOO_CANVAS_EVENTS_VISIBLE_MASK | GOO_CANVAS_EVENTS_FILL_MASK,
      GOO_CANVAS_EVENTS_VISIBLE_STROKE	= GOO_CANVAS_EVENTS_VISIBLE_MASK | GOO_CANVAS_EVENTS_STROKE_MASK,
      GOO_CANVAS_EVENTS_VISIBLE		= GOO_CANVAS_EVENTS_VISIBLE_MASK | GOO_CANVAS_EVENTS_FILL_MASK | GOO_CANVAS_EVENTS_STROKE_MASK,
      GOO_CANVAS_EVENTS_PAINTED		= GOO_CANVAS_EVENTS_PAINTED_MASK | GOO_CANVAS_EVENTS_FILL_MASK | GOO_CANVAS_EVENTS_STROKE_MASK,
      GOO_CANVAS_EVENTS_FILL		= GOO_CANVAS_EVENTS_FILL_MASK,
      GOO_CANVAS_EVENTS_STROKE		= GOO_CANVAS_EVENTS_STROKE_MASK,
      GOO_CANVAS_EVENTS_ALL			= GOO_CANVAS_EVENTS_FILL_MASK | GOO_CANVAS_EVENTS_STROKE_MASK
    } GooCanvasPointerEvents;

Specifies when an item receives pointer events such as mouse clicks.

`GOO_CANVAS_EVENTS_VISIBLE_MASK` | a mask indicating that the item only receives events when it is visible.
`GOO_CANVAS_EVENTS_PAINTED_MASK` | a mask indicating that the item only receives events when the specified parts of it are painted.
`GOO_CANVAS_EVENTS_FILL_MASK` | a mask indicating that the filled part of the item receives events.
`GOO_CANVAS_EVENTS_STROKE_MASK` | a mask indicating that the stroked part of the item receives events.
`GOO_CANVAS_EVENTS_NONE` | the item doesn't receive events at all.
`GOO_CANVAS_EVENTS_VISIBLE_PAINTED` | the item receives events in its painted areas when it is visible (the default).
`GOO_CANVAS_EVENTS_VISIBLE_FILL` | the item's interior receives events when it is visible.
`GOO_CANVAS_EVENTS_VISIBLE_STROKE` | the item's perimeter receives events when it is visible.
`GOO_CANVAS_EVENTS_VISIBLE` | the item receives events when it is visible, whether it is painted or not.
`GOO_CANVAS_EVENTS_PAINTED` | the item receives events in its painted areas, whether it is visible or not.
`GOO_CANVAS_EVENTS_FILL` | the item's interior receives events, whether it is visible or painted or not.
`GOO_CANVAS_EVENTS_STROKE` | the item's perimeter receives events, whether it is visible or painted or not.
`GOO_CANVAS_EVENTS_ALL` | the item's perimeter and interior receive events, whether it is visible or painted or not.

### enum GooCanvasAnimateType

    typedef enum
    {
      GOO_CANVAS_ANIMATE_FREEZE,
      GOO_CANVAS_ANIMATE_RESET,
      GOO_CANVAS_ANIMATE_RESTART,
      GOO_CANVAS_ANIMATE_BOUNCE
    } GooCanvasAnimateType;

GooCanvasAnimateType is used to specify what happens when the end of an animation is reached.

`GOO_CANVAS_ANIMATE_FREEZE` | the item remains in the final position.
`GOO_CANVAS_ANIMATE_RESET` | the item is moved back to the initial position.
`GOO_CANVAS_ANIMATE_RESTART` | the animation is restarted from the initial position.
`GOO_CANVAS_ANIMATE_BOUNCE` | the animation bounces back and forth between the start and end positions.

### GooCanvasPoints

    typedef struct {
      double *coords;
      int num_points;
      int ref_count;
    } GooCanvasPoints;

GooCairoPoints represents an array of points.

double *`coords`; | the coordinates of the points, in pairs.
int `num_points`; | the number of points.
int `ref_count`; | the reference count of the struct.

### goo_canvas_points_new ()

    GooCanvasPoints*    goo_canvas_points_new               (int num_points);

Creates a new GooCanvasPoints struct with space for the given number of points. It should be freed with `goo_canvas_points_unref()`.

`num_points` : | the number of points to create space for.
Returns : | a new GooCanvasPoints struct.

### goo_canvas_points_ref ()

    GooCanvasPoints*    goo_canvas_points_ref               (GooCanvasPoints *points);

Increments the reference count of the given GooCanvasPoints struct.

`points` : | a GooCanvasPoints struct.
Returns : | the GooCanvasPoints struct.

### goo_canvas_points_unref ()

    void                goo_canvas_points_unref             (GooCanvasPoints *points);

Decrements the reference count of the given GooCanvasPoints struct, freeing it if the reference count falls to zero.

`points` : | a GooCanvasPoints struct.

### GooCanvasLineDash

    typedef struct {
      int ref_count;
      int num_dashes;
      double *dashes;
      double dash_offset;
    } GooCanvasLineDash;

GooCanvasLineDash specifies a dash pattern to be used when drawing items.

int `ref_count`; | the reference count of the struct.
int `num_dashes`; | the number of dashes and gaps between them.
double *`dashes`; | the sizes of each dash and gap.
double `dash_offset`; | the start offset into the dash pattern.

### goo_canvas_line_dash_new ()

    GooCanvasLineDash*  goo_canvas_line_dash_new            (gint num_dashes,
                                                             ...);

Creates a new dash pattern.

`num_dashes` : | the number of dashes and gaps in the pattern.
`...` : | the length of each dash and gap.
Returns : | a new dash pattern.

### goo_canvas_line_dash_newv ()

    GooCanvasLineDash*  goo_canvas_line_dash_newv           (gint num_dashes,
                                                             double *dashes);

Creates a new dash pattern. Takes ownership of the `dashes` vector.

`num_dashes` : | the number of dashes and gaps in the pattern.
`dashes` : | a g_new-allocated vector of doubles, the length of each dash and gap.
Returns : | a new dash pattern.

### goo_canvas_line_dash_ref ()

    GooCanvasLineDash*  goo_canvas_line_dash_ref            (GooCanvasLineDash *dash);

Increments the reference count of the dash pattern.

`dash` : | a GooCanvasLineDash.
Returns : | the dash pattern.

### goo_canvas_line_dash_unref ()

    void                goo_canvas_line_dash_unref          (GooCanvasLineDash *dash);

Decrements the reference count of the dash pattern. If it falls to 0 it is freed.

`dash` : | a GooCanvasLineDash.

### enum GooCanvasPathCommandType

    typedef enum
    {
      /* Simple commands like moveto and lineto: MmZzLlHhVv. */
      GOO_CANVAS_PATH_MOVE_TO,
      GOO_CANVAS_PATH_CLOSE_PATH,
      GOO_CANVAS_PATH_LINE_TO,
      GOO_CANVAS_PATH_HORIZONTAL_LINE_TO,
      GOO_CANVAS_PATH_VERTICAL_LINE_TO,

      /* Bezier curve commands: CcSsQqTt. */
      GOO_CANVAS_PATH_CURVE_TO,
      GOO_CANVAS_PATH_SMOOTH_CURVE_TO,
      GOO_CANVAS_PATH_QUADRATIC_CURVE_TO,
      GOO_CANVAS_PATH_SMOOTH_QUADRATIC_CURVE_TO,

      /* The elliptical arc commands: Aa. */
      GOO_CANVAS_PATH_ELLIPTICAL_ARC
    } GooCanvasPathCommandType;

GooCanvasPathCommandType specifies the type of each command in the path. See the path element in the Scalable Vector Graphics (SVG) specification for more details.

`GOO_CANVAS_PATH_MOVE_TO` | move to the given point.
`GOO_CANVAS_PATH_CLOSE_PATH` | close the current path, drawing a line from the current position to the start of the path.
`GOO_CANVAS_PATH_LINE_TO` | draw a line to the given point.
`GOO_CANVAS_PATH_HORIZONTAL_LINE_TO` | draw a horizontal line to the given x coordinate.
`GOO_CANVAS_PATH_VERTICAL_LINE_TO` | draw a vertical line to the given y coordinate.
`GOO_CANVAS_PATH_CURVE_TO` | draw a bezier curve using two control points to the given point.
`GOO_CANVAS_PATH_SMOOTH_CURVE_TO` | draw a bezier curve using a reflection of the last control point of the last curve as the first control point, and one new control point, to the given point.
`GOO_CANVAS_PATH_QUADRATIC_CURVE_TO` | draw a quadratic bezier curve using a single control point to the given point.
`GOO_CANVAS_PATH_SMOOTH_QUADRATIC_CURVE_TO` | draw a quadratic bezier curve using a reflection of the control point from the previous curve as the control point, to the given point.
`GOO_CANVAS_PATH_ELLIPTICAL_ARC` | draw an elliptical arc, using the given 2 radii, the x axis rotation, and the 2 flags to disambiguate the arc, to the given point.

### union GooCanvasPathCommand

    union GooCanvasPathCommand
    {
      /* Simple commands like moveto and lineto: MmZzLlHhVv. */
      struct {
        guint type : 5; /* GooCanvasPathCommandType */
        guint relative : 1;
        gdouble x, y;
      } simple;

      /* Bezier curve commands: CcSsQqTt. */
      struct {
        guint type : 5; /* GooCanvasPathCommandType */
        guint relative : 1;
        gdouble x, y, x1, y1, x2, y2;
      } curve;

      /* The elliptical arc commands: Aa. */
      struct {
        guint type : 5; /* GooCanvasPathCommandType */
        guint relative : 1;
        guint large_arc_flag : 1;
        guint sweep_flag : 1;
        gdouble rx, ry, x_axis_rotation, x, y;
      } arc;
    };

GooCanvasPathCommand holds the data for each command in the path.

The `relative` flag specifies that the coordinates for the command are relative to the current point. Otherwise they are assumed to be absolute coordinates.

### goo_canvas_parse_path_data ()

    GArray*             goo_canvas_parse_path_data          (const gchar *path_data);

Parses the given SVG path specification string.

`path_data` : | the sequence of path commands, specified as a string using the same syntax as in the Scalable Vector Graphics (SVG) path element.
Returns : | a GArray of GooCanvasPathCommand elements.

### goo_canvas_create_path ()

    void                goo_canvas_create_path              (GArray *commands,
                                                             cairo_t *cr);

Creates the path specified by the given GooCanvasPathCommand array.

`commands` : | an array of GooCanvasPathCommand.
`cr` : | a cairo context.