gnome-canvas-path-def

struct GnomeCanvasPathDef

struct GnomeCanvasPathDef;

gnome_canvas_path_def_new ()

GnomeCanvasPathDef* gnome_canvas_path_def_new
                                            (void);

This function creates a new empty gnome_canvas_path_def.

gnome_canvas_path_def_new_sized ()

GnomeCanvasPathDef* gnome_canvas_path_def_new_sized
                                            (gint length);

This funtion creates a new gnome_canvas_path_def with length number of points allocated. It is useful, if you know the exact number of points in path, so you can avoid automatic point array reallocation.

gnome_canvas_path_def_new_from_bpath ()

GnomeCanvasPathDef* gnome_canvas_path_def_new_from_bpath
                                            (ArtBpath *bpath);

This function constructs a new gnome_canvas_path_def and uses the passed bpath as the contents. The passed bpath should not be static as the path definition is editable when constructed with this function. Also, passed bpath will be freed with art_free, if path is destroyed, so use it with caution. For constructing a gnome_canvas_path_def from (non-modifiable) bpath use gnome_canvas_path_def_new_from_static_bpath.

gnome_canvas_path_def_new_from_static_bpath ()

GnomeCanvasPathDef* gnome_canvas_path_def_new_from_static_bpath
                                            (ArtBpath *bpath);

This function constructs a new gnome_canvas_path_def and references the passed bpath as its contents. The gnome_canvas_path_def returned from this function is to be considered static and non-editable (meaning you cannot change the path from what you passed in bpath). The bpath will not be freed, if path will be destroyed, so use it with caution.

gnome_canvas_path_def_new_from_foreign_bpath ()

GnomeCanvasPathDef* gnome_canvas_path_def_new_from_foreign_bpath
                                            (ArtBpath *bpath);

This function constructs a new gnome_canvas_path_def and duplicates the contents of the passed bpath in the definition.

gnome_canvas_path_def_ref ()

void        gnome_canvas_path_def_ref       (GnomeCanvasPathDef *path);

Increment the reference count of the GnomeCanvasPathDef.

gnome_canvas_path_def_finish ()

void        gnome_canvas_path_def_finish    (GnomeCanvasPathDef *path);

Trims dynamic point array to exact length of path.

gnome_canvas_path_def_ensure_space ()

void        gnome_canvas_path_def_ensure_space
                                            (GnomeCanvasPathDef *path,
                                             gint space);

This function ensures that enough space for space points is allocated at the end of the path.

gnome_canvas_path_def_copy ()

void        gnome_canvas_path_def_copy      (GnomeCanvasPathDef *dst,
                                             const GnomeCanvasPathDef *src);

This function copies the contents src to dest. The old dest path array is freed and dest is marked as non-static (editable), regardless of the status of src.

gnome_canvas_path_def_duplicate ()

GnomeCanvasPathDef* gnome_canvas_path_def_duplicate
                                            (const GnomeCanvasPathDef *path);

This function duplicates the passed path. The new path is marked as non-static regardless of the state of original.

gnome_canvas_path_def_concat ()

GnomeCanvasPathDef* gnome_canvas_path_def_concat
                                            (const GSList *list);

This function concatenates a list of GnomeCanvasPathDefs into one newly created GnomeCanvasPathDef.

gnome_canvas_path_def_split ()

GSList*     gnome_canvas_path_def_split     (const GnomeCanvasPathDef *path);

This function splits the passed path into a list of GnomeCanvasPathDefs which represent each segment of the origional path. The path is split when ever an ART_MOVETO or ART_MOVETO_OPEN is encountered. The closedness of resulting paths is set accordingly to closedness of corresponding segment.

gnome_canvas_path_def_open_parts ()

GnomeCanvasPathDef* gnome_canvas_path_def_open_parts
                                            (const GnomeCanvasPathDef *path);

This function creates a new GnomeCanvasPathDef that contains all of the open segments on the passed path.

gnome_canvas_path_def_closed_parts ()

GnomeCanvasPathDef* gnome_canvas_path_def_closed_parts
                                            (const GnomeCanvasPathDef *path);

This function returns a new GnomeCanvasPathDef that contains the all of close parts of passed path.

gnome_canvas_path_def_close_all ()

GnomeCanvasPathDef* gnome_canvas_path_def_close_all
                                            (const GnomeCanvasPathDef *path);

This function closes all of the open segments in the passed path and returns a new GnomeCanvasPathDef.

gnome_canvas_path_def_unref ()

void        gnome_canvas_path_def_unref     (GnomeCanvasPathDef *path);

Decrease the reference count of the passed path. If the reference count is < 1 the path is deallocated.

gnome_canvas_path_def_reset ()

void        gnome_canvas_path_def_reset     (GnomeCanvasPathDef *path);

This function clears the contents of the passed path.

gnome_canvas_path_def_moveto ()

void        gnome_canvas_path_def_moveto    (GnomeCanvasPathDef *path,
                                             gdouble x,
                                             gdouble y);

This function adds starts new subpath on path, and sets its starting point to x and y. If current subpath is empty, it simply changes its starting coordinates to new values.

gnome_canvas_path_def_lineto ()

void        gnome_canvas_path_def_lineto    (GnomeCanvasPathDef *path,
                                             gdouble x,
                                             gdouble y);

This function add a line segment to the passed path with the specified x and y coordinates.

gnome_canvas_path_def_lineto_moving ()

void        gnome_canvas_path_def_lineto_moving
                                            (GnomeCanvasPathDef *path,
                                             gdouble x,
                                             gdouble y);

This functions adds a new line segment with loose endpoint to the path, or if endpoint is already loose, changes its coordinates to x, y. You can change the coordinates of loose endpoint as many times as you want, the last ones set will be fixed, if you continue line. This is useful for handling drawing with mouse.

gnome_canvas_path_def_curveto ()

void        gnome_canvas_path_def_curveto   (GnomeCanvasPathDef *path,
                                             gdouble x0,
                                             gdouble y0,
                                             gdouble x1,
                                             gdouble y1,
                                             gdouble x2,
                                             gdouble y2);

This function adds a bezier curve segment to the path definition.

gnome_canvas_path_def_closepath ()

void        gnome_canvas_path_def_closepath (GnomeCanvasPathDef *path);

This function closes the last subpath of path, adding a ART_LINETO to subpath starting point, if needed and changing starting pathcode to ART_MOVETO

gnome_canvas_path_def_closepath_current ()

void        gnome_canvas_path_def_closepath_current
                                            (GnomeCanvasPathDef *path);

This function closes the last subpath by setting the coordinates of the endpoint of the last segment (line or curve) to starting point.

gnome_canvas_path_def_bpath ()

ArtBpath*   gnome_canvas_path_def_bpath     (const GnomeCanvasPathDef *path);

This function returns a ArtBpath that consists of the path definition.

gnome_canvas_path_def_length ()

gint        gnome_canvas_path_def_length    (const GnomeCanvasPathDef *path);

This function returns the length of the path definition. Not Euclidian length of the path but rather the number of points on the path.

gnome_canvas_path_def_is_empty ()

gboolean    gnome_canvas_path_def_is_empty  (const GnomeCanvasPathDef *path);

This function is a boolean test to see if the path is empty, meaning containing no line segments.

gnome_canvas_path_def_has_currentpoint ()

gboolean    gnome_canvas_path_def_has_currentpoint
                                            (const GnomeCanvasPathDef *path);

This function is a boolean test checking to see if the path has a current point defined. Current point will be set by line operators, and cleared by closing subpath.

gnome_canvas_path_def_currentpoint ()

void        gnome_canvas_path_def_currentpoint
                                            (const GnomeCanvasPathDef *path,
                                             ArtPoint *p);

Stores the current point of the path definition in the passed ArtPoint p.

gnome_canvas_path_def_last_bpath ()

ArtBpath*   gnome_canvas_path_def_last_bpath
                                            (const GnomeCanvasPathDef *path);

This function returns pointer to the last ArtBpath segment in the path definition.

gnome_canvas_path_def_first_bpath ()

ArtBpath*   gnome_canvas_path_def_first_bpath
                                            (const GnomeCanvasPathDef *path);

This function returns the first ArtBpath point in the definition.

gnome_canvas_path_def_any_open ()

gboolean    gnome_canvas_path_def_any_open  (const GnomeCanvasPathDef *path);

This function returns a boolean value indicating if the path has any open segments.

gnome_canvas_path_def_all_open ()

gboolean    gnome_canvas_path_def_all_open  (const GnomeCanvasPathDef *path);

This function returns a boolean value indicating if the path only contains open segments.

gnome_canvas_path_def_any_closed ()

gboolean    gnome_canvas_path_def_any_closed
                                            (const GnomeCanvasPathDef *path);

This function returns a boolean valid indicating if the path has any closed segements.

gnome_canvas_path_def_all_closed ()

gboolean    gnome_canvas_path_def_all_closed
                                            (const GnomeCanvasPathDef *path);

This function returns a boolean value indicating if the path only contains closed segments.