<MACRO>
<NAME>GANV_TYPE_WIDGET</NAME>
#define GANV_TYPE_WIDGET            (ganv_widget_get_type ())
</MACRO>
<MACRO>
<NAME>GANV_WIDGET</NAME>
#define GANV_WIDGET(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GANV_TYPE_WIDGET, GanvWidget))
</MACRO>
<MACRO>
<NAME>GANV_WIDGET_CLASS</NAME>
#define GANV_WIDGET_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GANV_TYPE_WIDGET, GanvWidgetClass))
</MACRO>
<MACRO>
<NAME>GANV_IS_WIDGET</NAME>
#define GANV_IS_WIDGET(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GANV_TYPE_WIDGET))
</MACRO>
<MACRO>
<NAME>GANV_IS_WIDGET_CLASS</NAME>
#define GANV_IS_WIDGET_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GANV_TYPE_WIDGET))
</MACRO>
<MACRO>
<NAME>GANV_WIDGET_GET_CLASS</NAME>
#define GANV_WIDGET_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GANV_TYPE_WIDGET, GanvWidgetClass))
</MACRO>
<STRUCT>
<NAME>GanvWidget</NAME>
struct _GanvWidget {
	GanvItem        item;
	GanvWidgetImpl* impl;
};
</STRUCT>
<STRUCT>
<NAME>GanvWidgetClass</NAME>
struct _GanvWidgetClass {
	GanvItemClass parent_class;

	/* Reserved for future expansion */
	gpointer spare_vmethods [4];
};
</STRUCT>
<FUNCTION>
<NAME>ganv_widget_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GanvWidgetImpl</NAME>
</STRUCT>
<MACRO>
<NAME>GANV_TYPE_TEXT</NAME>
#define GANV_TYPE_TEXT            (ganv_text_get_type())
</MACRO>
<MACRO>
<NAME>GANV_TEXT</NAME>
#define GANV_TEXT(obj)            (GTK_CHECK_CAST((obj), GANV_TYPE_TEXT, GanvText))
</MACRO>
<MACRO>
<NAME>GANV_TEXT_CLASS</NAME>
#define GANV_TEXT_CLASS(klass)    (GTK_CHECK_CLASS_CAST((klass), GANV_TYPE_TEXT, GanvTextClass))
</MACRO>
<MACRO>
<NAME>GANV_IS_TEXT</NAME>
#define GANV_IS_TEXT(obj)         (GTK_CHECK_TYPE((obj), GANV_TYPE_TEXT))
</MACRO>
<MACRO>
<NAME>GANV_IS_TEXT_CLASS</NAME>
#define GANV_IS_TEXT_CLASS(klass) (GTK_CHECK_CLASS_TYPE((klass), GANV_TYPE_TEXT))
</MACRO>
<MACRO>
<NAME>GANV_TEXT_GET_CLASS</NAME>
#define GANV_TEXT_GET_CLASS(obj)  (GTK_CHECK_GET_CLASS((obj), GANV_TYPE_TEXT, GanvTextClass))
</MACRO>
<STRUCT>
<NAME>GanvText</NAME>
struct _GanvText {
	GanvItem      item;
	GanvTextImpl* impl;
};
</STRUCT>
<STRUCT>
<NAME>GanvTextClass</NAME>
struct _GanvTextClass {
	GanvItemClass parent_class;

	/* Reserved for future expansion */
	gpointer spare_vmethodsx[4];
};
</STRUCT>
<FUNCTION>
<NAME>ganv_text_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ganv_text_layout</NAME>
<RETURNS>void  </RETURNS>
GanvText* text
</FUNCTION>
<STRUCT>
<NAME>GanvTextImpl</NAME>
</STRUCT>
<MACRO>
<NAME>GANV_TYPE_PORT</NAME>
#define GANV_TYPE_PORT            (ganv_port_get_type())
</MACRO>
<MACRO>
<NAME>GANV_PORT</NAME>
#define GANV_PORT(obj)            (GTK_CHECK_CAST((obj), GANV_TYPE_PORT, GanvPort))
</MACRO>
<MACRO>
<NAME>GANV_PORT_CLASS</NAME>
#define GANV_PORT_CLASS(klass)    (GTK_CHECK_CLASS_CAST((klass), GANV_TYPE_PORT, GanvPortClass))
</MACRO>
<MACRO>
<NAME>GANV_IS_PORT</NAME>
#define GANV_IS_PORT(obj)         (GTK_CHECK_TYPE((obj), GANV_TYPE_PORT))
</MACRO>
<MACRO>
<NAME>GANV_IS_PORT_CLASS</NAME>
#define GANV_IS_PORT_CLASS(klass) (GTK_CHECK_CLASS_TYPE((klass), GANV_TYPE_PORT))
</MACRO>
<MACRO>
<NAME>GANV_PORT_GET_CLASS</NAME>
#define GANV_PORT_GET_CLASS(obj)  (GTK_CHECK_GET_CLASS((obj), GANV_TYPE_PORT, GanvPortClass))
</MACRO>
<STRUCT>
<NAME>GanvPort</NAME>
struct _GanvPort {
	GanvBox       box;
	GanvPortImpl* impl;
};
</STRUCT>
<STRUCT>
<NAME>GanvPortClass</NAME>
struct _GanvPortClass {
	GanvBoxClass parent_class;

	/* Reserved for future expansion */
	gpointer spare_vmethods[4];
};
</STRUCT>
<FUNCTION>
<NAME>ganv_port_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ganv_port_new</NAME>
<RETURNS>GanvPort *</RETURNS>
GanvModule* module, gboolean    is_input, const char* first_prop_name, ...
</FUNCTION>
<FUNCTION>
<NAME>ganv_port_set_value_label</NAME>
<RETURNS>void </RETURNS>
GanvPort*   port, const char* str
</FUNCTION>
<FUNCTION>
<NAME>ganv_port_show_control</NAME>
<RETURNS>void </RETURNS>
GanvPort* port
</FUNCTION>
<FUNCTION>
<NAME>ganv_port_hide_control</NAME>
<RETURNS>void </RETURNS>
GanvPort* port
</FUNCTION>
<FUNCTION>
<NAME>ganv_port_set_control_is_toggle</NAME>
<RETURNS>void </RETURNS>
GanvPort* port, gboolean  is_toggle
</FUNCTION>
<FUNCTION>
<NAME>ganv_port_set_control_is_integer</NAME>
<RETURNS>void </RETURNS>
GanvPort* port, gboolean  is_integer
</FUNCTION>
<FUNCTION>
<NAME>ganv_port_set_control_value</NAME>
<RETURNS>void </RETURNS>
GanvPort* port, float     value
</FUNCTION>
<FUNCTION>
<NAME>ganv_port_set_control_min</NAME>
<RETURNS>void </RETURNS>
GanvPort* port, float     min
</FUNCTION>
<FUNCTION>
<NAME>ganv_port_set_control_max</NAME>
<RETURNS>void </RETURNS>
GanvPort* port, float     max
</FUNCTION>
<FUNCTION>
<NAME>ganv_port_get_natural_width</NAME>
<RETURNS>double </RETURNS>
const GanvPort* port
</FUNCTION>
<FUNCTION>
<NAME>ganv_port_get_module</NAME>
<RETURNS>GanvModule * </RETURNS>
const GanvPort* port
</FUNCTION>
<FUNCTION>
<NAME>ganv_port_get_control_value</NAME>
<RETURNS>float     </RETURNS>
const GanvPort* port
</FUNCTION>
<FUNCTION>
<NAME>ganv_port_get_control_min</NAME>
<RETURNS>float     </RETURNS>
const GanvPort* port
</FUNCTION>
<FUNCTION>
<NAME>ganv_port_get_control_max</NAME>
<RETURNS>float     </RETURNS>
const GanvPort* port
</FUNCTION>
<FUNCTION>
<NAME>ganv_port_is_input</NAME>
<RETURNS>gboolean  </RETURNS>
const GanvPort* port
</FUNCTION>
<FUNCTION>
<NAME>ganv_port_is_output</NAME>
<RETURNS>gboolean  </RETURNS>
const GanvPort* port
</FUNCTION>
<STRUCT>
<NAME>GanvPortImpl</NAME>
</STRUCT>
<MACRO>
<NAME>GANV_TYPE_NODE</NAME>
#define GANV_TYPE_NODE            (ganv_node_get_type())
</MACRO>
<MACRO>
<NAME>GANV_NODE</NAME>
#define GANV_NODE(obj)            (GTK_CHECK_CAST((obj), GANV_TYPE_NODE, GanvNode))
</MACRO>
<MACRO>
<NAME>GANV_NODE_CLASS</NAME>
#define GANV_NODE_CLASS(klass)    (GTK_CHECK_CLASS_CAST((klass), GANV_TYPE_NODE, GanvNodeClass))
</MACRO>
<MACRO>
<NAME>GANV_IS_NODE</NAME>
#define GANV_IS_NODE(obj)         (GTK_CHECK_TYPE((obj), GANV_TYPE_NODE))
</MACRO>
<MACRO>
<NAME>GANV_IS_NODE_CLASS</NAME>
#define GANV_IS_NODE_CLASS(klass) (GTK_CHECK_CLASS_TYPE((klass), GANV_TYPE_NODE))
</MACRO>
<MACRO>
<NAME>GANV_NODE_GET_CLASS</NAME>
#define GANV_NODE_GET_CLASS(obj)  (GTK_CHECK_GET_CLASS((obj), GANV_TYPE_NODE, GanvNodeClass))
</MACRO>
<STRUCT>
<NAME>GanvNode</NAME>
struct _GanvNode {
	GanvItem      item;
	GanvNodeImpl* impl;
};
</STRUCT>
<STRUCT>
<NAME>GanvNodeClass</NAME>
struct _GanvNodeClass {
	GanvItemClass parent_class;

	void (*tick)(GanvNode* self,
	             double    seconds);

	void (*move)(GanvNode* node,
	             double    dx,
	             double    dy);

	void (*move_to)(GanvNode* node,
	                double    x,
	                double    y);

	void (*resize)(GanvNode* node);

	void (*redraw_text)(GanvNode* node);

	void (*disconnect)(GanvNode* node);

	gboolean (*is_within)(const GanvNode* self,
	                      double          x1,
	                      double          y1,
	                      double          x2,
	                      double          y2);

	void (*tail_vector)(const GanvNode* self,
	                    const GanvNode* head,
	                    double*         x,
	                    double*         y,
	                    double*         dx,
	                    double*         dy);

	void (*head_vector)(const GanvNode* self,
	                    const GanvNode* tail,
	                    double*         x,
	                    double*         y,
	                    double*         dx,
	                    double*         dy);

	/* Reserved for future expansion */
	gpointer spare_vmethods[4];
};
</STRUCT>
<FUNCTION>
<NAME>ganv_node_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ganv_node_can_tail</NAME>
<RETURNS>gboolean </RETURNS>
const GanvNode* node
</FUNCTION>
<FUNCTION>
<NAME>ganv_node_can_head</NAME>
<RETURNS>gboolean </RETURNS>
const GanvNode* node
</FUNCTION>
<FUNCTION>
<NAME>ganv_node_set_is_source</NAME>
<RETURNS>void </RETURNS>
const GanvNode* node, gboolean is_source
</FUNCTION>
<FUNCTION>
<NAME>ganv_node_is_within</NAME>
<RETURNS>gboolean </RETURNS>
const GanvNode* node, double          x1, double          y1, double          x2, double          y2
</FUNCTION>
<FUNCTION>
<NAME>ganv_node_get_label</NAME>
<RETURNS>const char * </RETURNS>
const GanvNode* node
</FUNCTION>
<FUNCTION>
<NAME>ganv_node_get_border_width</NAME>
<RETURNS>double  </RETURNS>
const GanvNode* node
</FUNCTION>
<FUNCTION>
<NAME>ganv_node_set_border_width</NAME>
<RETURNS>void  </RETURNS>
const GanvNode* node, double border_width
</FUNCTION>
<FUNCTION>
<NAME>ganv_node_get_dash_length</NAME>
<RETURNS>double  </RETURNS>
const GanvNode* node
</FUNCTION>
<FUNCTION>
<NAME>ganv_node_set_dash_length</NAME>
<RETURNS>void  </RETURNS>
const GanvNode* node, double dash_length
</FUNCTION>
<FUNCTION>
<NAME>ganv_node_get_dash_offset</NAME>
<RETURNS>double  </RETURNS>
const GanvNode* node
</FUNCTION>
<FUNCTION>
<NAME>ganv_node_set_dash_offset</NAME>
<RETURNS>void  </RETURNS>
const GanvNode* node, double dash_offset
</FUNCTION>
<FUNCTION>
<NAME>ganv_node_get_fill_color</NAME>
<RETURNS>guint  </RETURNS>
const GanvNode* node
</FUNCTION>
<FUNCTION>
<NAME>ganv_node_set_fill_color</NAME>
<RETURNS>void  </RETURNS>
const GanvNode* node, guint fill_color
</FUNCTION>
<FUNCTION>
<NAME>ganv_node_get_border_color</NAME>
<RETURNS>guint  </RETURNS>
const GanvNode* node
</FUNCTION>
<FUNCTION>
<NAME>ganv_node_set_border_color</NAME>
<RETURNS>void  </RETURNS>
const GanvNode* node, guint border_color
</FUNCTION>
<FUNCTION>
<NAME>ganv_node_get_partner</NAME>
<RETURNS>GanvNode *</RETURNS>
const GanvNode* node
</FUNCTION>
<FUNCTION>
<NAME>ganv_node_set_label</NAME>
<RETURNS>void  </RETURNS>
GanvNode* node, const char* str
</FUNCTION>
<FUNCTION>
<NAME>ganv_node_set_show_label</NAME>
<RETURNS>void  </RETURNS>
GanvNode* node, gboolean show
</FUNCTION>
<FUNCTION>
<NAME>ganv_node_move</NAME>
<RETURNS>void </RETURNS>
GanvNode* node, double    dx, double    dy
</FUNCTION>
<FUNCTION>
<NAME>ganv_node_move_to</NAME>
<RETURNS>void </RETURNS>
GanvNode* node, double    x, double    y
</FUNCTION>
<FUNCTION>
<NAME>ganv_node_resize</NAME>
<RETURNS>void </RETURNS>
GanvNode* node
</FUNCTION>
<FUNCTION>
<NAME>ganv_node_redraw_text</NAME>
<RETURNS>void </RETURNS>
GanvNode* node
</FUNCTION>
<FUNCTION>
<NAME>ganv_node_disconnect</NAME>
<RETURNS>void </RETURNS>
GanvNode* node
</FUNCTION>
<FUNCTION>
<NAME>ganv_node_is_selected</NAME>
<RETURNS>gboolean </RETURNS>
GanvNode* node
</FUNCTION>
<STRUCT>
<NAME>GanvNodeImpl</NAME>
</STRUCT>
<MACRO>
<NAME>GANV_TYPE_MODULE</NAME>
#define GANV_TYPE_MODULE            (ganv_module_get_type())
</MACRO>
<MACRO>
<NAME>GANV_MODULE</NAME>
#define GANV_MODULE(obj)            (GTK_CHECK_CAST((obj), GANV_TYPE_MODULE, GanvModule))
</MACRO>
<MACRO>
<NAME>GANV_MODULE_CLASS</NAME>
#define GANV_MODULE_CLASS(klass)    (GTK_CHECK_CLASS_CAST((klass), GANV_TYPE_MODULE, GanvModuleClass))
</MACRO>
<MACRO>
<NAME>GANV_IS_MODULE</NAME>
#define GANV_IS_MODULE(obj)         (GTK_CHECK_TYPE((obj), GANV_TYPE_MODULE))
</MACRO>
<MACRO>
<NAME>GANV_IS_MODULE_CLASS</NAME>
#define GANV_IS_MODULE_CLASS(klass) (GTK_CHECK_CLASS_TYPE((klass), GANV_TYPE_MODULE))
</MACRO>
<MACRO>
<NAME>GANV_MODULE_GET_CLASS</NAME>
#define GANV_MODULE_GET_CLASS(obj)  (GTK_CHECK_GET_CLASS((obj), GANV_TYPE_MODULE, GanvModuleClass))
</MACRO>
<USER_FUNCTION>
<NAME>GanvPortFunc</NAME>
<RETURNS>void </RETURNS>
GanvPort* port, void* data
</USER_FUNCTION>
<STRUCT>
<NAME>GanvModule</NAME>
struct _GanvModule {
	GanvBox         box;
	GanvModuleImpl* impl;
};
</STRUCT>
<STRUCT>
<NAME>GanvModuleClass</NAME>
struct _GanvModuleClass {
	GanvBoxClass parent_class;

	/* Reserved for future expansion */
	gpointer spare_vmethods[4];
};
</STRUCT>
<FUNCTION>
<NAME>ganv_module_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ganv_module_new</NAME>
<RETURNS>GanvModule *</RETURNS>
GanvCanvas* canvas, const char* first_prop_name, ...
</FUNCTION>
<FUNCTION>
<NAME>ganv_module_num_ports</NAME>
<RETURNS>guint </RETURNS>
const GanvModule* module
</FUNCTION>
<FUNCTION>
<NAME>ganv_module_get_port</NAME>
<RETURNS>GanvPort *</RETURNS>
GanvModule* module, guint       index
</FUNCTION>
<FUNCTION>
<NAME>ganv_module_get_empty_port_breadth</NAME>
<RETURNS>double </RETURNS>
const GanvModule* module
</FUNCTION>
<FUNCTION>
<NAME>ganv_module_get_empty_port_depth</NAME>
<RETURNS>double </RETURNS>
const GanvModule* module
</FUNCTION>
<FUNCTION>
<NAME>ganv_module_embed</NAME>
<RETURNS>void </RETURNS>
GanvModule* module, GtkWidget* widget
</FUNCTION>
<FUNCTION>
<NAME>ganv_module_set_direction</NAME>
<RETURNS>void </RETURNS>
GanvModule* module, GanvDirection direction
</FUNCTION>
<FUNCTION>
<NAME>ganv_module_for_each_port</NAME>
<RETURNS>void </RETURNS>
GanvModule*  module, GanvPortFunc f, void*        data
</FUNCTION>
<STRUCT>
<NAME>GanvModuleImpl</NAME>
</STRUCT>
<MACRO>
<NAME>GANV_TYPE_ITEM</NAME>
#define GANV_TYPE_ITEM            (ganv_item_get_type())
</MACRO>
<MACRO>
<NAME>GANV_ITEM</NAME>
#define GANV_ITEM(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), GANV_TYPE_ITEM, GanvItem))
</MACRO>
<MACRO>
<NAME>GANV_ITEM_CLASS</NAME>
#define GANV_ITEM_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), GANV_TYPE_ITEM, GanvItemClass))
</MACRO>
<MACRO>
<NAME>GANV_IS_ITEM</NAME>
#define GANV_IS_ITEM(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), GANV_TYPE_ITEM))
</MACRO>
<MACRO>
<NAME>GANV_IS_ITEM_CLASS</NAME>
#define GANV_IS_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GANV_TYPE_ITEM))
</MACRO>
<MACRO>
<NAME>GANV_ITEM_GET_CLASS</NAME>
#define GANV_ITEM_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), GANV_TYPE_ITEM, GanvItemClass))
</MACRO>
<STRUCT>
<NAME>GanvItem</NAME>
struct _GanvItem {
	GtkObject     object;
	GanvItemImpl* impl;
};
</STRUCT>
<STRUCT>
<NAME>GanvItemClass</NAME>
struct _GanvItemClass {
	GtkObjectClass parent_class;

	/* Add a child to this item (optional). */
	void (*add)(GanvItem* item, GanvItem* child);

	/* Remove a child from this item (optional). */
	void (*remove)(GanvItem* item, GanvItem* child);

	/* Tell the item to update itself.
	 *
	 * The flags are from the update flags defined above.  The item should
	 * update its internal state from its queued state, and recompute and
	 * request its repaint area.  The update method also recomputes the
	 * bounding box of the item.
	 */
	void (*update)(GanvItem* item, int flags);

	/* Realize an item (create GCs, etc.). */
	void (*realize)(GanvItem* item);

	/* Unrealize an item. */
	void (*unrealize)(GanvItem* item);

	/* Map an item - normally only need by items with their own GdkWindows. */
	void (*map)(GanvItem* item);

	/* Unmap an item */
	void (*unmap)(GanvItem* item);

	/* Draw an item of this type.
	 *
	 * (cx, cy) and (width, height) describe the rectangle being drawn in
	 * world-relative coordinates.
	 */
	void (*draw)(GanvItem* item,
	             cairo_t*  cr,
	             double    cx,
	             double    cy,
	             double    cw,
	             double    ch);

	/* Calculate the distance from an item to the specified point.
	 *
	 * It also returns a canvas item which is actual item the point is within,
	 * which may not be equal to @item if @item has children.
	 * (x, y) are item-relative coordinates.
	 */
	double (*point)(GanvItem*  item,
	                double     x,
	                double     y,
	                GanvItem** actual_item);

	/* Fetch the item's bounding box (need not be exactly tight).
	 *
	 * This should be in item-relative coordinates.
	 */
	void (*bounds)(GanvItem* item, double* x1, double* y1, double* x2, double* y2);

	/* Signal: an event occurred for an item of this type.
	 *
	 * The (x, y) coordinates are in the canvas world coordinate system.
	 */
	gboolean (*event)(GanvItem* item, GdkEvent* event);

	/* Reserved for future expansion */
	gpointer spare_vmethods[4];
};
</STRUCT>
<FUNCTION>
<NAME>ganv_item_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ganv_item_new</NAME>
<RETURNS>GanvItem * </RETURNS>
GanvItem* parent, GType type, const gchar* first_arg_name, ...
</FUNCTION>
<FUNCTION>
<NAME>ganv_item_construct</NAME>
<RETURNS>void  </RETURNS>
GanvItem* item, GanvItem* parent, const gchar* first_arg_name, va_list args
</FUNCTION>
<FUNCTION>
<NAME>ganv_item_set</NAME>
<RETURNS>void  </RETURNS>
GanvItem* item, const gchar* first_arg_name, ...
</FUNCTION>
<FUNCTION>
<NAME>ganv_item_set_valist</NAME>
<RETURNS>void  </RETURNS>
GanvItem* item, const gchar* first_arg_name, va_list args
</FUNCTION>
<FUNCTION>
<NAME>ganv_item_get_canvas</NAME>
<RETURNS>struct _GanvCanvas * </RETURNS>
GanvItem* item
</FUNCTION>
<FUNCTION>
<NAME>ganv_item_get_parent</NAME>
<RETURNS>GanvItem * </RETURNS>
GanvItem* item
</FUNCTION>
<FUNCTION>
<NAME>ganv_item_raise</NAME>
<RETURNS>void  </RETURNS>
GanvItem* item
</FUNCTION>
<FUNCTION>
<NAME>ganv_item_lower</NAME>
<RETURNS>void  </RETURNS>
GanvItem* item
</FUNCTION>
<FUNCTION>
<NAME>ganv_item_move</NAME>
<RETURNS>void  </RETURNS>
GanvItem* item, double dx, double dy
</FUNCTION>
<FUNCTION>
<NAME>ganv_item_show</NAME>
<RETURNS>void  </RETURNS>
GanvItem* item
</FUNCTION>
<FUNCTION>
<NAME>ganv_item_hide</NAME>
<RETURNS>void  </RETURNS>
GanvItem* item
</FUNCTION>
<FUNCTION>
<NAME>ganv_item_i2w</NAME>
<RETURNS>void  </RETURNS>
GanvItem* item, double* x, double* y
</FUNCTION>
<FUNCTION>
<NAME>ganv_item_w2i</NAME>
<RETURNS>void  </RETURNS>
GanvItem* item, double* x, double* y
</FUNCTION>
<FUNCTION>
<NAME>ganv_item_grab_focus</NAME>
<RETURNS>void  </RETURNS>
GanvItem* item
</FUNCTION>
<FUNCTION>
<NAME>ganv_item_get_bounds</NAME>
<RETURNS>void  </RETURNS>
GanvItem* item, double* x1, double* y1, double* x2, double* y2
</FUNCTION>
<FUNCTION>
<NAME>ganv_item_request_update</NAME>
<RETURNS>void  </RETURNS>
GanvItem* item
</FUNCTION>
<STRUCT>
<NAME>GanvItemImpl</NAME>
</STRUCT>
<MACRO>
<NAME>GANV_TYPE_GROUP</NAME>
#define GANV_TYPE_GROUP            (ganv_group_get_type())
</MACRO>
<MACRO>
<NAME>GANV_GROUP</NAME>
#define GANV_GROUP(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), GANV_TYPE_GROUP, GanvGroup))
</MACRO>
<MACRO>
<NAME>GANV_GROUP_CLASS</NAME>
#define GANV_GROUP_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), GANV_TYPE_GROUP, GanvGroupClass))
</MACRO>
<MACRO>
<NAME>GANV_IS_GROUP</NAME>
#define GANV_IS_GROUP(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), GANV_TYPE_GROUP))
</MACRO>
<MACRO>
<NAME>GANV_IS_GROUP_CLASS</NAME>
#define GANV_IS_GROUP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GANV_TYPE_GROUP))
</MACRO>
<MACRO>
<NAME>GANV_GROUP_GET_CLASS</NAME>
#define GANV_GROUP_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), GANV_TYPE_GROUP, GanvGroupClass))
</MACRO>
<STRUCT>
<NAME>GanvGroup</NAME>
struct _GanvGroup {
	GanvItem       item;
	GanvGroupImpl* impl;
};
</STRUCT>
<STRUCT>
<NAME>GanvGroupClass</NAME>
struct _GanvGroupClass {
	GanvItemClass parent_class;

	/* Reserved for future expansion */
	gpointer spare_vmethods[4];
};
</STRUCT>
<FUNCTION>
<NAME>ganv_group_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GanvGroupImpl</NAME>
</STRUCT>
<MACRO>
<NAME>GANV_TYPE_EDGE</NAME>
#define GANV_TYPE_EDGE            (ganv_edge_get_type())
</MACRO>
<MACRO>
<NAME>GANV_EDGE</NAME>
#define GANV_EDGE(obj)            (GTK_CHECK_CAST((obj), GANV_TYPE_EDGE, GanvEdge))
</MACRO>
<MACRO>
<NAME>GANV_EDGE_CLASS</NAME>
#define GANV_EDGE_CLASS(klass)    (GTK_CHECK_CLASS_CAST((klass), GANV_TYPE_EDGE, GanvEdgeClass))
</MACRO>
<MACRO>
<NAME>GANV_IS_EDGE</NAME>
#define GANV_IS_EDGE(obj)         (GTK_CHECK_TYPE((obj), GANV_TYPE_EDGE))
</MACRO>
<MACRO>
<NAME>GANV_IS_EDGE_CLASS</NAME>
#define GANV_IS_EDGE_CLASS(klass) (GTK_CHECK_CLASS_TYPE((klass), GANV_TYPE_EDGE))
</MACRO>
<MACRO>
<NAME>GANV_EDGE_GET_CLASS</NAME>
#define GANV_EDGE_GET_CLASS(obj)  (GTK_CHECK_GET_CLASS((obj), GANV_TYPE_EDGE, GanvEdgeClass))
</MACRO>
<STRUCT>
<NAME>GanvEdge</NAME>
struct _GanvEdge {
	GanvItem      item;
	GanvEdgeImpl* impl;
};
</STRUCT>
<STRUCT>
<NAME>GanvEdgeClass</NAME>
struct _GanvEdgeClass {
	GanvItemClass parent_class;

	/* Reserved for future expansion */
	gpointer spare_vmethods[4];
};
</STRUCT>
<FUNCTION>
<NAME>ganv_edge_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ganv_edge_new</NAME>
<RETURNS>GanvEdge *</RETURNS>
GanvCanvas* canvas, GanvNode*   tail, GanvNode*   head, const char* first_prop_name, ...
</FUNCTION>
<FUNCTION>
<NAME>ganv_edge_is_within</NAME>
<RETURNS>gboolean </RETURNS>
const GanvEdge* edge, double          x1, double          y1, double          x2, double          y2
</FUNCTION>
<FUNCTION>
<NAME>ganv_edge_get_curved</NAME>
<RETURNS>gboolean </RETURNS>
const GanvEdge* edge
</FUNCTION>
<FUNCTION>
<NAME>ganv_edge_set_curved</NAME>
<RETURNS>void </RETURNS>
GanvEdge* edge, gboolean curved
</FUNCTION>
<FUNCTION>
<NAME>ganv_edge_set_selected</NAME>
<RETURNS>void </RETURNS>
GanvEdge* edge, gboolean selected
</FUNCTION>
<FUNCTION>
<NAME>ganv_edge_set_highlighted</NAME>
<RETURNS>void </RETURNS>
GanvEdge* edge, gboolean highlighted
</FUNCTION>
<FUNCTION>
<NAME>ganv_edge_select</NAME>
<RETURNS>void </RETURNS>
GanvEdge* edge
</FUNCTION>
<FUNCTION>
<NAME>ganv_edge_unselect</NAME>
<RETURNS>void </RETURNS>
GanvEdge* edge
</FUNCTION>
<FUNCTION>
<NAME>ganv_edge_disconnect</NAME>
<RETURNS>void </RETURNS>
GanvEdge* edge
</FUNCTION>
<FUNCTION>
<NAME>ganv_edge_remove</NAME>
<RETURNS>void </RETURNS>
GanvEdge* edge
</FUNCTION>
<FUNCTION>
<NAME>ganv_edge_get_tail</NAME>
<RETURNS>GanvNode *</RETURNS>
const GanvEdge* edge
</FUNCTION>
<FUNCTION>
<NAME>ganv_edge_get_head</NAME>
<RETURNS>GanvNode *</RETURNS>
const GanvEdge* edge
</FUNCTION>
<STRUCT>
<NAME>GanvEdgeImpl</NAME>
</STRUCT>
<MACRO>
<NAME>GANV_TYPE_CIRCLE</NAME>
#define GANV_TYPE_CIRCLE            (ganv_circle_get_type())
</MACRO>
<MACRO>
<NAME>GANV_CIRCLE</NAME>
#define GANV_CIRCLE(obj)            (GTK_CHECK_CAST((obj), GANV_TYPE_CIRCLE, GanvCircle))
</MACRO>
<MACRO>
<NAME>GANV_CIRCLE_CLASS</NAME>
#define GANV_CIRCLE_CLASS(klass)    (GTK_CHECK_CLASS_CAST((klass), GANV_TYPE_CIRCLE, GanvCircleClass))
</MACRO>
<MACRO>
<NAME>GANV_IS_CIRCLE</NAME>
#define GANV_IS_CIRCLE(obj)         (GTK_CHECK_TYPE((obj), GANV_TYPE_CIRCLE))
</MACRO>
<MACRO>
<NAME>GANV_IS_CIRCLE_CLASS</NAME>
#define GANV_IS_CIRCLE_CLASS(klass) (GTK_CHECK_CLASS_TYPE((klass), GANV_TYPE_CIRCLE))
</MACRO>
<MACRO>
<NAME>GANV_CIRCLE_GET_CLASS</NAME>
#define GANV_CIRCLE_GET_CLASS(obj)  (GTK_CHECK_GET_CLASS((obj), GANV_TYPE_CIRCLE, GanvCircleClass))
</MACRO>
<STRUCT>
<NAME>GanvCircle</NAME>
struct _GanvCircle {
	GanvNode        node;
	GanvCircleImpl* impl;
};
</STRUCT>
<STRUCT>
<NAME>GanvCircleClass</NAME>
struct _GanvCircleClass {
	GanvNodeClass parent_class;

	/* Reserved for future expansion */
	gpointer spare_vmethods[4];
};
</STRUCT>
<FUNCTION>
<NAME>ganv_circle_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ganv_circle_new</NAME>
<RETURNS>GanvCircle *</RETURNS>
GanvCanvas* canvas, const char* first_prop_name, ...
</FUNCTION>
<FUNCTION>
<NAME>ganv_circle_get_radius</NAME>
<RETURNS>double </RETURNS>
const GanvCircle* circle
</FUNCTION>
<FUNCTION>
<NAME>ganv_circle_set_radius</NAME>
<RETURNS>void </RETURNS>
GanvCircle* circle, double radius
</FUNCTION>
<FUNCTION>
<NAME>ganv_circle_get_radius_ems</NAME>
<RETURNS>double </RETURNS>
const GanvCircle* circle
</FUNCTION>
<FUNCTION>
<NAME>ganv_circle_set_radius_ems</NAME>
<RETURNS>void </RETURNS>
GanvCircle* circle, double radius
</FUNCTION>
<FUNCTION>
<NAME>ganv_circle_get_fit_label</NAME>
<RETURNS>gboolean </RETURNS>
const GanvCircle* circle
</FUNCTION>
<FUNCTION>
<NAME>ganv_circle_set_fit_label</NAME>
<RETURNS>void </RETURNS>
GanvCircle* circle, gboolean fit_label
</FUNCTION>
<STRUCT>
<NAME>GanvCircleImpl</NAME>
</STRUCT>
<MACRO>
<NAME>GANV_TYPE_CANVAS</NAME>
#define GANV_TYPE_CANVAS            (ganv_canvas_get_type())
</MACRO>
<MACRO>
<NAME>GANV_CANVAS</NAME>
#define GANV_CANVAS(obj)            (GTK_CHECK_CAST((obj), GANV_TYPE_CANVAS, GanvCanvas))
</MACRO>
<MACRO>
<NAME>GANV_CANVAS_CLASS</NAME>
#define GANV_CANVAS_CLASS(klass)    (GTK_CHECK_CLASS_CAST((klass), GANV_TYPE_CANVAS, GanvCanvasClass))
</MACRO>
<MACRO>
<NAME>GANV_IS_CANVAS</NAME>
#define GANV_IS_CANVAS(obj)         (GTK_CHECK_TYPE((obj), GANV_TYPE_CANVAS))
</MACRO>
<MACRO>
<NAME>GANV_IS_CANVAS_CLASS</NAME>
#define GANV_IS_CANVAS_CLASS(klass) (GTK_CHECK_CLASS_TYPE((klass), GANV_TYPE_CANVAS))
</MACRO>
<MACRO>
<NAME>GANV_CANVAS_GET_CLASS</NAME>
#define GANV_CANVAS_GET_CLASS(obj)  (GTK_CHECK_GET_CLASS((obj), GANV_TYPE_CANVAS, GanvCanvasClass))
</MACRO>
<TYPEDEF>
<NAME>GanvCanvasImpl</NAME>
typedef struct GanvCanvasImpl   GanvCanvasImpl;
</TYPEDEF>
<ENUM>
<NAME>GanvDirection</NAME>
typedef enum {
	GANV_DIRECTION_DOWN,
	GANV_DIRECTION_RIGHT
} GanvDirection;
</ENUM>
<STRUCT>
<NAME>GanvCanvas</NAME>
struct _GanvCanvas {
	GtkLayout       layout;
	GanvCanvasImpl* impl;
};
</STRUCT>
<STRUCT>
<NAME>GanvCanvasClass</NAME>
struct _GanvCanvasClass {
	GtkLayoutClass parent_class;

	/* Reserved for future expansion */
	gpointer spare_vmethods[4];
};
</STRUCT>
<FUNCTION>
<NAME>ganv_canvas_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<USER_FUNCTION>
<NAME>GanvEdgeFunc</NAME>
<RETURNS>void </RETURNS>
GanvEdge* edge, void* data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GanvNodeFunc</NAME>
<RETURNS>void </RETURNS>
GanvNode* node, void* data
</USER_FUNCTION>
<FUNCTION>
<NAME>ganv_canvas_new</NAME>
<RETURNS>GanvCanvas *</RETURNS>
double width, double height
</FUNCTION>
<FUNCTION>
<NAME>ganv_canvas_clear</NAME>
<RETURNS>void </RETURNS>
GanvCanvas* canvas
</FUNCTION>
<FUNCTION>
<NAME>ganv_canvas_empty</NAME>
<RETURNS>gboolean </RETURNS>
const GanvCanvas* canvas
</FUNCTION>
<FUNCTION>
<NAME>ganv_canvas_resize</NAME>
<RETURNS>void </RETURNS>
GanvCanvas* canvas, double width, double height
</FUNCTION>
<FUNCTION>
<NAME>ganv_canvas_root</NAME>
<RETURNS>GanvItem *</RETURNS>
GanvCanvas* canvas
</FUNCTION>
<FUNCTION>
<NAME>ganv_canvas_set_scroll_region</NAME>
<RETURNS>void </RETURNS>
GanvCanvas* canvas, double x1, double y1, double x2, double y2
</FUNCTION>
<FUNCTION>
<NAME>ganv_canvas_get_scroll_region</NAME>
<RETURNS>void </RETURNS>
GanvCanvas* canvas, double* x1, double* y1, double* x2, double* y2
</FUNCTION>
<FUNCTION>
<NAME>ganv_canvas_set_center_scroll_region</NAME>
<RETURNS>void </RETURNS>
GanvCanvas* canvas, gboolean    center_scroll_region
</FUNCTION>
<FUNCTION>
<NAME>ganv_canvas_get_center_scroll_region</NAME>
<RETURNS>gboolean </RETURNS>
const GanvCanvas* canvas
</FUNCTION>
<FUNCTION>
<NAME>ganv_canvas_scroll_to</NAME>
<RETURNS>void </RETURNS>
GanvCanvas* canvas, int cx, int cy
</FUNCTION>
<FUNCTION>
<NAME>ganv_canvas_get_scroll_offsets</NAME>
<RETURNS>void </RETURNS>
const GanvCanvas* canvas, int* cx, int* cy
</FUNCTION>
<FUNCTION>
<NAME>ganv_canvas_w2c_affine</NAME>
<RETURNS>void </RETURNS>
GanvCanvas* canvas, cairo_matrix_t* matrix
</FUNCTION>
<FUNCTION>
<NAME>ganv_canvas_w2c</NAME>
<RETURNS>void </RETURNS>
GanvCanvas* canvas, double wx, double wy, int* cx, int* cy
</FUNCTION>
<FUNCTION>
<NAME>ganv_canvas_w2c_d</NAME>
<RETURNS>void </RETURNS>
GanvCanvas* canvas, double      wx, double      wy, double*     cx, double*     cy
</FUNCTION>
<FUNCTION>
<NAME>ganv_canvas_c2w</NAME>
<RETURNS>void </RETURNS>
GanvCanvas* canvas, int cx, int cy, double* wx, double* wy
</FUNCTION>
<FUNCTION>
<NAME>ganv_canvas_window_to_world</NAME>
<RETURNS>void </RETURNS>
GanvCanvas* canvas, double      winx, double      winy, double*     worldx, double*     worldy
</FUNCTION>
<FUNCTION>
<NAME>ganv_canvas_world_to_window</NAME>
<RETURNS>void </RETURNS>
GanvCanvas* canvas, double      worldx, double      worldy, double*     winx, double*     winy
</FUNCTION>
<FUNCTION>
<NAME>ganv_canvas_get_item_at</NAME>
<RETURNS>GanvItem *</RETURNS>
GanvCanvas* canvas, double x, double y
</FUNCTION>
<FUNCTION>
<NAME>ganv_canvas_get_edge</NAME>
<RETURNS>GanvEdge *</RETURNS>
GanvCanvas* canvas, GanvNode*   tail, GanvNode*   head
</FUNCTION>
<FUNCTION>
<NAME>ganv_canvas_remove_edge</NAME>
<RETURNS>void </RETURNS>
GanvCanvas* canvas, GanvEdge*   edge
</FUNCTION>
<FUNCTION>
<NAME>ganv_canvas_remove_edge_between</NAME>
<RETURNS>void </RETURNS>
GanvCanvas* canvas, GanvNode*   tail, GanvNode*   head
</FUNCTION>
<FUNCTION>
<NAME>ganv_canvas_get_direction</NAME>
<RETURNS>GanvDirection </RETURNS>
GanvCanvas* canvas
</FUNCTION>
<FUNCTION>
<NAME>ganv_canvas_set_direction</NAME>
<RETURNS>void </RETURNS>
GanvCanvas* canvas, GanvDirection dir
</FUNCTION>
<FUNCTION>
<NAME>ganv_canvas_arrange</NAME>
<RETURNS>void </RETURNS>
GanvCanvas* canvas
</FUNCTION>
<FUNCTION>
<NAME>ganv_canvas_export_dot</NAME>
<RETURNS>void </RETURNS>
GanvCanvas* canvas, const char* filename
</FUNCTION>
<FUNCTION>
<NAME>ganv_canvas_supports_sprung_layout</NAME>
<RETURNS>gboolean </RETURNS>
const GanvCanvas* canvas
</FUNCTION>
<FUNCTION>
<NAME>ganv_canvas_set_sprung_layout</NAME>
<RETURNS>gboolean </RETURNS>
GanvCanvas* canvas, gboolean sprung_layout
</FUNCTION>
<FUNCTION>
<NAME>ganv_canvas_get_locked</NAME>
<RETURNS>gboolean </RETURNS>
const GanvCanvas* canvas
</FUNCTION>
<FUNCTION>
<NAME>ganv_canvas_for_each_node</NAME>
<RETURNS>void </RETURNS>
GanvCanvas*  canvas, GanvNodeFunc f, void*        data
</FUNCTION>
<FUNCTION>
<NAME>ganv_canvas_for_each_selected_node</NAME>
<RETURNS>void </RETURNS>
GanvCanvas*  canvas, GanvNodeFunc f, void*        data
</FUNCTION>
<FUNCTION>
<NAME>ganv_canvas_for_each_edge</NAME>
<RETURNS>void </RETURNS>
GanvCanvas*  canvas, GanvEdgeFunc f, void*        data
</FUNCTION>
<FUNCTION>
<NAME>ganv_canvas_for_each_edge_from</NAME>
<RETURNS>void </RETURNS>
GanvCanvas*     canvas, const GanvNode* tail, GanvEdgeFunc    f, void*           data
</FUNCTION>
<FUNCTION>
<NAME>ganv_canvas_for_each_edge_to</NAME>
<RETURNS>void </RETURNS>
GanvCanvas*     canvas, const GanvNode* head, GanvEdgeFunc    f, void*           data
</FUNCTION>
<FUNCTION>
<NAME>ganv_canvas_for_each_edge_on</NAME>
<RETURNS>void </RETURNS>
GanvCanvas*     canvas, const GanvNode* node, GanvEdgeFunc    f, void*           data
</FUNCTION>
<FUNCTION>
<NAME>ganv_canvas_for_each_selected_edge</NAME>
<RETURNS>void </RETURNS>
GanvCanvas*  canvas, GanvEdgeFunc f, void*        data
</FUNCTION>
<FUNCTION>
<NAME>ganv_canvas_select_all</NAME>
<RETURNS>void </RETURNS>
GanvCanvas* canvas
</FUNCTION>
<FUNCTION>
<NAME>ganv_canvas_clear_selection</NAME>
<RETURNS>void </RETURNS>
GanvCanvas* canvas
</FUNCTION>
<FUNCTION>
<NAME>ganv_canvas_get_zoom</NAME>
<RETURNS>double </RETURNS>
const GanvCanvas* canvas
</FUNCTION>
<FUNCTION>
<NAME>ganv_canvas_set_zoom</NAME>
<RETURNS>void </RETURNS>
GanvCanvas* canvas, double zoom
</FUNCTION>
<FUNCTION>
<NAME>ganv_canvas_zoom_full</NAME>
<RETURNS>void </RETURNS>
GanvCanvas* canvas
</FUNCTION>
<FUNCTION>
<NAME>ganv_canvas_get_default_font_size</NAME>
<RETURNS>double </RETURNS>
const GanvCanvas* canvas
</FUNCTION>
<FUNCTION>
<NAME>ganv_canvas_get_font_size</NAME>
<RETURNS>double </RETURNS>
const GanvCanvas* canvas
</FUNCTION>
<FUNCTION>
<NAME>ganv_canvas_set_font_size</NAME>
<RETURNS>void </RETURNS>
GanvCanvas* canvas, double points
</FUNCTION>
<FUNCTION>
<NAME>ganv_canvas_get_move_cursor</NAME>
<RETURNS>GdkCursor *</RETURNS>
const GanvCanvas* canvas
</FUNCTION>
<FUNCTION>
<NAME>ganv_canvas_move_contents_to</NAME>
<RETURNS>void </RETURNS>
GanvCanvas* canvas, double x, double y
</FUNCTION>
<MACRO>
<NAME>GANV_TYPE_BOX</NAME>
#define GANV_TYPE_BOX            (ganv_box_get_type())
</MACRO>
<MACRO>
<NAME>GANV_BOX</NAME>
#define GANV_BOX(obj)            (GTK_CHECK_CAST((obj), GANV_TYPE_BOX, GanvBox))
</MACRO>
<MACRO>
<NAME>GANV_BOX_CLASS</NAME>
#define GANV_BOX_CLASS(klass)    (GTK_CHECK_CLASS_CAST((klass), GANV_TYPE_BOX, GanvBoxClass))
</MACRO>
<MACRO>
<NAME>GANV_IS_BOX</NAME>
#define GANV_IS_BOX(obj)         (GTK_CHECK_TYPE((obj), GANV_TYPE_BOX))
</MACRO>
<MACRO>
<NAME>GANV_IS_BOX_CLASS</NAME>
#define GANV_IS_BOX_CLASS(klass) (GTK_CHECK_CLASS_TYPE((klass), GANV_TYPE_BOX))
</MACRO>
<MACRO>
<NAME>GANV_BOX_GET_CLASS</NAME>
#define GANV_BOX_GET_CLASS(obj)  (GTK_CHECK_GET_CLASS((obj), GANV_TYPE_BOX, GanvBoxClass))
</MACRO>
<STRUCT>
<NAME>GanvBox</NAME>
struct _GanvBox {
	GanvNode     node;
	GanvBoxImpl* impl;
};
</STRUCT>
<STRUCT>
<NAME>GanvBoxClass</NAME>
struct _GanvBoxClass {
	GanvNodeClass parent_class;

	void (*set_width)(GanvBox* box,
	                  double   width);

	void (*set_height)(GanvBox* box,
	                   double   height);

	/* Reserved for future expansion */
	gpointer spare_vmethods[4];
};
</STRUCT>
<FUNCTION>
<NAME>ganv_box_get_type</NAME>
<RETURNS>GType   </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ganv_box_get_x1</NAME>
<RETURNS>double  </RETURNS>
const GanvBox* box
</FUNCTION>
<FUNCTION>
<NAME>ganv_box_get_y1</NAME>
<RETURNS>double  </RETURNS>
const GanvBox* box
</FUNCTION>
<FUNCTION>
<NAME>ganv_box_get_x2</NAME>
<RETURNS>double  </RETURNS>
const GanvBox* box
</FUNCTION>
<FUNCTION>
<NAME>ganv_box_get_y2</NAME>
<RETURNS>double  </RETURNS>
const GanvBox* box
</FUNCTION>
<FUNCTION>
<NAME>ganv_box_get_width</NAME>
<RETURNS>double  </RETURNS>
const GanvBox* box
</FUNCTION>
<FUNCTION>
<NAME>ganv_box_set_width</NAME>
<RETURNS>void    </RETURNS>
GanvBox* box, double width
</FUNCTION>
<FUNCTION>
<NAME>ganv_box_get_height</NAME>
<RETURNS>double  </RETURNS>
const GanvBox* box
</FUNCTION>
<FUNCTION>
<NAME>ganv_box_set_height</NAME>
<RETURNS>void    </RETURNS>
GanvBox* box, double height
</FUNCTION>
<FUNCTION>
<NAME>ganv_box_get_border_width</NAME>
<RETURNS>double  </RETURNS>
const GanvBox* box
</FUNCTION>
<FUNCTION>
<NAME>ganv_box_normalize</NAME>
<RETURNS>void  </RETURNS>
GanvBox* box
</FUNCTION>
<STRUCT>
<NAME>GanvBoxImpl</NAME>
</STRUCT>
