goocanvas 0.90.6-x86-mingw32

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

@@ -0,0 +1,334 @@
+/*
+ * GooCanvas. Copyright (C) 2005 Damon Chaplin.
+ * Released under the GNU LGPL license. See COPYING for details.
+ *
+ * goocanvas.h - the main canvas widget.
+ */
+#ifndef __GOO_CANVAS_H__
+#define __GOO_CANVAS_H__
+
+#include <gtk/gtk.h>
+#include <goocanvasenumtypes.h>
+#include <goocanvasellipse.h>
+#include <goocanvasgrid.h>
+#include <goocanvasgroup.h>
+#include <goocanvasimage.h>
+#include <goocanvaspath.h>
+#include <goocanvaspolyline.h>
+#include <goocanvasrect.h>
+#include <goocanvastable.h>
+#include <goocanvastext.h>
+#include <goocanvaswidget.h>
+
+G_BEGIN_DECLS
+
+
+#define GOO_TYPE_CANVAS            (goo_canvas_get_type ())
+#define GOO_CANVAS(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GOO_TYPE_CANVAS, GooCanvas))
+#define GOO_CANVAS_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GOO_TYPE_CANVAS, GooCanvasClass))
+#define GOO_IS_CANVAS(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GOO_TYPE_CANVAS))
+#define GOO_IS_CANVAS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GOO_TYPE_CANVAS))
+#define GOO_CANVAS_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GOO_TYPE_CANVAS, GooCanvasClass))
+
+
+typedef struct _GooCanvasClass  GooCanvasClass;
+
+/**
+ * GooCanvas
+ *
+ * The #GooCanvas-struct struct contains private data only.
+ */
+struct _GooCanvas
+{
+  GtkContainer container;
+
+  /* The model for the root item, in model/view mode. */
+  GooCanvasItemModel *root_item_model;
+
+  /* The root canvas item. */
+  GooCanvasItem *root_item;
+
+  /* The bounds of the canvas, in canvas units (not pixels). */
+  GooCanvasBounds bounds;
+
+  /* The scale/zoom factors of the canvas. */
+  gdouble scale_x, scale_y;
+
+  /* The minimum of scale_x and scale_y, to compare with items' visibility
+     thresholds. */
+  gdouble scale;
+
+  /* Where the canvas is anchored (where it is displayed when it is smaller
+     than the entire window). */
+  GtkAnchorType anchor;
+
+  /* Idle handler ID, for processing updates. */
+  guint idle_id;
+
+  /* This is TRUE if some item in the canvas needs an update. */
+  guint need_update : 1;
+
+  /* This is TRUE if all items in the canvas need to be updated. */
+  guint need_entire_subtree_update : 1;
+
+  /* This is TRUE if all layout should be done to the nearest integer. */
+  guint integer_layout : 1;
+
+  /* This is TRUE if the bounds are calculated automatically, using the bounds
+     of all the items in the canvas. */
+  guint automatic_bounds : 1;
+
+  /* This is TRUE if the automatic bounds are calculated from the origin. */
+  guint bounds_from_origin : 1;
+
+  /* This is TRUE if the background is cleared before painting the canvas. */
+  guint clear_background : 1;
+
+  /* This is TRUE if the canvas is completely redrawn when scrolled. It is
+     useful when there are sticky items to reduce flicker, but is slower. */
+  guint redraw_when_scrolled : 1;
+
+  /* If the canvas hasn't received the initial expose event yet. */
+  guint before_initial_expose : 1;
+
+  /* This is the padding around the automatic bounds. */
+  gdouble bounds_padding;
+
+  /* The item that the mouse is over. */
+  GooCanvasItem *pointer_item;
+
+  /* The item that has the pointer grab, or NULL. */
+  GooCanvasItem *pointer_grab_item;
+
+  /* This is the item that the grab was started from. When the grab ends
+     we synthesize enter/leave notify events from this item. */
+  GooCanvasItem *pointer_grab_initial_item;
+
+  /* This is the mouse button that started an implicit pointer grab.
+     When the same button is released the implicit grab ends. */
+  guint pointer_grab_button;
+
+  /* The item that has the keyboard focus, or NULL. */
+  GooCanvasItem *focused_item;
+
+  /* The item that has the keyboard grab, or NULL. */
+  GooCanvasItem *keyboard_grab_item;
+
+  /* The synthesized event used for sending enter-notify and leave-notify
+     events to items. */
+  GdkEventCrossing crossing_event;
+
+  /* The main canvas window, which gets scrolled around. */
+  GdkWindow *canvas_window;
+
+  /* The offsets of the canvas within the canvas window, in pixels. These are
+     used when the canvas is smaller than the window size and the anchor is not
+     NORTH_WEST. */
+  gint canvas_x_offset;
+  gint canvas_y_offset;
+
+  /* The adjustments used for scrolling. */
+  GtkAdjustment *hadjustment;
+  GtkAdjustment *vadjustment;
+
+  /* Freezes any movement of the canvas window, until thawed. This is used
+     when we need to set both adjustments and don't want it to scroll twice. */
+  gint freeze_count;
+
+  /* A window temporarily mapped above the canvas to stop X from scrolling
+     the contents unnecessarily (i.e. when we zoom in/out). */
+  GdkWindow *tmp_window;
+
+  /* A hash table mapping canvas item models to canvas items. */
+  GHashTable *model_to_item;
+
+  /* The units of the canvas, which applies to all item coords. */
+  GtkUnit units;
+
+  /* The horizontal and vertical resolution of the display, in dots per inch.
+     This is only needed when units other than pixels are used. */
+  gdouble resolution_x, resolution_y;
+
+  /* The multiplers to convert from device units to pixels, taking into account
+     the canvas scale, the units setting and the display resolution. */
+  gdouble device_to_pixels_x, device_to_pixels_y;
+
+  /* The list of child widgets (using GooCanvasWidget items). */
+  GList *widget_items;
+};
+
+/**
+ * GooCanvasClass
+ * @create_item: a virtual method that subclasses may override to create custom
+ *  canvas items for item models.
+ * @item_created: signal emitted when a new canvas item has been created.
+ *  Applications can connect to this to setup signal handlers for the new item.
+ *
+ * The #GooCanvasClass-struct struct contains one virtual method that
+ * subclasses may override.
+ */
+struct _GooCanvasClass
+{
+  /*< private >*/
+  GtkContainerClass parent_class;
+
+  void		 (* set_scroll_adjustments) (GooCanvas          *canvas,
+					     GtkAdjustment      *hadjustment,
+					     GtkAdjustment      *vadjustment);
+
+  /* Virtual methods. */
+  /*< public >*/
+  GooCanvasItem* (* create_item)	    (GooCanvas          *canvas,
+					     GooCanvasItemModel *model);
+
+  /* Signals. */
+  void           (* item_created)	    (GooCanvas          *canvas,
+					     GooCanvasItem      *item,
+					     GooCanvasItemModel *model);
+
+  /*< 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);
+  void (*_goo_canvas_reserved8) (void);
+};
+
+
+GType           goo_canvas_get_type	    (void) G_GNUC_CONST;
+GtkWidget*      goo_canvas_new		    (void);
+
+GooCanvasItem*  goo_canvas_get_root_item    (GooCanvas		*canvas);
+void            goo_canvas_set_root_item    (GooCanvas		*canvas,
+					     GooCanvasItem      *item);
+
+GooCanvasItemModel* goo_canvas_get_root_item_model (GooCanvas	       *canvas);
+void                goo_canvas_set_root_item_model (GooCanvas	       *canvas,
+						    GooCanvasItemModel *model);
+
+GooCanvasItem*  goo_canvas_get_static_root_item    (GooCanvas		*canvas);
+void            goo_canvas_set_static_root_item    (GooCanvas		*canvas,
+						    GooCanvasItem      *item);
+
+GooCanvasItemModel* goo_canvas_get_static_root_item_model (GooCanvas	       *canvas);
+void                goo_canvas_set_static_root_item_model (GooCanvas	       *canvas,
+							   GooCanvasItemModel *model);
+
+GooCanvasItem*  goo_canvas_get_item	    (GooCanvas		*canvas,
+					     GooCanvasItemModel *model);
+GooCanvasItem*  goo_canvas_get_item_at	    (GooCanvas		*canvas,
+					     gdouble             x,
+					     gdouble             y,
+					     gboolean            is_pointer_event);
+GList*		goo_canvas_get_items_at	    (GooCanvas		*canvas,
+					     gdouble		 x,
+					     gdouble		 y,
+					     gboolean		 is_pointer_event);
+GList*		goo_canvas_get_items_in_area(GooCanvas		*canvas,
+					     const GooCanvasBounds *area,
+					     gboolean		 inside_area,
+					     gboolean            allow_overlaps,
+					     gboolean            include_containers);
+
+gdouble         goo_canvas_get_scale	    (GooCanvas		*canvas);
+void            goo_canvas_set_scale	    (GooCanvas		*canvas,
+					     gdouble             scale);
+
+void            goo_canvas_get_bounds	    (GooCanvas		*canvas,
+					     gdouble            *left,
+					     gdouble            *top,
+					     gdouble            *right,
+					     gdouble            *bottom);
+void            goo_canvas_set_bounds	    (GooCanvas		*canvas,
+					     gdouble             left,
+					     gdouble             top,
+					     gdouble             right,
+					     gdouble             bottom);
+
+void            goo_canvas_scroll_to	    (GooCanvas		*canvas,
+					     gdouble             left,
+					     gdouble             top);
+
+void            goo_canvas_grab_focus	    (GooCanvas		*canvas,
+					     GooCanvasItem	*item);
+
+void            goo_canvas_render	    (GooCanvas		   *canvas,
+					     cairo_t               *cr,
+					     const GooCanvasBounds *bounds,
+					     gdouble                scale);
+
+/*
+ * Coordinate conversion.
+ */
+void		goo_canvas_convert_to_pixels	   (GooCanvas       *canvas,
+						    gdouble         *x,
+						    gdouble         *y);
+void		goo_canvas_convert_from_pixels	   (GooCanvas       *canvas,
+						    gdouble         *x,
+						    gdouble         *y);
+
+void		goo_canvas_convert_to_item_space   (GooCanvas	    *canvas,
+						    GooCanvasItem   *item,
+						    gdouble         *x,
+						    gdouble         *y);
+void		goo_canvas_convert_from_item_space (GooCanvas       *canvas,
+						    GooCanvasItem   *item,
+						    gdouble         *x,
+						    gdouble         *y);
+void		goo_canvas_convert_bounds_to_item_space (GooCanvas           *canvas,
+							 GooCanvasItem       *item,
+							 GooCanvasBounds     *bounds);
+
+
+/*
+ * Pointer/keyboard grabbing & ungrabbing.
+ */
+GdkGrabStatus	goo_canvas_pointer_grab	    (GooCanvas		*canvas,
+					     GooCanvasItem	*item,
+					     GdkEventMask        event_mask,
+					     GdkCursor		*cursor,
+					     guint32             time);
+void		goo_canvas_pointer_ungrab   (GooCanvas		*canvas,
+					     GooCanvasItem	*item,
+					     guint32             time);
+GdkGrabStatus	goo_canvas_keyboard_grab    (GooCanvas		*canvas,
+					     GooCanvasItem	*item,
+					     gboolean            owner_events,
+					     guint32             time);
+void		goo_canvas_keyboard_ungrab  (GooCanvas		*canvas,
+					     GooCanvasItem	*item,
+					     guint32             time);
+
+
+/*
+ * Internal functions, mainly for canvas subclasses and item implementations.
+ */
+cairo_t*	goo_canvas_create_cairo_context	(GooCanvas *canvas);
+GooCanvasItem*	goo_canvas_create_item	    (GooCanvas          *canvas,
+					     GooCanvasItemModel *model);
+void		goo_canvas_unregister_item  (GooCanvas		*canvas,
+					     GooCanvasItemModel *model);
+void		goo_canvas_update	    (GooCanvas		*canvas);
+void		goo_canvas_request_update   (GooCanvas		*canvas);
+void		goo_canvas_request_redraw   (GooCanvas		*canvas,
+					     const GooCanvasBounds *bounds);
+void		goo_canvas_request_item_redraw   (GooCanvas		*canvas,
+						  const GooCanvasBounds *bounds,
+						  gboolean               is_static);
+gdouble         goo_canvas_get_default_line_width (GooCanvas    *canvas);
+
+
+void            goo_canvas_register_widget_item   (GooCanvas          *canvas,
+						   GooCanvasWidget    *witem);
+void            goo_canvas_unregister_widget_item (GooCanvas          *canvas,
+						   GooCanvasWidget    *witem);
+
+
+G_END_DECLS
+
+#endif /* __GOO_CANVAS_H__ */

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

@@ -0,0 +1,22 @@
+/*
+ * GooCanvas. Copyright (C) 2005 Damon Chaplin.
+ * Released under the GNU LGPL license. See COPYING for details.
+ *
+ * goocanvasatk.h - the accessibility code.
+ */
+#ifndef __GOO_CANVAS_ATK_H__
+#define __GOO_CANVAS_ATK_H__
+
+#include <gtk/gtk.h>
+
+
+G_BEGIN_DECLS
+
+GType    goo_canvas_accessible_factory_get_type  (void) G_GNUC_CONST;
+GType    goo_canvas_item_accessible_factory_get_type  (void) G_GNUC_CONST;
+GType    goo_canvas_widget_accessible_factory_get_type  (void) G_GNUC_CONST;
+
+
+G_END_DECLS
+
+#endif /* __GOO_CANVAS_ATK_H__ */

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

@@ -0,0 +1,120 @@
+/*
+ * GooCanvas. Copyright (C) 2005 Damon Chaplin.
+ * Released under the GNU LGPL license. See COPYING for details.
+ *
+ * goocanvasellipse.h - ellipse item.
+ */
+#ifndef __GOO_CANVAS_ELLIPSE_H__
+#define __GOO_CANVAS_ELLIPSE_H__
+
+#include <gtk/gtk.h>
+#include "goocanvasitemsimple.h"
+
+G_BEGIN_DECLS
+
+
+/* This is the data used by both model and view classes. */
+typedef struct _GooCanvasEllipseData   GooCanvasEllipseData;
+struct _GooCanvasEllipseData
+{
+  gdouble center_x, center_y, radius_x, radius_y;
+};
+
+
+#define GOO_TYPE_CANVAS_ELLIPSE            (goo_canvas_ellipse_get_type ())
+#define GOO_CANVAS_ELLIPSE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GOO_TYPE_CANVAS_ELLIPSE, GooCanvasEllipse))
+#define GOO_CANVAS_ELLIPSE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GOO_TYPE_CANVAS_ELLIPSE, GooCanvasEllipseClass))
+#define GOO_IS_CANVAS_ELLIPSE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GOO_TYPE_CANVAS_ELLIPSE))
+#define GOO_IS_CANVAS_ELLIPSE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GOO_TYPE_CANVAS_ELLIPSE))
+#define GOO_CANVAS_ELLIPSE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GOO_TYPE_CANVAS_ELLIPSE, GooCanvasEllipseClass))
+
+
+typedef struct _GooCanvasEllipse       GooCanvasEllipse;
+typedef struct _GooCanvasEllipseClass  GooCanvasEllipseClass;
+
+/**
+ * GooCanvasEllipse
+ *
+ * The #GooCanvasEllipse-struct struct contains private data only.
+ */
+struct _GooCanvasEllipse
+{
+  GooCanvasItemSimple parent_object;
+
+  GooCanvasEllipseData *ellipse_data;
+};
+
+struct _GooCanvasEllipseClass
+{
+  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_ellipse_get_type  (void) G_GNUC_CONST;
+
+GooCanvasItem*      goo_canvas_ellipse_new	 (GooCanvasItem      *parent,
+						  gdouble             center_x,
+						  gdouble             center_y,
+						  gdouble             radius_x,
+						  gdouble             radius_y,
+						  ...);
+
+
+
+#define GOO_TYPE_CANVAS_ELLIPSE_MODEL            (goo_canvas_ellipse_model_get_type ())
+#define GOO_CANVAS_ELLIPSE_MODEL(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GOO_TYPE_CANVAS_ELLIPSE_MODEL, GooCanvasEllipseModel))
+#define GOO_CANVAS_ELLIPSE_MODEL_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GOO_TYPE_CANVAS_ELLIPSE_MODEL, GooCanvasEllipseModelClass))
+#define GOO_IS_CANVAS_ELLIPSE_MODEL(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GOO_TYPE_CANVAS_ELLIPSE_MODEL))
+#define GOO_IS_CANVAS_ELLIPSE_MODEL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GOO_TYPE_CANVAS_ELLIPSE_MODEL))
+#define GOO_CANVAS_ELLIPSE_MODEL_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GOO_TYPE_CANVAS_ELLIPSE_MODEL, GooCanvasEllipseModelClass))
+
+
+typedef struct _GooCanvasEllipseModel       GooCanvasEllipseModel;
+typedef struct _GooCanvasEllipseModelClass  GooCanvasEllipseModelClass;
+
+/**
+ * GooCanvasEllipseModel
+ *
+ * The #GooCanvasEllipseModel-struct struct contains private data only.
+ */
+struct _GooCanvasEllipseModel
+{
+  GooCanvasItemModelSimple parent_object;
+
+  GooCanvasEllipseData ellipse_data;
+};
+
+struct _GooCanvasEllipseModelClass
+{
+  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_ellipse_model_get_type  (void) G_GNUC_CONST;
+
+GooCanvasItemModel* goo_canvas_ellipse_model_new (GooCanvasItemModel *parent,
+						  gdouble             center_x,
+						  gdouble             center_y,
+						  gdouble             radius_x,
+						  gdouble             radius_y,
+						  ...);
+
+G_END_DECLS
+
+#endif /* __GOO_CANVAS_ELLIPSE_H__ */

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

@@ -0,0 +1,33 @@
+
+/* Generated data (by glib-mkenums) */
+
+#ifndef __GOO_CANVAS_ENUM_TYPES_H__
+#define __GOO_CANVAS_ENUM_TYPES_H__
+
+#include <glib-object.h>
+
+G_BEGIN_DECLS
+/* Enumerations from "goocanvasitem.h" */
+GType goo_canvas_animate_type_get_type (void);
+#define GOO_TYPE_CANVAS_ANIMATE_TYPE (goo_canvas_animate_type_get_type())
+
+
+/* Enumerations from "goocanvasutils.h" */
+GType goo_canvas_pointer_events_get_type (void);
+#define GOO_TYPE_CANVAS_POINTER_EVENTS (goo_canvas_pointer_events_get_type())
+
+
+GType goo_canvas_item_visibility_get_type (void);
+#define GOO_TYPE_CANVAS_ITEM_VISIBILITY (goo_canvas_item_visibility_get_type())
+
+
+GType goo_canvas_path_command_type_get_type (void);
+#define GOO_TYPE_CANVAS_PATH_COMMAND_TYPE (goo_canvas_path_command_type_get_type())
+
+
+G_END_DECLS
+
+#endif /* __GOO_CANVAS_ENUM_TYPES_H__ */
+
+/* Generated data ends here */
+

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

@@ -0,0 +1,153 @@
+/*
+ * GooCanvas. Copyright (C) 2005-8 Damon Chaplin.
+ * Released under the GNU LGPL license. See COPYING for details.
+ *
+ * goocanvasgrid.h - a grid item.
+ */
+#ifndef __GOO_CANVAS_GRID_H__
+#define __GOO_CANVAS_GRID_H__
+
+#include <gtk/gtk.h>
+#include "goocanvasitemsimple.h"
+
+G_BEGIN_DECLS
+
+
+/* This is the data used by both model and view classes. */
+typedef struct _GooCanvasGridData   GooCanvasGridData;
+struct _GooCanvasGridData
+{
+  /* The area that the grid covers. */
+  gdouble x, y, width, height;
+
+  /* The distance between grid lines. */
+  gdouble x_step, y_step;
+
+  /* The offset before the first grid line. */
+  gdouble x_offset, y_offset;
+
+  /* The widths of the grid lines, or -ve to use item's stroke width. */
+  gdouble horz_grid_line_width, vert_grid_line_width;
+
+  /* The color/pattern for the grid lines, or NULL to use the stroke color. */
+  cairo_pattern_t *horz_grid_line_pattern, *vert_grid_line_pattern;
+
+  /* The width of the border around the grid, or -1 for no border. */
+  gdouble border_width;
+
+  /* The color/pattern for the border, or NULL to use the stroke color. */
+  cairo_pattern_t *border_pattern;
+
+  /* If the horizontal and vertical grid lines should be shown. */
+  guint show_horz_grid_lines : 1;
+  guint show_vert_grid_lines : 1;
+
+  /* If vertical grid lines are drawn on top. */
+  guint vert_grid_lines_on_top : 1;
+};
+
+
+#define GOO_TYPE_CANVAS_GRID            (goo_canvas_grid_get_type ())
+#define GOO_CANVAS_GRID(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GOO_TYPE_CANVAS_GRID, GooCanvasGrid))
+#define GOO_CANVAS_GRID_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GOO_TYPE_CANVAS_GRID, GooCanvasGridClass))
+#define GOO_IS_CANVAS_GRID(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GOO_TYPE_CANVAS_GRID))
+#define GOO_IS_CANVAS_GRID_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GOO_TYPE_CANVAS_GRID))
+#define GOO_CANVAS_GRID_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GOO_TYPE_CANVAS_GRID, GooCanvasGridClass))
+
+
+typedef struct _GooCanvasGrid       GooCanvasGrid;
+typedef struct _GooCanvasGridClass  GooCanvasGridClass;
+
+/**
+ * GooCanvasGrid
+ *
+ * The #GooCanvasGrid-struct struct contains private data only.
+ */
+struct _GooCanvasGrid
+{
+  GooCanvasItemSimple parent_object;
+
+  GooCanvasGridData *grid_data;
+};
+
+struct _GooCanvasGridClass
+{
+  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_grid_get_type      (void) G_GNUC_CONST;
+GooCanvasItem* goo_canvas_grid_new           (GooCanvasItem      *parent,
+					      gdouble             x,
+					      gdouble             y,
+					      gdouble             width,
+					      gdouble             height,
+					      gdouble             x_step,
+					      gdouble             y_step,
+					      gdouble             x_offset,
+					      gdouble             y_offset,
+					      ...);
+
+
+
+#define GOO_TYPE_CANVAS_GRID_MODEL            (goo_canvas_grid_model_get_type ())
+#define GOO_CANVAS_GRID_MODEL(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GOO_TYPE_CANVAS_GRID_MODEL, GooCanvasGridModel))
+#define GOO_CANVAS_GRID_MODEL_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GOO_TYPE_CANVAS_GRID_MODEL, GooCanvasGridModelClass))
+#define GOO_IS_CANVAS_GRID_MODEL(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GOO_TYPE_CANVAS_GRID_MODEL))
+#define GOO_IS_CANVAS_GRID_MODEL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GOO_TYPE_CANVAS_GRID_MODEL))
+#define GOO_CANVAS_GRID_MODEL_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GOO_TYPE_CANVAS_GRID_MODEL, GooCanvasGridModelClass))
+
+
+typedef struct _GooCanvasGridModel       GooCanvasGridModel;
+typedef struct _GooCanvasGridModelClass  GooCanvasGridModelClass;
+
+/**
+ * GooCanvasGridModel
+ *
+ * The #GooCanvasGridModel-struct struct contains private data only.
+ */
+struct _GooCanvasGridModel
+{
+  GooCanvasItemModelSimple parent_object;
+
+  GooCanvasGridData grid_data;
+};
+
+struct _GooCanvasGridModelClass
+{
+  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_grid_model_get_type (void) G_GNUC_CONST;
+GooCanvasItemModel* goo_canvas_grid_model_new      (GooCanvasItemModel *parent,
+						    gdouble             x,
+						    gdouble             y,
+						    gdouble             width,
+						    gdouble             height,
+						    gdouble             x_step,
+						    gdouble             y_step,
+						    gdouble             x_offset,
+						    gdouble             y_offset,
+						    ...);
+
+
+G_END_DECLS
+
+#endif /* __GOO_CANVAS_GRID_H__ */