goocanvas 0.90.6-x86-mingw32

data/vendor/local/include/goocanvas-1.0.0/goocanvas/goocanvasitemmodel.h

@@ -0,0 +1,275 @@
+/*
+ * GooCanvas. Copyright (C) 2005 Damon Chaplin.
+ * Released under the GNU LGPL license. See COPYING for details.
+ *
+ * goocanvasitemmodel.h - interface for canvas item models.
+ */
+#ifndef __GOO_CANVAS_ITEM_MODEL_H__
+#define __GOO_CANVAS_ITEM_MODEL_H__
+
+#include <gtk/gtk.h>
+#include "goocanvasitem.h"
+
+G_BEGIN_DECLS
+
+
+#define GOO_TYPE_CANVAS_ITEM_MODEL            (goo_canvas_item_model_get_type ())
+#define GOO_CANVAS_ITEM_MODEL(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GOO_TYPE_CANVAS_ITEM_MODEL, GooCanvasItemModel))
+#define GOO_IS_CANVAS_ITEM_MODEL(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GOO_TYPE_CANVAS_ITEM_MODEL))
+#define GOO_CANVAS_ITEM_MODEL_GET_IFACE(obj)  (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GOO_TYPE_CANVAS_ITEM_MODEL, GooCanvasItemModelIface))
+
+
+/**
+ * GooCanvasItemModel
+ *
+ * #GooCanvasItemModel is a typedef used for objects that implement the
+ * #GooCanvasItemModel interface.
+ *
+ * (There is no actual #GooCanvasItemModel struct, since it is only an interface.
+ * But using '#GooCanvasItemModel' is more helpful than using '#GObject'.)
+ */
+/* The typedef is in goocanvasitem.h */
+/*typedef struct _GooCanvasItemModel       GooCanvasItemModel;*/
+
+
+/**
+ * GooCanvasItemModelIface
+ * @get_n_children: returns the number of children of the model.
+ * @get_child: returns the child at the given index.
+ * @add_child: adds a child.
+ * @move_child: moves a child up or down the stacking order.
+ * @remove_child: removes a child.
+ * @get_child_property: gets a child property of a given child model,
+ *  e.g. the "row" or "column" property of a model in a #GooCanvasTableModel.
+ * @set_child_property: sets a child property for a given child model.
+ * @get_parent: gets the model's parent.
+ * @set_parent: sets the model's parent.
+ * @create_item: creates a default canvas item to view the model.
+ * @get_transform: gets the model's transformation matrix.
+ * @set_transform: sets the model's transformation matrix.
+ * @get_style: gets the model's style.
+ * @set_style: sets the model's style.
+ * @child_added: signal emitted when a child is added.
+ * @child_moved: signal emitted when a child is moved in the stacking order.
+ * @child_removed: signal emitted when a child is removed.
+ * @changed: signal emitted when the model has changed.
+ * @child_notify: signal emitted when a child property has changed.
+ * @animation_finished: signal emitted when the model's animation has finished.
+ *
+ * #GooCanvasItemModelIFace holds the virtual methods that make up the
+ * #GooCanvasItemModel interface.
+ *
+ * Simple item models only need to implement the get_parent(), set_parent()
+ * and create_item() methods.
+ *
+ * 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_n_children() and get_child().
+ * 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() and set_child_property().
+ */
+typedef struct _GooCanvasItemModelIface  GooCanvasItemModelIface;
+
+struct _GooCanvasItemModelIface
+{
+  /*< private >*/
+  GTypeInterface base_iface;
+
+  /*< public >*/
+  /* Virtual methods that group models must implement. */
+  gint		       (* get_n_children)		(GooCanvasItemModel	*model);
+  GooCanvasItemModel*  (* get_child)			(GooCanvasItemModel	*model,
+							 gint			 child_num);
+
+  /* Virtual methods that group models may implement. */
+  void                 (* add_child)			(GooCanvasItemModel	*model,
+							 GooCanvasItemModel	*child,
+							 gint			 position);
+  void                 (* move_child)			(GooCanvasItemModel	*model,
+							 gint			 old_position,
+							 gint			 new_position);
+  void                 (* remove_child)			(GooCanvasItemModel	*model,
+							 gint			 child_num);
+  void                 (* get_child_property)		(GooCanvasItemModel	*model,
+							 GooCanvasItemModel	*child,
+							 guint			 property_id,
+							 GValue			*value,
+							 GParamSpec		*pspec);
+  void                 (* set_child_property)		(GooCanvasItemModel	*item,
+							 GooCanvasItemModel	*child,
+							 guint			 property_id,
+							 const GValue		*value,
+							 GParamSpec		*pspec);
+
+  /* Virtual methods that all item models must implement. */
+  GooCanvasItemModel*  (* get_parent)			(GooCanvasItemModel	*model);
+  void                 (* set_parent)			(GooCanvasItemModel	*model,
+							 GooCanvasItemModel	*parent);
+
+  GooCanvasItem*       (* create_item)			(GooCanvasItemModel	*model,
+							 GooCanvas		*canvas);
+
+  /* Virtual methods that all item models may implement. */
+  gboolean             (* get_transform)		(GooCanvasItemModel	*model,
+							 cairo_matrix_t         *transform);
+  void                 (* set_transform)		(GooCanvasItemModel	*model,
+							 const cairo_matrix_t	*transform);
+  GooCanvasStyle*      (* get_style)			(GooCanvasItemModel	*model);
+  void                 (* set_style)			(GooCanvasItemModel	*model,
+							 GooCanvasStyle		*style);
+
+  /* Signals. */
+  void                 (* child_added)			(GooCanvasItemModel	*model,
+							 gint			 child_num);
+  void                 (* child_moved)			(GooCanvasItemModel	*model,
+							 gint			 old_child_num,
+							 gint			 new_child_num);
+  void                 (* child_removed)		(GooCanvasItemModel	*model,
+							 gint			 child_num);
+  void                 (* changed)			(GooCanvasItemModel	*model,
+							 gboolean		 recompute_bounds);
+  void                 (* child_notify)			(GooCanvasItemModel	*model,
+							 GParamSpec		*pspec);
+
+  void		       (* animation_finished)		(GooCanvasItemModel     *model,
+							 gboolean                stopped);
+
+  /*< private >*/
+
+  /* Padding for future expansion */
+  void (*_goo_canvas_reserved1) (void);
+  void (*_goo_canvas_reserved2) (void);
+  void (*_goo_canvas_reserved3) (void);
+  void (*_goo_canvas_reserved4) (void);
+  void (*_goo_canvas_reserved5) (void);
+  void (*_goo_canvas_reserved6) (void);
+  void (*_goo_canvas_reserved7) (void);
+};
+
+
+GType               goo_canvas_item_model_get_type       (void) G_GNUC_CONST;
+
+
+/*
+ * Group functions - these should only be called on container models.
+ */
+gint                goo_canvas_item_model_get_n_children (GooCanvasItemModel *model);
+GooCanvasItemModel* goo_canvas_item_model_get_child      (GooCanvasItemModel *model,
+							  gint                child_num);
+void                goo_canvas_item_model_add_child      (GooCanvasItemModel *model,
+							  GooCanvasItemModel *child,
+							  gint                position);
+void                goo_canvas_item_model_move_child     (GooCanvasItemModel *model,
+							  gint                old_position,
+							  gint                new_position);
+void                goo_canvas_item_model_remove_child   (GooCanvasItemModel *model,
+							  gint                child_num);
+gint                goo_canvas_item_model_find_child     (GooCanvasItemModel *model,
+							  GooCanvasItemModel *child);
+
+void     goo_canvas_item_model_get_child_property	 (GooCanvasItemModel   *model,
+							  GooCanvasItemModel   *child,
+							  const gchar          *property_name,
+							  GValue               *value);
+void     goo_canvas_item_model_set_child_property	 (GooCanvasItemModel   *model,
+							  GooCanvasItemModel   *child,
+							  const gchar          *property_name,
+							  const GValue         *value);
+void     goo_canvas_item_model_get_child_properties	 (GooCanvasItemModel   *model,
+							  GooCanvasItemModel   *child,
+							  ...) G_GNUC_NULL_TERMINATED;
+void     goo_canvas_item_model_set_child_properties	 (GooCanvasItemModel   *model,
+							  GooCanvasItemModel   *child,
+							  ...) G_GNUC_NULL_TERMINATED;
+void     goo_canvas_item_model_get_child_properties_valist (GooCanvasItemModel   *model,
+							    GooCanvasItemModel   *child,
+							    va_list	         var_args);
+void     goo_canvas_item_model_set_child_properties_valist (GooCanvasItemModel   *model,
+							    GooCanvasItemModel   *child,
+							    va_list	         var_args);
+
+
+/*
+ * Model functions - these are safe to call on all models.
+ */
+GooCanvasItemModel* goo_canvas_item_model_get_parent     (GooCanvasItemModel *model);
+void                goo_canvas_item_model_set_parent	 (GooCanvasItemModel *model,
+							  GooCanvasItemModel *parent);
+void                goo_canvas_item_model_remove         (GooCanvasItemModel *model);
+gboolean            goo_canvas_item_model_is_container   (GooCanvasItemModel *model);
+
+void                goo_canvas_item_model_raise          (GooCanvasItemModel *model,
+							  GooCanvasItemModel *above);
+void                goo_canvas_item_model_lower          (GooCanvasItemModel *model,
+							  GooCanvasItemModel *below);
+
+gboolean            goo_canvas_item_model_get_transform  (GooCanvasItemModel *model,
+							  cairo_matrix_t     *transform);
+void                goo_canvas_item_model_set_transform  (GooCanvasItemModel   *model,
+							  const cairo_matrix_t *transform);
+gboolean	    goo_canvas_item_model_get_simple_transform (GooCanvasItemModel *model,
+								gdouble            *x,
+								gdouble            *y,
+								gdouble            *scale,
+								gdouble            *rotation);
+void                goo_canvas_item_model_set_simple_transform (GooCanvasItemModel *model,
+								gdouble             x,
+								gdouble             y,
+								gdouble             scale,
+								gdouble             rotation);
+
+void                goo_canvas_item_model_translate      (GooCanvasItemModel *model,
+							  gdouble             tx,
+							  gdouble             ty);
+void                goo_canvas_item_model_scale          (GooCanvasItemModel *model,
+							  gdouble             sx,
+							  gdouble             sy);
+void                goo_canvas_item_model_rotate         (GooCanvasItemModel *model,
+							  gdouble             degrees,
+							  gdouble             cx,
+							  gdouble             cy);
+void                goo_canvas_item_model_skew_x         (GooCanvasItemModel *model,
+							  gdouble             degrees,
+							  gdouble             cx,
+							  gdouble             cy);
+void                goo_canvas_item_model_skew_y         (GooCanvasItemModel *model,
+							  gdouble             degrees,
+							  gdouble             cx,
+							  gdouble             cy);
+
+GooCanvasStyle*     goo_canvas_item_model_get_style      (GooCanvasItemModel *model);
+void                goo_canvas_item_model_set_style      (GooCanvasItemModel *model,
+							  GooCanvasStyle  *style);
+
+void                goo_canvas_item_model_animate        (GooCanvasItemModel *model,
+							  gdouble             x,
+							  gdouble             y,
+							  gdouble             scale,
+							  gdouble             degrees,
+							  gboolean            absolute,
+							  gint                duration,
+							  gint                step_time,
+							  GooCanvasAnimateType type);
+void                goo_canvas_item_model_stop_animation (GooCanvasItemModel *model);
+
+
+/*
+ * Functions to support child properties when implementing new canvas items.
+ */
+void         goo_canvas_item_model_class_install_child_property (GObjectClass *mclass,
+								 guint	 property_id,
+								 GParamSpec	*pspec);
+GParamSpec*  goo_canvas_item_model_class_find_child_property	(GObjectClass	*mclass,
+								 const gchar	*property_name);
+GParamSpec** goo_canvas_item_model_class_list_child_properties  (GObjectClass	*mclass,
+								 guint	*n_properties);
+
+
+
+G_END_DECLS
+
+#endif /* __GOO_CANVAS_ITEM_MODEL_H__ */

data/vendor/local/include/goocanvas-1.0.0/goocanvas/goocanvasitemsimple.h

@@ -0,0 +1,247 @@
+/*
+ * GooCanvas. Copyright (C) 2005-6 Damon Chaplin.
+ * Released under the GNU LGPL license. See COPYING for details.
+ *
+ * goocanvasitemsimple.h - abstract base class for simple items.
+ */
+#ifndef __GOO_CANVAS_ITEM_SIMPLE_H__
+#define __GOO_CANVAS_ITEM_SIMPLE_H__
+
+#include <gtk/gtk.h>
+#include "goocanvasitem.h"
+#include "goocanvasitemmodel.h"
+#include "goocanvasstyle.h"
+#include "goocanvasutils.h"
+
+G_BEGIN_DECLS
+
+
+/**
+ * GooCanvasItemSimpleData
+ * @style: the style to draw with.
+ * @transform: the transformation matrix of the item, or %NULL.
+ * @clip_path_commands: an array of #GooCanvasPathCommand specifying the clip
+ *  path of the item, or %NULL.
+ * @tooltip: the item's tooltip.
+ * @visibility_threshold: the threshold scale setting at which to show the item
+ *  (if the @visibility setting is set to %VISIBLE_ABOVE_THRESHOLD).
+ * @visibility: the #GooCanvasItemVisibility setting specifying whether the
+ *  item is visible, invisible, or visible above a given canvas scale setting.
+ * @pointer_events: the #GooCanvasPointerEvents setting specifying the events
+ *  the item should receive.
+ * @can_focus: if the item can take the keyboard focus.
+ * @own_style: if the item has its own style, rather than using its parent's.
+ * @clip_fill_rule: the #cairo_fill_rule_t setting specifying the fill rule
+ *  used for the clip path.
+ * @is_static: if the item is static.
+ *
+ * This is the data common to both the model and view classes.
+ */
+typedef struct _GooCanvasItemSimpleData   GooCanvasItemSimpleData;
+struct _GooCanvasItemSimpleData
+{
+  GooCanvasStyle *style;
+  cairo_matrix_t *transform;
+  GArray *clip_path_commands;
+  gchar *tooltip;
+
+  /*< public >*/
+  gdouble visibility_threshold;
+  guint visibility			: 2;
+  guint pointer_events			: 4;
+  guint can_focus                       : 1;
+  guint own_style                       : 1;
+  guint clip_fill_rule			: 4;
+  guint is_static			: 1;
+
+  /*< private >*/
+  /* We might use this in future for a cache setting - never/always/visible. */
+  guint cache_setting			: 2;
+  /* We might need this for tooltips in future. */
+  guint has_tooltip			: 1;
+};
+
+
+#define GOO_TYPE_CANVAS_ITEM_SIMPLE            (goo_canvas_item_simple_get_type ())
+#define GOO_CANVAS_ITEM_SIMPLE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GOO_TYPE_CANVAS_ITEM_SIMPLE, GooCanvasItemSimple))
+#define GOO_CANVAS_ITEM_SIMPLE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GOO_TYPE_CANVAS_ITEM_SIMPLE, GooCanvasItemSimpleClass))
+#define GOO_IS_CANVAS_ITEM_SIMPLE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GOO_TYPE_CANVAS_ITEM_SIMPLE))
+#define GOO_IS_CANVAS_ITEM_SIMPLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GOO_TYPE_CANVAS_ITEM_SIMPLE))
+#define GOO_CANVAS_ITEM_SIMPLE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GOO_TYPE_CANVAS_ITEM_SIMPLE, GooCanvasItemSimpleClass))
+
+
+typedef struct _GooCanvasItemSimple       GooCanvasItemSimple;
+typedef struct _GooCanvasItemSimpleClass  GooCanvasItemSimpleClass;
+
+typedef struct _GooCanvasItemModelSimple       GooCanvasItemModelSimple;
+
+/**
+ * GooCanvasItemSimple
+ * @canvas: the canvas.
+ * @parent: the parent item.
+ * @model: the item's model, if it has one.
+ * @simple_data: data that is common to both the model and view classes. If
+ *  the canvas item has a model, this will point to the model's
+ *  #GooCanvasItemSimpleData, otherwise the canvas item will have its own
+ *  #GooCanvasItemSimpleData.
+ * @bounds: the bounds of the item, in device space.
+ * @need_update: if the item needs to recompute its bounds and redraw.
+ * @need_entire_subtree_update: if all descendants need to be updated.
+ *
+ * The #GooCanvasItemSimple-struct struct contains the basic data needed to
+ * implement canvas items.
+ */
+struct _GooCanvasItemSimple
+{
+  /* <private> */
+  GObject parent_object;
+
+  /* <public> */
+  GooCanvas *canvas;
+  GooCanvasItem *parent;
+  GooCanvasItemModelSimple *model;
+  GooCanvasItemSimpleData *simple_data;
+  GooCanvasBounds bounds;
+  guint	need_update			: 1;
+  guint need_entire_subtree_update      : 1;
+
+  /* <private> */
+  /* We might use this in future for things like a cache. */
+  gpointer priv;
+};
+
+/**
+ * GooCanvasItemSimpleClass
+ * @simple_create_path: simple subclasses that draw basic shapes and paths only
+ *  need to override this one method. It creates the path for the item.
+ *  All updating, painting and hit-testing is provided automatically by the
+ *  #GooCanvasItemSimple class. (This method is used by the builtin
+ *  #GooCanvasEllipse, #GooCanvasRect and #GooCanvasPath items.)
+ *  More complicated subclasses must override @simple_update, @simple_paint and
+ *  @simple_is_item_at instead.
+ * @simple_update: subclasses should override this to calculate their new
+ *  bounds, in user space.
+ * @simple_paint: subclasses should override this to paint their item.
+ * @simple_is_item_at: subclasses should override this to do hit-testing.
+ *
+ * The #GooCanvasItemSimpleClass-struct struct contains several methods that
+ * subclasses can override.
+ *
+ * Simple items need only implement the create_path() method. More complex
+ * items must override the update(), paint() and is_item_at() methods instead.
+ */
+struct _GooCanvasItemSimpleClass
+{
+  /*< private >*/
+  GObjectClass parent_class;
+
+  /*< public >*/
+  void		 (* simple_create_path)	(GooCanvasItemSimple   *simple,
+					 cairo_t               *cr);
+
+  void           (* simple_update)	(GooCanvasItemSimple   *simple,
+					 cairo_t               *cr);
+  void           (* simple_paint)	(GooCanvasItemSimple   *simple,
+					 cairo_t               *cr,
+					 const GooCanvasBounds *bounds);
+  gboolean       (* simple_is_item_at)  (GooCanvasItemSimple   *simple,
+					 gdouble                x,
+					 gdouble                y,
+					 cairo_t               *cr,
+					 gboolean               is_pointer_event);
+
+  /*< private >*/
+
+  /* Padding for future expansion */
+  void (*_goo_canvas_reserved1) (void);
+  void (*_goo_canvas_reserved2) (void);
+  void (*_goo_canvas_reserved3) (void);
+  void (*_goo_canvas_reserved4) (void);
+};
+
+
+GType    goo_canvas_item_simple_get_type		(void) G_GNUC_CONST;
+
+
+void     goo_canvas_item_simple_get_path_bounds		(GooCanvasItemSimple	*item,
+							 cairo_t		*cr,
+							 GooCanvasBounds	*bounds);
+void     goo_canvas_item_simple_user_bounds_to_device	(GooCanvasItemSimple	*item,
+							 cairo_t		*cr,
+							 GooCanvasBounds	*bounds);
+void     goo_canvas_item_simple_user_bounds_to_parent	(GooCanvasItemSimple	*item,
+							 cairo_t		*cr,
+							 GooCanvasBounds	*bounds);
+gboolean goo_canvas_item_simple_check_in_path		(GooCanvasItemSimple	*item,
+							 gdouble		 x,
+							 gdouble		 y,
+							 cairo_t		*cr,
+							 GooCanvasPointerEvents  pointer_events);
+void     goo_canvas_item_simple_paint_path		(GooCanvasItemSimple	*item,
+							 cairo_t		*cr);
+
+void     goo_canvas_item_simple_changed			(GooCanvasItemSimple	*item,
+							 gboolean		 recompute_bounds);
+void     goo_canvas_item_simple_check_style		(GooCanvasItemSimple	*item);
+gdouble  goo_canvas_item_simple_get_line_width		(GooCanvasItemSimple   *item);
+void	 goo_canvas_item_simple_set_model		(GooCanvasItemSimple	*item,
+							 GooCanvasItemModel	*model);
+
+
+
+
+
+#define GOO_TYPE_CANVAS_ITEM_MODEL_SIMPLE            (goo_canvas_item_model_simple_get_type ())
+#define GOO_CANVAS_ITEM_MODEL_SIMPLE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GOO_TYPE_CANVAS_ITEM_MODEL_SIMPLE, GooCanvasItemModelSimple))
+#define GOO_CANVAS_ITEM_MODEL_SIMPLE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GOO_TYPE_CANVAS_ITEM_MODEL_SIMPLE, GooCanvasItemModelSimpleClass))
+#define GOO_IS_CANVAS_ITEM_MODEL_SIMPLE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GOO_TYPE_CANVAS_ITEM_MODEL_SIMPLE))
+#define GOO_IS_CANVAS_ITEM_MODEL_SIMPLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GOO_TYPE_CANVAS_ITEM_MODEL_SIMPLE))
+#define GOO_CANVAS_ITEM_MODEL_SIMPLE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GOO_TYPE_CANVAS_ITEM_MODEL_SIMPLE, GooCanvasItemModelSimpleClass))
+
+
+typedef struct _GooCanvasItemModelSimpleClass  GooCanvasItemModelSimpleClass;
+
+/**
+ * GooCanvasItemModelSimple
+ * @parent: the parent model.
+ * @simple_data: data used by the canvas item for viewing the model.
+ *
+ * The #GooCanvasItemModelSimple-struct struct contains the basic data needed
+ * to implement canvas item models.
+ */
+struct _GooCanvasItemModelSimple
+{
+  GObject parent_object;
+
+  /*< public >*/
+  GooCanvasItemModel *parent;
+  GooCanvasItemSimpleData simple_data;
+
+  /*< private >*/
+
+  /* The title and description of the item for accessibility. */
+  gchar *title;
+  gchar *description;
+};
+
+
+struct _GooCanvasItemModelSimpleClass
+{
+  GObjectClass parent_class;
+
+  /*< private >*/
+
+  /* Padding for future expansion */
+  void (*_goo_canvas_reserved1) (void);
+  void (*_goo_canvas_reserved2) (void);
+  void (*_goo_canvas_reserved3) (void);
+  void (*_goo_canvas_reserved4) (void);
+};
+
+
+GType    goo_canvas_item_model_simple_get_type  (void) G_GNUC_CONST;
+
+
+G_END_DECLS
+
+#endif /* __GOO_CANVAS_ITEM_SIMPLE_H__ */

data/vendor/local/include/goocanvas-1.0.0/goocanvas/goocanvasmarshal.h

@@ -0,0 +1,61 @@
+
+#ifndef __goo_canvas_marshal_MARSHAL_H__
+#define __goo_canvas_marshal_MARSHAL_H__
+
+#include	<glib-object.h>
+
+G_BEGIN_DECLS
+
+/* VOID:VOID (./goocanvasmarshal.list:1) */
+#define goo_canvas_marshal_VOID__VOID	g_cclosure_marshal_VOID__VOID
+
+/* VOID:INT (./goocanvasmarshal.list:2) */
+#define goo_canvas_marshal_VOID__INT	g_cclosure_marshal_VOID__INT
+
+/* VOID:INT,INT (./goocanvasmarshal.list:3) */
+extern void goo_canvas_marshal_VOID__INT_INT (GClosure     *closure,
+                                              GValue       *return_value,
+                                              guint         n_param_values,
+                                              const GValue *param_values,
+                                              gpointer      invocation_hint,
+                                              gpointer      marshal_data);
+
+/* VOID:BOOLEAN (./goocanvasmarshal.list:4) */
+#define goo_canvas_marshal_VOID__BOOLEAN	g_cclosure_marshal_VOID__BOOLEAN
+
+/* VOID:OBJECT,OBJECT (./goocanvasmarshal.list:5) */
+extern void goo_canvas_marshal_VOID__OBJECT_OBJECT (GClosure     *closure,
+                                                    GValue       *return_value,
+                                                    guint         n_param_values,
+                                                    const GValue *param_values,
+                                                    gpointer      invocation_hint,
+                                                    gpointer      marshal_data);
+
+/* BOOLEAN:BOXED (./goocanvasmarshal.list:6) */
+extern void goo_canvas_marshal_BOOLEAN__BOXED (GClosure     *closure,
+                                               GValue       *return_value,
+                                               guint         n_param_values,
+                                               const GValue *param_values,
+                                               gpointer      invocation_hint,
+                                               gpointer      marshal_data);
+
+/* BOOLEAN:OBJECT,BOXED (./goocanvasmarshal.list:7) */
+extern void goo_canvas_marshal_BOOLEAN__OBJECT_BOXED (GClosure     *closure,
+                                                      GValue       *return_value,
+                                                      guint         n_param_values,
+                                                      const GValue *param_values,
+                                                      gpointer      invocation_hint,
+                                                      gpointer      marshal_data);
+
+/* BOOLEAN:DOUBLE,DOUBLE,BOOLEAN,OBJECT (./goocanvasmarshal.list:8) */
+extern void goo_canvas_marshal_BOOLEAN__DOUBLE_DOUBLE_BOOLEAN_OBJECT (GClosure     *closure,
+                                                                      GValue       *return_value,
+                                                                      guint         n_param_values,
+                                                                      const GValue *param_values,
+                                                                      gpointer      invocation_hint,
+                                                                      gpointer      marshal_data);
+
+G_END_DECLS
+
+#endif /* __goo_canvas_marshal_MARSHAL_H__ */
+

data/vendor/local/include/goocanvas-1.0.0/goocanvas/goocanvaspath.h

@@ -0,0 +1,116 @@
+/*
+ * GooCanvas. Copyright (C) 2005-6 Damon Chaplin.
+ * Released under the GNU LGPL license. See COPYING for details.
+ *
+ * goocanvaspath.h - a path item, very similar to the SVG path element.
+ */
+#ifndef __GOO_CANVAS_PATH_H__
+#define __GOO_CANVAS_PATH_H__
+
+#include <gtk/gtk.h>
+#include "goocanvasitemsimple.h"
+
+G_BEGIN_DECLS
+
+
+/* This is the data used by both model and view classes. */
+typedef struct _GooCanvasPathData   GooCanvasPathData;
+struct _GooCanvasPathData
+{
+  /* An array of GooCanvasPathCommand. */
+  GArray *path_commands;
+};
+
+
+#define GOO_TYPE_CANVAS_PATH            (goo_canvas_path_get_type ())
+#define GOO_CANVAS_PATH(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GOO_TYPE_CANVAS_PATH, GooCanvasPath))
+#define GOO_CANVAS_PATH_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GOO_TYPE_CANVAS_PATH, GooCanvasPathClass))
+#define GOO_IS_CANVAS_PATH(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GOO_TYPE_CANVAS_PATH))
+#define GOO_IS_CANVAS_PATH_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GOO_TYPE_CANVAS_PATH))
+#define GOO_CANVAS_PATH_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GOO_TYPE_CANVAS_PATH, GooCanvasPathClass))
+
+
+typedef struct _GooCanvasPath       GooCanvasPath;
+typedef struct _GooCanvasPathClass  GooCanvasPathClass;
+
+/**
+ * GooCanvasPath
+ *
+ * The #GooCanvasPath-struct struct contains private data only.
+ */
+struct _GooCanvasPath
+{
+  GooCanvasItemSimple parent;
+
+  GooCanvasPathData *path_data;
+};
+
+struct _GooCanvasPathClass
+{
+  GooCanvasItemSimpleClass parent_class;
+
+  /*< private >*/
+
+  /* Padding for future expansion */
+  void (*_goo_canvas_reserved1) (void);
+  void (*_goo_canvas_reserved2) (void);
+  void (*_goo_canvas_reserved3) (void);
+  void (*_goo_canvas_reserved4) (void);
+};
+
+
+GType               goo_canvas_path_get_type  (void) G_GNUC_CONST;
+
+GooCanvasItem*      goo_canvas_path_new       (GooCanvasItem      *parent,
+					       const gchar        *path_data,
+					       ...);
+
+
+
+#define GOO_TYPE_CANVAS_PATH_MODEL            (goo_canvas_path_model_get_type ())
+#define GOO_CANVAS_PATH_MODEL(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GOO_TYPE_CANVAS_PATH_MODEL, GooCanvasPathModel))
+#define GOO_CANVAS_PATH_MODEL_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GOO_TYPE_CANVAS_PATH_MODEL, GooCanvasPathModelClass))
+#define GOO_IS_CANVAS_PATH_MODEL(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GOO_TYPE_CANVAS_PATH_MODEL))
+#define GOO_IS_CANVAS_PATH_MODEL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GOO_TYPE_CANVAS_PATH_MODEL))
+#define GOO_CANVAS_PATH_MODEL_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GOO_TYPE_CANVAS_PATH_MODEL, GooCanvasPathModelClass))
+
+
+typedef struct _GooCanvasPathModel       GooCanvasPathModel;
+typedef struct _GooCanvasPathModelClass  GooCanvasPathModelClass;
+
+/**
+ * GooCanvasPathModel
+ *
+ * The #GooCanvasPathModel-struct struct contains private data only.
+ */
+struct _GooCanvasPathModel
+{
+  GooCanvasItemModelSimple parent_object;
+
+  GooCanvasPathData path_data;
+};
+
+struct _GooCanvasPathModelClass
+{
+  GooCanvasItemModelSimpleClass parent_class;
+
+  /*< private >*/
+
+  /* Padding for future expansion */
+  void (*_goo_canvas_reserved1) (void);
+  void (*_goo_canvas_reserved2) (void);
+  void (*_goo_canvas_reserved3) (void);
+  void (*_goo_canvas_reserved4) (void);
+};
+
+
+GType               goo_canvas_path_model_get_type  (void) G_GNUC_CONST;
+
+GooCanvasItemModel* goo_canvas_path_model_new (GooCanvasItemModel *parent,
+					       const gchar        *path_data,
+					       ...);
+
+
+G_END_DECLS
+
+#endif /* __GOO_CANVAS_PATH_H__ */