<FUNCTION>
<NAME>demo_find_file</NAME>
<RETURNS>gchar  *</RETURNS>
const gchar  *base,GError      **err
</FUNCTION>
<USER_FUNCTION>
<NAME>GDoDemoFunc</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkWidget *do_widget
</USER_FUNCTION>
<STRUCT>
<NAME>Demo</NAME>
</STRUCT>
<STRUCT>
<NAME>Demo</NAME>
struct Demo 
{
  gchar *title;
  gchar *filename;
  GDoDemoFunc func;
  Demo *children;
};
</STRUCT>
<FUNCTION>
<NAME>do_data_model_dir</NAME>
<RETURNS>GtkWidget  *</RETURNS>
GtkWidget *do_widget
</FUNCTION>
<FUNCTION>
<NAME>do_form</NAME>
<RETURNS>GtkWidget  *</RETURNS>
GtkWidget *do_widget
</FUNCTION>
<FUNCTION>
<NAME>do_form_rw</NAME>
<RETURNS>GtkWidget  *</RETURNS>
GtkWidget *do_widget
</FUNCTION>
<FUNCTION>
<NAME>do_form_pict</NAME>
<RETURNS>GtkWidget  *</RETURNS>
GtkWidget *do_widget
</FUNCTION>
<FUNCTION>
<NAME>do_grid</NAME>
<RETURNS>GtkWidget  *</RETURNS>
GtkWidget *do_widget
</FUNCTION>
<FUNCTION>
<NAME>do_grid_rw</NAME>
<RETURNS>GtkWidget  *</RETURNS>
GtkWidget *do_widget
</FUNCTION>
<FUNCTION>
<NAME>do_grid_pict</NAME>
<RETURNS>GtkWidget  *</RETURNS>
GtkWidget *do_widget
</FUNCTION>
<FUNCTION>
<NAME>do_linked_grid_form</NAME>
<RETURNS>GtkWidget  *</RETURNS>
GtkWidget *do_widget
</FUNCTION>
<FUNCTION>
<NAME>do_linked_model_param</NAME>
<RETURNS>GtkWidget  *</RETURNS>
GtkWidget *do_widget
</FUNCTION>
<FUNCTION>
<NAME>do_console</NAME>
<RETURNS>GtkWidget  *</RETURNS>
GtkWidget *do_widget
</FUNCTION>
<FUNCTION>
<NAME>do_selector</NAME>
<RETURNS>GtkWidget  *</RETURNS>
GtkWidget *do_widget
</FUNCTION>
<FUNCTION>
<NAME>do_ddl_queries</NAME>
<RETURNS>GtkWidget  *</RETURNS>
GtkWidget *do_widget
</FUNCTION>
<FUNCTION>
<NAME>do_graph</NAME>
<RETURNS>GtkWidget  *</RETURNS>
GtkWidget *do_widget
</FUNCTION>
<FUNCTION>
<NAME>dsn_properties_dialog</NAME>
<RETURNS>void  </RETURNS>
GtkWindow *parent, const gchar *dsn
</FUNCTION>
<FUNCTION>
<NAME>provider_config_new</NAME>
<RETURNS>GtkWidget  *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>dsn_config_new</NAME>
<RETURNS>GtkWidget  *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>dsn_config_edit_properties</NAME>
<RETURNS>void  </RETURNS>
GtkWidget *dsn
</FUNCTION>
<FUNCTION>
<NAME>dsn_config_delete</NAME>
<RETURNS>void  </RETURNS>
GtkWidget *dsn
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_canvas_print</NAME>
<RETURNS>void  </RETURNS>
GnomeDbCanvas *canvas
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_CANVAS_TIP</NAME>
#define GNOME_DB_TYPE_CANVAS_TIP          (gnome_db_canvas_tip_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_CANVAS_TIP</NAME>
#define GNOME_DB_CANVAS_TIP(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gnome_db_canvas_tip_get_type(), GnomeDbCanvasTip)
</MACRO>
<MACRO>
<NAME>GNOME_DB_CANVAS_TIP_CLASS</NAME>
#define GNOME_DB_CANVAS_TIP_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gnome_db_canvas_tip_get_type (), GnomeDbCanvasTipClass)
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_CANVAS_TIP</NAME>
#define GNOME_DB_IS_CANVAS_TIP(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gnome_db_canvas_tip_get_type ())
</MACRO>
<STRUCT>
<NAME>GnomeDbCanvasTip</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbCanvasTipClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbCanvasTipPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbCanvasTip</NAME>
struct GnomeDbCanvasTip
{
	GooCanvasGroup        object;

	GnomeDbCanvasTipPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbCanvasTipClass</NAME>
struct GnomeDbCanvasTipClass
{
	GooCanvasGroupClass   parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_canvas_tip_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_canvas_tip_new</NAME>
<RETURNS>GooCanvasItem  *</RETURNS>
GooCanvasItem *parent, const gchar *txt, gdouble x, gdouble y, ...
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_CANVAS_FKEY</NAME>
#define GNOME_DB_TYPE_CANVAS_FKEY          (gnome_db_canvas_fkey_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_CANVAS_FKEY</NAME>
#define GNOME_DB_CANVAS_FKEY(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gnome_db_canvas_fkey_get_type(), GnomeDbCanvasFkey)
</MACRO>
<MACRO>
<NAME>GNOME_DB_CANVAS_FKEY_CLASS</NAME>
#define GNOME_DB_CANVAS_FKEY_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gnome_db_canvas_fkey_get_type (), GnomeDbCanvasFkeyClass)
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_CANVAS_FKEY</NAME>
#define GNOME_DB_IS_CANVAS_FKEY(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gnome_db_canvas_fkey_get_type ())
</MACRO>
<STRUCT>
<NAME>GnomeDbCanvasFkey</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbCanvasFkeyClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbCanvasFkeyPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbCanvasFkey</NAME>
struct GnomeDbCanvasFkey
{
	GnomeDbCanvasItem         object;
	GnomeDbCanvasFkeyPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbCanvasFkeyClass</NAME>
struct GnomeDbCanvasFkeyClass
{
	GnomeDbCanvasItemClass    parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_canvas_fkey_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_canvas_fkey_new</NAME>
<RETURNS>GooCanvasItem  *</RETURNS>
GooCanvasItem *parent, GdaMetaTableForeignKey *fk, ...
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_CANVAS_COLUMN</NAME>
#define GNOME_DB_TYPE_CANVAS_COLUMN          (gnome_db_canvas_column_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_CANVAS_COLUMN</NAME>
#define GNOME_DB_CANVAS_COLUMN(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gnome_db_canvas_column_get_type(), GnomeDbCanvasColumn)
</MACRO>
<MACRO>
<NAME>GNOME_DB_CANVAS_COLUMN_CLASS</NAME>
#define GNOME_DB_CANVAS_COLUMN_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gnome_db_canvas_column_get_type (), GnomeDbCanvasColumnClass)
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_CANVAS_COLUMN</NAME>
#define GNOME_DB_IS_CANVAS_COLUMN(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gnome_db_canvas_column_get_type ())
</MACRO>
<STRUCT>
<NAME>GnomeDbCanvasColumn</NAME>
struct GnomeDbCanvasColumn
{
	GnomeDbCanvasText          object;

	GnomeDbCanvasColumnPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbCanvasColumnClass</NAME>
struct GnomeDbCanvasColumnClass
{
	GnomeDbCanvasTextClass     parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_canvas_column_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_canvas_column_new</NAME>
<RETURNS>GooCanvasItem *</RETURNS>
GooCanvasItem *parent, GdaMetaTableColumn *column,gdouble x, gdouble y, ...
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_canvas_column_get_column</NAME>
<RETURNS>GdaMetaTableColumn   *</RETURNS>
GnomeDbCanvasColumn *column
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_canvas_column_get_parent_item</NAME>
<RETURNS>GnomeDbCanvasTable   *</RETURNS>
GnomeDbCanvasColumn *column
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_CANVAS_ITEM</NAME>
#define GNOME_DB_TYPE_CANVAS_ITEM          (gnome_db_canvas_item_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_CANVAS_ITEM</NAME>
#define GNOME_DB_CANVAS_ITEM(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gnome_db_canvas_item_get_type(), GnomeDbCanvasItem)
</MACRO>
<MACRO>
<NAME>GNOME_DB_CANVAS_ITEM_CLASS</NAME>
#define GNOME_DB_CANVAS_ITEM_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gnome_db_canvas_item_get_type (), GnomeDbCanvasItemClass)
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_CANVAS_ITEM</NAME>
#define GNOME_DB_IS_CANVAS_ITEM(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gnome_db_canvas_item_get_type ())
</MACRO>
<STRUCT>
<NAME>GnomeDbCanvasItem</NAME>
struct GnomeDbCanvasItem
{
	GooCanvasGroup         object;

	GnomeDbCanvasItemPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbCanvasItemClass</NAME>
struct GnomeDbCanvasItemClass
{
	GooCanvasGroupClass    parent_class;

	/* signals */
	void (*moved)        (GnomeDbCanvasItem *citem);
	void (*moving)       (GnomeDbCanvasItem *citem);
	void (*shifted)      (GnomeDbCanvasItem *citem);
	void (*drag_action)  (GnomeDbCanvasItem *citem, GnomeDbCanvasItem * dragged_from, GnomeDbCanvasItem * dragged_to);
	void (*destroy)      (GnomeDbCanvasItem *citem);

	/* virtual functions */
	void (*extra_event)  (GnomeDbCanvasItem *citem, GdkEventType event_type);
	void (*get_edge_nodes)(GnomeDbCanvasItem *citem, GnomeDbCanvasItem **from, GnomeDbCanvasItem **to);
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_canvas_item_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_canvas_item_get_canvas</NAME>
<RETURNS>GnomeDbCanvas      *</RETURNS>
GnomeDbCanvasItem *item
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_canvas_item_get_graph_item</NAME>
<RETURNS>GnomeDbGraphItem   *</RETURNS>
GnomeDbCanvasItem *item
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_canvas_item_get_edge_nodes</NAME>
<RETURNS>void  </RETURNS>
GnomeDbCanvasItem *item,GnomeDbCanvasItem **from, GnomeDbCanvasItem **to
</FUNCTION>
<STRUCT>
<NAME>GnomeDbCanvasCanvasShape</NAME>
struct GnomeDbCanvasCanvasShape
{
	gchar         *id;
	GooCanvasItem *item;
	gboolean       _used;
	gboolean       is_new;
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_canvas_util_compute_anchor_shapes</NAME>
<RETURNS>GSList  *</RETURNS>
GooCanvasItem *parent, GSList *shapes,GnomeDbCanvasTable *fk_ent, GnomeDbCanvasTable *ref_pk_ent,guint nb_anchors, guint ext, gboolean with_handle
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_canvas_util_compute_connect_shapes</NAME>
<RETURNS>GSList  *</RETURNS>
GooCanvasItem *parent, GSList *shapes,GnomeDbCanvasTable *ent1, GdaMetaTableColumn *field1,GnomeDbCanvasTable *ent2, GdaMetaTableColumn *field2,guint nb_connect, guint ext
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_canvas_canvas_shapes_dump</NAME>
<RETURNS>void  </RETURNS>
GSList *list
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_canvas_canvas_shapes_remove_all</NAME>
<RETURNS>void  </RETURNS>
GSList *list
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_canvas_canvas_shapes_remove_obsolete_shapes</NAME>
<RETURNS>GSList  *</RETURNS>
GSList *list
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_CANVAS_CANVAS_SHAPE</NAME>
#define GNOME_DB_CANVAS_CANVAS_SHAPE(x) ((GnomeDbCanvasCanvasShape *)(x))
</MACRO>
<MACRO>
<NAME>GNOME_DB_TYPE_CANVAS</NAME>
#define GNOME_DB_TYPE_CANVAS          (gnome_db_canvas_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_CANVAS</NAME>
#define GNOME_DB_CANVAS(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gnome_db_canvas_get_type(), GnomeDbCanvas)
</MACRO>
<MACRO>
<NAME>GNOME_DB_CANVAS_CLASS</NAME>
#define GNOME_DB_CANVAS_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gnome_db_canvas_get_type (), GnomeDbCanvasClass)
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_CANVAS</NAME>
#define GNOME_DB_IS_CANVAS(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gnome_db_canvas_get_type ())
</MACRO>
<ENUM>
<NAME>GnomeDbCanvasLayoutAlgorithm</NAME>
typedef enum {
	GNOME_DB_CANVAS_LAYOUT_DEFAULT,
	GNOME_DB_CANVAS_LAYOUT_RADIAL
} GnomeDbCanvasLayoutAlgorithm;
</ENUM>
<STRUCT>
<NAME>GnomeDbCanvas</NAME>
struct GnomeDbCanvas
{
	GooCanvas           widget;

	/* pointer position when a context menu was last opened */
	gdouble             xmouse;
	gdouble             ymouse;
	/* private */
	GnomeDbCanvasPrivate  *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbCanvasClass</NAME>
struct GnomeDbCanvasClass
{
	GooCanvasClass      parent_class;

	/* virtual functions */
	void           (*create_canvas_items) (GnomeDbCanvas *canvas); /* create individual GnomeDbCanvasItem objects */
	void           (*clean_canvas_items)  (GnomeDbCanvas *canvas); /* clean any extra structure, not the individual items */

	void           (*graph_item_added)    (GnomeDbCanvas *canvas, GnomeDbGraphItem *item);
	void           (*graph_item_dropped)  (GnomeDbCanvas *canvas, GnomeDbGraphItem *item);

	GtkWidget     *(*build_context_menu)  (GnomeDbCanvas *canvas);

	/* signals */
	void           (*drag_action)        (GnomeDbCanvas *canvas, GnomeDbCanvasItem *from_item, GnomeDbCanvasItem *to_item);
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_canvas_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_canvas_get_graph</NAME>
<RETURNS>GnomeDbGraph       *</RETURNS>
GnomeDbCanvas *canvas
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_canvas_set_in_scrolled_window</NAME>
<RETURNS>GtkWidget          *</RETURNS>
GnomeDbCanvas *canvas
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_canvas_declare_item</NAME>
<RETURNS>void  </RETURNS>
GnomeDbCanvas *canvas, GnomeDbCanvasItem *item
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_canvas_set_zoom_factor</NAME>
<RETURNS>void  </RETURNS>
GnomeDbCanvas *canvas, gdouble n
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_canvas_get_zoom_factor</NAME>
<RETURNS>gdouble  </RETURNS>
GnomeDbCanvas *canvas
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_canvas_fit_zoom_factor</NAME>
<RETURNS>gdouble  </RETURNS>
GnomeDbCanvas *canvas
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_canvas_auto_layout_enabled</NAME>
<RETURNS>gboolean  </RETURNS>
GnomeDbCanvas *canvas
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_canvas_perform_auto_layout</NAME>
<RETURNS>void  </RETURNS>
GnomeDbCanvas *canvas, gboolean animate,GnomeDbCanvasLayoutAlgorithm algorithm
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_canvas_center</NAME>
<RETURNS>void  </RETURNS>
GnomeDbCanvas *canvas
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_CANVAS_ENTITY_COLOR</NAME>
#define GNOME_DB_CANVAS_ENTITY_COLOR      "yellow"
</MACRO>
<MACRO>
<NAME>GNOME_DB_CANVAS_DB_TABLE_COLOR</NAME>
#define GNOME_DB_CANVAS_DB_TABLE_COLOR    "lightblue"
</MACRO>
<MACRO>
<NAME>GNOME_DB_CANVAS_QUERY_COLOR</NAME>
#define GNOME_DB_CANVAS_QUERY_COLOR       "lightgreen"
</MACRO>
<MACRO>
<NAME>GNOME_DB_TYPE_CANVAS_CURSOR</NAME>
#define GNOME_DB_TYPE_CANVAS_CURSOR          (gnome_db_canvas_cursor_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_CANVAS_CURSOR</NAME>
#define GNOME_DB_CANVAS_CURSOR(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gnome_db_canvas_cursor_get_type(), GnomeDbCanvasCursor)
</MACRO>
<MACRO>
<NAME>GNOME_DB_CANVAS_CURSOR_CLASS</NAME>
#define GNOME_DB_CANVAS_CURSOR_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gnome_db_canvas_cursor_get_type (), GnomeDbCanvasCursorClass)
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_CANVAS_CURSOR</NAME>
#define GNOME_DB_IS_CANVAS_CURSOR(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gnome_db_canvas_cursor_get_type ())
</MACRO>
<STRUCT>
<NAME>GnomeDbCanvasCursor</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbCanvasCursorClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbCanvasCursor</NAME>
struct GnomeDbCanvasCursor
{
	GnomeDbCanvasItem        object;

	GooCanvasItem    *item;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbCanvasCursorClass</NAME>
struct GnomeDbCanvasCursorClass
{
	GnomeDbCanvasItemClass   parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_canvas_cursor_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_canvas_cursor_new</NAME>
<RETURNS>GooCanvasItem  *</RETURNS>
GooCanvasItem *parent, ...
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_CANVAS_DB_RELATIONS</NAME>
#define GNOME_DB_TYPE_CANVAS_DB_RELATIONS          (gnome_db_canvas_db_relations_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_CANVAS_DB_RELATIONS</NAME>
#define GNOME_DB_CANVAS_DB_RELATIONS(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gnome_db_canvas_db_relations_get_type(), GnomeDbCanvasDbRelations)
</MACRO>
<MACRO>
<NAME>GNOME_DB_CANVAS_DB_RELATIONS_CLASS</NAME>
#define GNOME_DB_CANVAS_DB_RELATIONS_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gnome_db_canvas_db_relations_get_type (), GnomeDbCanvasDbRelationsClass)
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_CANVAS_DB_RELATIONS</NAME>
#define GNOME_DB_IS_CANVAS_DB_RELATIONS(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gnome_db_canvas_db_relations_get_type ())
</MACRO>
<STRUCT>
<NAME>GnomeDbCanvasDbRelations</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbCanvasDbRelationsClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbCanvasDbRelationsPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbCanvasDbRelations</NAME>
struct GnomeDbCanvasDbRelations
{
	GnomeDbCanvas                       widget;

	GnomeDbCanvasDbRelationsPrivate    *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbCanvasDbRelationsClass</NAME>
struct GnomeDbCanvasDbRelationsClass
{
	GnomeDbCanvasClass                  parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_canvas_db_relations_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_canvas_db_relations_new</NAME>
<RETURNS>GtkWidget        *</RETURNS>
GdaMetaStore *store
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_canvas_db_relations_get_table_item</NAME>
<RETURNS>GnomeDbCanvasTable  *</RETURNS>
GnomeDbCanvasDbRelations *canvas, GdaMetaTable *table
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_canvas_db_relations_add_table_item</NAME>
<RETURNS>GnomeDbCanvasTable  *</RETURNS>
GnomeDbCanvasDbRelations *canvas,const GValue *table_catalog, const GValue *table_schema,const GValue *table_name
</FUNCTION>
<STRUCT>
<NAME>GnomeDbCanvas</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbCanvasClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbCanvasPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbCanvasItem</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbCanvasItemClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbCanvasItemPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbCanvasTable</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbCanvasTableClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbCanvasTablePrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbCanvasColumn</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbCanvasColumnClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbCanvasColumnPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbGraph</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbGraphClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbGraphPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbGraphItem</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbGraphItemClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbGraphItemPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GNOME_DB_TYPE_GRAPH_ITEM</NAME>
#define GNOME_DB_TYPE_GRAPH_ITEM          (gnome_db_graph_item_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_GRAPH_ITEM</NAME>
#define GNOME_DB_GRAPH_ITEM(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gnome_db_graph_item_get_type(), GnomeDbGraphItem)
</MACRO>
<MACRO>
<NAME>GNOME_DB_GRAPH_ITEM_CLASS</NAME>
#define GNOME_DB_GRAPH_ITEM_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gnome_db_graph_item_get_type (), GnomeDbGraphItemClass)
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_GRAPH_ITEM</NAME>
#define GNOME_DB_IS_GRAPH_ITEM(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gnome_db_graph_item_get_type ())
</MACRO>
<FUNCTION>
<NAME>gnome_db_graph_item_error_quark</NAME>
<RETURNS>GQuark  </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_GRAPH_ITEM_ERROR</NAME>
#define GNOME_DB_GRAPH_ITEM_ERROR gnome_db_graph_item_error_quark ()
</MACRO>
<ENUM>
<NAME>GnomeDbGraphItemError</NAME>
typedef enum
{
	GNOME_DB_GRAPH_ITEM__ERROR
} GnomeDbGraphItemError;
</ENUM>
<STRUCT>
<NAME>GnomeDbGraphItem</NAME>
struct GnomeDbGraphItem
{
	GObject               object;
	GnomeDbGraphItemPrivate  *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbGraphItemClass</NAME>
struct GnomeDbGraphItemClass
{
	GObjectClass   parent_class;
	
	/* signals */
	void        (*moved) (GnomeDbGraphItem *item);
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_graph_item_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_graph_item_new</NAME>
<RETURNS>GnomeDbGraphItem  *</RETURNS>
GnomeDbGraph *graph
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_graph_item_get_graph</NAME>
<RETURNS>GnomeDbGraph      *</RETURNS>
GnomeDbGraphItem *item
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_graph_item_set_position</NAME>
<RETURNS>void  </RETURNS>
GnomeDbGraphItem *item, gdouble x, gdouble y
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_graph_item_get_position</NAME>
<RETURNS>void  </RETURNS>
GnomeDbGraphItem *item, gdouble *x, gdouble *y
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_GRAPH</NAME>
#define GNOME_DB_TYPE_GRAPH          (gnome_db_graph_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_GRAPH</NAME>
#define GNOME_DB_GRAPH(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gnome_db_graph_get_type(), GnomeDbGraph)
</MACRO>
<MACRO>
<NAME>GNOME_DB_GRAPH_CLASS</NAME>
#define GNOME_DB_GRAPH_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gnome_db_graph_get_type (), GnomeDbGraphClass)
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_GRAPH</NAME>
#define GNOME_DB_IS_GRAPH(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gnome_db_graph_get_type ())
</MACRO>
<FUNCTION>
<NAME>gnome_db_graph_error_quark</NAME>
<RETURNS>GQuark  </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_GRAPH_ERROR</NAME>
#define GNOME_DB_GRAPH_ERROR gnome_db_graph_error_quark ()
</MACRO>
<ENUM>
<NAME>GnomeDbGraphError</NAME>
typedef enum
{
	GNOME_DB_GRAPH__ERROR
} GnomeDbGraphError;
</ENUM>
<STRUCT>
<NAME>GnomeDbGraph</NAME>
struct GnomeDbGraph
{
	GObject         object;
	GnomeDbGraphPrivate  *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbGraphClass</NAME>
struct GnomeDbGraphClass
{
	GObjectClass   parent_class;
	
	/* signals */
	void        (*item_added)   (GnomeDbGraph *graph, GnomeDbGraphItem *item);
	void        (*item_dropped) (GnomeDbGraph *graph, GnomeDbGraphItem *item);
	void        (*item_moved)   (GnomeDbGraph *graph, GnomeDbGraphItem *item);
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_graph_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_graph_new</NAME>
<RETURNS>GnomeDbGraph     *</RETURNS>
GdaMetaStore *store, guint id
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_graph_add_item</NAME>
<RETURNS>void  </RETURNS>
GnomeDbGraph *graph, GnomeDbGraphItem *item
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_graph_del_item</NAME>
<RETURNS>void  </RETURNS>
GnomeDbGraph *graph, GnomeDbGraphItem *item
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_graph_get_items</NAME>
<RETURNS>GSList           *</RETURNS>
GnomeDbGraph *graph
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_graph_delete</NAME>
<RETURNS>void  </RETURNS>
GdaMetaStore *store, guint id
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_CANVAS_TABLE</NAME>
#define GNOME_DB_TYPE_CANVAS_TABLE          (gnome_db_canvas_table_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_CANVAS_TABLE</NAME>
#define GNOME_DB_CANVAS_TABLE(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gnome_db_canvas_table_get_type(), GnomeDbCanvasTable)
</MACRO>
<MACRO>
<NAME>GNOME_DB_CANVAS_TABLE_CLASS</NAME>
#define GNOME_DB_CANVAS_TABLE_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gnome_db_canvas_table_get_type (), GnomeDbCanvasTableClass)
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_CANVAS_TABLE</NAME>
#define GNOME_DB_IS_CANVAS_TABLE(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gnome_db_canvas_table_get_type ())
</MACRO>
<STRUCT>
<NAME>GnomeDbCanvasTable</NAME>
struct GnomeDbCanvasTable
{
	GnomeDbCanvasItem           object;

	GnomeDbCanvasTablePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbCanvasTableClass</NAME>
struct GnomeDbCanvasTableClass
{
	GnomeDbCanvasItemClass   parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_canvas_table_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_canvas_table_new</NAME>
<RETURNS>GooCanvasItem        *</RETURNS>
GooCanvasItem *parent, GdaMetaTable *table,gdouble x, gdouble y, ...
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_canvas_table_get_column_item</NAME>
<RETURNS>GnomeDbCanvasColumn  *</RETURNS>
GnomeDbCanvasTable *ce, GdaMetaTableColumn *column
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_canvas_table_get_column_ypos</NAME>
<RETURNS>gdouble  </RETURNS>
GnomeDbCanvasTable *ce, GdaMetaTableColumn *column
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_CANVAS_TEXT</NAME>
#define GNOME_DB_TYPE_CANVAS_TEXT          (gnome_db_canvas_text_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_CANVAS_TEXT</NAME>
#define GNOME_DB_CANVAS_TEXT(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gnome_db_canvas_text_get_type(), GnomeDbCanvasText)
</MACRO>
<MACRO>
<NAME>GNOME_DB_CANVAS_TEXT_CLASS</NAME>
#define GNOME_DB_CANVAS_TEXT_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gnome_db_canvas_text_get_type (), GnomeDbCanvasTextClass)
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_CANVAS_TEXT</NAME>
#define GNOME_DB_IS_CANVAS_TEXT(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gnome_db_canvas_text_get_type ())
</MACRO>
<STRUCT>
<NAME>GnomeDbCanvasText</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbCanvasTextClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbCanvasTextPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbCanvasText</NAME>
struct GnomeDbCanvasText
{
	GnomeDbCanvasItem           object;

	GnomeDbCanvasTextPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbCanvasTextClass</NAME>
struct GnomeDbCanvasTextClass
{
	GnomeDbCanvasItemClass   parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_canvas_text_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_canvas_text_new</NAME>
<RETURNS>GooCanvasItem *</RETURNS>
GooCanvasItem *parent,const gchar *txt,gdouble x,gdouble y,...
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_canvas_text_set_highlight</NAME>
<RETURNS>void  </RETURNS>
GnomeDbCanvasText *ct, gboolean highlight
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_selector_feature_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_DB_SELECTOR_FEATURE</NAME>
#define GNOME_DB_TYPE_DB_SELECTOR_FEATURE (gnome_db_selector_feature_get_type())
</MACRO>
<FUNCTION>
<NAME>gnome_db_selector_part_fill_mode_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_DB_SELECTOR_PART_FILL_MODE</NAME>
#define GNOME_DB_TYPE_DB_SELECTOR_PART_FILL_MODE (gnome_db_selector_part_fill_mode_get_type())
</MACRO>
<FUNCTION>
<NAME>gnome_db_selector_schema_node_type_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_DB_SELECTOR_SCHEMA_NODE_TYPE</NAME>
#define GNOME_DB_TYPE_DB_SELECTOR_SCHEMA_NODE_TYPE (gnome_db_selector_schema_node_type_get_type())
</MACRO>
<FUNCTION>
<NAME>gnome_db_selector_table_node_type_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_DB_SELECTOR_TABLE_NODE_TYPE</NAME>
#define GNOME_DB_TYPE_DB_SELECTOR_TABLE_NODE_TYPE (gnome_db_selector_table_node_type_get_type())
</MACRO>
<FUNCTION>
<NAME>gnome_db_selector_view_node_type_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_DB_SELECTOR_VIEW_NODE_TYPE</NAME>
#define GNOME_DB_TYPE_DB_SELECTOR_VIEW_NODE_TYPE (gnome_db_selector_view_node_type_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_TYPE_SELECTOR</NAME>
#define GNOME_DB_TYPE_SELECTOR          (gnome_db_selector_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_SELECTOR</NAME>
#define GNOME_DB_SELECTOR(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gnome_db_selector_get_type(), GnomeDbSelector)
</MACRO>
<MACRO>
<NAME>GNOME_DB_SELECTOR_CLASS</NAME>
#define GNOME_DB_SELECTOR_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gnome_db_selector_get_type (), GnomeDbSelectorClass)
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_SELECTOR</NAME>
#define GNOME_DB_IS_SELECTOR(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gnome_db_selector_get_type ())
</MACRO>
<STRUCT>
<NAME>GnomeDbSelector</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbSelectorClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbSelectorPriv</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbSelector</NAME>
struct GnomeDbSelector
{
	GtkTreeView          object;
	GnomeDbSelectorPriv *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbSelectorClass</NAME>
struct GnomeDbSelectorClass
{
	GtkTreeViewClass    parent_class;
	void              (*selected_object_changed) (GnomeDbSelector *sel, GnomeDbSelectorPart *part, 
						      GtkTreeStore *store, GtkTreeIter *iter);
};
</STRUCT>
<ENUM>
<NAME>GnomeDbSelectorFeature</NAME>
typedef enum {
	GNOME_DB_SELECTOR_FEATURE_NONE = 0,
	GNOME_DB_SELECTOR_FEATURE_SCHEMAS = 1 << 0,
	GNOME_DB_SELECTOR_FEATURE_SCHEMA_TABLES = 1 << 1,
	GNOME_DB_SELECTOR_FEATURE_SCHEMA_VIEWS = 1 << 2,
	GNOME_DB_SELECTOR_FEATURE_SCHEMA_DOMAINS = 1 << 3,

	GNOME_DB_SELECTOR_FEATURE_SCHEMA_TABLE_COLUMNS = 1 << 4,
	GNOME_DB_SELECTOR_FEATURE_SCHEMA_TABLE_CONSTRAINTS = 1 << 5,
	GNOME_DB_SELECTOR_FEATURE_SCHEMA_TABLE_TRIGGERS = 1 << 6,
	
	GNOME_DB_SELECTOR_FEATURE_SCHEMA_TABLE_DETAILS = (GNOME_DB_SELECTOR_FEATURE_SCHEMA_TABLE_COLUMNS | GNOME_DB_SELECTOR_FEATURE_SCHEMA_TABLE_CONSTRAINTS | GNOME_DB_SELECTOR_FEATURE_SCHEMA_TABLE_TRIGGERS),

	GNOME_DB_SELECTOR_FEATURE_SCHEMA_VIEW_COLUMNS = 1 << 7,
	GNOME_DB_SELECTOR_FEATURE_SCHEMA_VIEW_DETAILS = (GNOME_DB_SELECTOR_FEATURE_SCHEMA_VIEW_COLUMNS)
} GnomeDbSelectorFeature;
</ENUM>
<FUNCTION>
<NAME>gnome_db_selector_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_selector_new</NAME>
<RETURNS>GtkWidget  *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_selector_add_part</NAME>
<RETURNS>void  </RETURNS>
GnomeDbSelector *sel, const gchar *name, GnomeDbSelectorPart *part
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_selector_add_parts_for_feature</NAME>
<RETURNS>void  </RETURNS>
GnomeDbSelector *sel, GdaMetaStore *store,GnomeDbSelectorFeature feature
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_SELECTOR_SCHEMA</NAME>
#define GNOME_DB_TYPE_SELECTOR_SCHEMA            (gnome_db_selector_schema_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_SELECTOR_SCHEMA</NAME>
#define GNOME_DB_SELECTOR_SCHEMA(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GNOME_DB_TYPE_SELECTOR_SCHEMA, GnomeDbSelectorSchema))
</MACRO>
<MACRO>
<NAME>GNOME_DB_SELECTOR_SCHEMA_CLASS</NAME>
#define GNOME_DB_SELECTOR_SCHEMA_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GNOME_DB_TYPE_SELECTOR_SCHEMA, GnomeDbSelectorSchemaClass))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_SELECTOR_SCHEMA</NAME>
#define GNOME_DB_IS_SELECTOR_SCHEMA(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GNOME_DB_TYPE_SELECTOR_SCHEMA))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_SELECTOR_SCHEMA_CLASS</NAME>
#define GNOME_DB_IS_SELECTOR_SCHEMA_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GNOME_DB_TYPE_SELECTOR_SCHEMA))
</MACRO>
<STRUCT>
<NAME>GnomeDbSelectorSchema</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbSelectorSchemaClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbSelectorSchemaPrivate</NAME>
</STRUCT>
<ENUM>
<NAME>GnomeDbSelectorSchemaNodeType</NAME>
typedef enum {
	GNOME_DB_SELECTOR_SCHEMA_TABLES = 0,
	GNOME_DB_SELECTOR_SCHEMA_VIEWS,
	GNOME_DB_SELECTOR_SCHEMA_SEQUENCES,
	GNOME_DB_SELECTOR_SCHEMA_PROCEDURES,
	GNOME_DB_SELECTOR_SCHEMA_DOMAINS,

	GNOME_DB_SELECTOR_SCHEMA_LAST
} GnomeDbSelectorSchemaNodeType;
</ENUM>
<STRUCT>
<NAME>GnomeDbSelectorSchema</NAME>
struct GnomeDbSelectorSchema {
	GObject                 object;
	GnomeDbSelectorSchemaPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbSelectorSchemaClass</NAME>
struct GnomeDbSelectorSchemaClass {
	GObjectClass            parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_selector_schema_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_selector_schema_new</NAME>
<RETURNS>GnomeDbSelectorPart  *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_selector_schema_set_sub_part</NAME>
<RETURNS>void  </RETURNS>
GnomeDbSelectorSchema *part,GnomeDbSelectorSchemaNodeType type,GnomeDbSelectorPart *subpart
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_SELECTOR_VIEW</NAME>
#define GNOME_DB_TYPE_SELECTOR_VIEW            (gnome_db_selector_view_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_SELECTOR_VIEW</NAME>
#define GNOME_DB_SELECTOR_VIEW(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GNOME_DB_TYPE_SELECTOR_VIEW, GnomeDbSelectorView))
</MACRO>
<MACRO>
<NAME>GNOME_DB_SELECTOR_VIEW_CLASS</NAME>
#define GNOME_DB_SELECTOR_VIEW_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GNOME_DB_TYPE_SELECTOR_VIEW, GnomeDbSelectorViewClass))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_SELECTOR_VIEW</NAME>
#define GNOME_DB_IS_SELECTOR_VIEW(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GNOME_DB_TYPE_SELECTOR_VIEW))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_SELECTOR_VIEW_CLASS</NAME>
#define GNOME_DB_IS_SELECTOR_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GNOME_DB_TYPE_SELECTOR_VIEW))
</MACRO>
<STRUCT>
<NAME>GnomeDbSelectorView</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbSelectorViewClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbSelectorViewPrivate</NAME>
</STRUCT>
<ENUM>
<NAME>GnomeDbSelectorViewNodeType</NAME>
typedef enum {
	GNOME_DB_SELECTOR_VIEW_COLUMNS = 0,

	GNOME_DB_SELECTOR_VIEW_LAST
} GnomeDbSelectorViewNodeType;
</ENUM>
<STRUCT>
<NAME>GnomeDbSelectorView</NAME>
struct GnomeDbSelectorView {
	GObject                 object;
	GnomeDbSelectorViewPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbSelectorViewClass</NAME>
struct GnomeDbSelectorViewClass {
	GObjectClass            parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_selector_view_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_selector_view_new</NAME>
<RETURNS>GnomeDbSelectorPart  *</RETURNS>
GdaMetaStore *store
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_SELECTOR_META</NAME>
#define GNOME_DB_TYPE_SELECTOR_META            (gnome_db_selector_meta_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_SELECTOR_META</NAME>
#define GNOME_DB_SELECTOR_META(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GNOME_DB_TYPE_SELECTOR_META, GnomeDbSelectorMeta))
</MACRO>
<MACRO>
<NAME>GNOME_DB_SELECTOR_META_CLASS</NAME>
#define GNOME_DB_SELECTOR_META_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GNOME_DB_TYPE_SELECTOR_META, GnomeDbSelectorMetaClass))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_SELECTOR_META</NAME>
#define GNOME_DB_IS_SELECTOR_META(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GNOME_DB_TYPE_SELECTOR_META))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_SELECTOR_META_CLASS</NAME>
#define GNOME_DB_IS_SELECTOR_META_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GNOME_DB_TYPE_SELECTOR_META))
</MACRO>
<STRUCT>
<NAME>GnomeDbSelectorMeta</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbSelectorMetaClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbSelectorMetaPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbSelectorMeta</NAME>
struct GnomeDbSelectorMeta {
	GObject                 object;
	GnomeDbSelectorMetaPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbSelectorMetaClass</NAME>
struct GnomeDbSelectorMetaClass {
	GObjectClass            parent_class;
};
</STRUCT>
<USER_FUNCTION>
<NAME>GnomeDbSelectorMetaPixbufFunc</NAME>
<RETURNS>GdkPixbuf *</RETURNS>
const GValue *value
</USER_FUNCTION>
<FUNCTION>
<NAME>gnome_db_selector_meta_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_selector_meta_new_with_sql</NAME>
<RETURNS>GnomeDbSelectorPart  *</RETURNS>
GdaMetaStore *store, const gchar *sql, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_selector_meta_add_sql</NAME>
<RETURNS>gboolean  </RETURNS>
GnomeDbSelectorMeta *part, const gchar *sql, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_selector_meta_set_sub_part</NAME>
<RETURNS>void  </RETURNS>
GnomeDbSelectorMeta *part, GnomeDbSelectorPart *subpart
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_selector_meta_set_pixbuf_func</NAME>
<RETURNS>void  </RETURNS>
GnomeDbSelectorMeta *part, gint column,GnomeDbSelectorMetaPixbufFunc func
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_SELECTOR_PART</NAME>
#define GNOME_DB_TYPE_SELECTOR_PART            (gnome_db_selector_part_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_SELECTOR_PART</NAME>
#define GNOME_DB_SELECTOR_PART(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GNOME_DB_TYPE_SELECTOR_PART, GnomeDbSelectorPart))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_SELECTOR_PART</NAME>
#define GNOME_DB_IS_SELECTOR_PART(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GNOME_DB_TYPE_SELECTOR_PART))
</MACRO>
<MACRO>
<NAME>GNOME_DB_SELECTOR_PART_GET_CLASS</NAME>
#define GNOME_DB_SELECTOR_PART_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GNOME_DB_TYPE_SELECTOR_PART, GnomeDbSelectorPartClass))
</MACRO>
<STRUCT>
<NAME>GnomeDbSelectorPartClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbSelectorPart</NAME>
</STRUCT>
<MACRO>
<NAME>GNOME_DB_SELECTOR_PART_PIXBUF_COLUMN</NAME>
#define GNOME_DB_SELECTOR_PART_PIXBUF_COLUMN 0
</MACRO>
<MACRO>
<NAME>GNOME_DB_SELECTOR_PART_LABEL_COLUMN</NAME>
#define GNOME_DB_SELECTOR_PART_LABEL_COLUMN 1
</MACRO>
<MACRO>
<NAME>GNOME_DB_SELECTOR_PART_PART_COLUMN</NAME>
#define GNOME_DB_SELECTOR_PART_PART_COLUMN 2
</MACRO>
<MACRO>
<NAME>GNOME_DB_SELECTOR_PART_PRIVATE_OBJ_COLUMN</NAME>
#define GNOME_DB_SELECTOR_PART_PRIVATE_OBJ_COLUMN 3
</MACRO>
<MACRO>
<NAME>GNOME_DB_SELECTOR_PART_PRIVATE_INT_COLUMN</NAME>
#define GNOME_DB_SELECTOR_PART_PRIVATE_INT_COLUMN 4
</MACRO>
<STRUCT>
<NAME>GnomeDbSelectorPartClass</NAME>
struct GnomeDbSelectorPartClass {
	GTypeInterface           g_iface;

	/* virtual table */
	void                 (*set_name)        (GnomeDbSelectorPart *part, const gchar *name);
	const gchar         *(*get_name)        (GnomeDbSelectorPart *part);
	void                 (*set_parent_part) (GnomeDbSelectorPart *part, GnomeDbSelectorPart *parent_part);
	GnomeDbSelectorPart *(*get_parent_part) (GnomeDbSelectorPart *part);
	GdkPixbuf           *(*get_pixbuf)      (GnomeDbSelectorPart *part);
	void                 (*fill_tree_store) (GnomeDbSelectorPart *part, 
						 GtkTreeStore *store, GtkTreeIter *parent_iter);
	GdaSet              *(*get_params)      (GnomeDbSelectorPart *part, GtkTreeStore *store, GtkTreeIter *at_iter);
	GdaSet              *(*get_data)        (GnomeDbSelectorPart *part, GtkTreeStore *store, GtkTreeIter *at_iter);
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_selector_part_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_selector_part_set_name</NAME>
<RETURNS>void  </RETURNS>
GnomeDbSelectorPart *part, const gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_selector_part_get_name</NAME>
<RETURNS>const gchar          *</RETURNS>
GnomeDbSelectorPart *part
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_selector_part_set_parent_part</NAME>
<RETURNS>void  </RETURNS>
GnomeDbSelectorPart *part,GnomeDbSelectorPart *parent_part
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_selector_part_get_parent_part</NAME>
<RETURNS>GnomeDbSelectorPart  *</RETURNS>
GnomeDbSelectorPart *part
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_selector_part_get_pixbuf</NAME>
<RETURNS>GdkPixbuf            *</RETURNS>
GnomeDbSelectorPart *part
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_selector_part_fill_tree_store</NAME>
<RETURNS>void  </RETURNS>
GnomeDbSelectorPart *part,GtkTreeStore *store, GtkTreeIter *parent
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_selector_part_get_params</NAME>
<RETURNS>GdaSet               *</RETURNS>
GnomeDbSelectorPart *part,GtkTreeStore *store, GtkTreeIter *at_iter
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_selector_part_get_data</NAME>
<RETURNS>GdaSet               *</RETURNS>
GnomeDbSelectorPart *part,GtkTreeStore *store, GtkTreeIter *at_iter
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_selector_part_get_value</NAME>
<RETURNS>const GValue         *</RETURNS>
GnomeDbSelectorPart *part, const gchar *id,GtkTreeStore *store, GtkTreeIter *at_iter
</FUNCTION>
<ENUM>
<NAME>GnomeDbSelectorPartFillMode</NAME>
typedef enum {
	GNOME_DB_SELECTOR_PART_FILL_MODE_FIRST_FILL,
	GNOME_DB_SELECTOR_PART_FILL_MODE_OVW_FIRST,
	GNOME_DB_SELECTOR_PART_FILL_MODE_OVW_NEXT
} GnomeDbSelectorPartFillMode;
</ENUM>
<FUNCTION>
<NAME>gnome_db_selector_part_obtain_new_store_row</NAME>
<RETURNS>void  </RETURNS>
GnomeDbSelectorPart *part, GnomeDbSelectorPartFillMode *in_out_mode,GtkTreeStore *store, GtkTreeIter *iter, GtkTreeIter *parent_iter
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_SQL_CONSOLE</NAME>
#define GNOME_DB_TYPE_SQL_CONSOLE          (gnome_db_sql_console_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_SQL_CONSOLE</NAME>
#define GNOME_DB_SQL_CONSOLE(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gnome_db_sql_console_get_type(), GnomeDbSqlConsole)
</MACRO>
<MACRO>
<NAME>GNOME_DB_SQL_CONSOLE_CLASS</NAME>
#define GNOME_DB_SQL_CONSOLE_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gnome_db_sql_console_get_type (), GnomeDbSqlConsoleClass)
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_SQL_CONSOLE</NAME>
#define GNOME_DB_IS_SQL_CONSOLE(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gnome_db_sql_console_get_type ())
</MACRO>
<STRUCT>
<NAME>GnomeDbSqlConsole</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbSqlConsoleClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbSqlConsolePriv</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbSqlConsole</NAME>
struct GnomeDbSqlConsole
{
	GtkTextView            object;

	GnomeDbSqlConsolePriv *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbSqlConsoleClass</NAME>
struct GnomeDbSqlConsoleClass
{
	GtkTextViewClass       parent_class;

	/* signals */
	gchar                *(*sql_entered) (GnomeDbSqlConsole *console, const gchar *sql);
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_sql_console_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_sql_console_new</NAME>
<RETURNS>GtkWidget  *</RETURNS>
GdaConnection *cnc, const gchar *message
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_sql_console_clear</NAME>
<RETURNS>void  </RETURNS>
GnomeDbSqlConsole *console
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_sql_console_clear_history</NAME>
<RETURNS>void  </RETURNS>
GnomeDbSqlConsole *console
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_EDITOR</NAME>
#define GNOME_DB_TYPE_EDITOR            (gnome_db_editor_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_EDITOR</NAME>
#define GNOME_DB_EDITOR(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GNOME_DB_TYPE_EDITOR, GnomeDbEditor))
</MACRO>
<MACRO>
<NAME>GNOME_DB_EDITOR_CLASS</NAME>
#define GNOME_DB_EDITOR_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GNOME_DB_TYPE_EDITOR, GnomeDbEditorClass))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_EDITOR</NAME>
#define GNOME_DB_IS_EDITOR(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GNOME_DB_TYPE_EDITOR))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_EDITOR_CLASS</NAME>
#define GNOME_DB_IS_EDITOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GNOME_DB_TYPE_EDITOR))
</MACRO>
<STRUCT>
<NAME>GnomeDbEditor</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbEditorClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbEditorPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbEditor</NAME>
struct GnomeDbEditor {
	GtkVBox parent;
	GnomeDbEditorPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbEditorClass</NAME>
struct GnomeDbEditorClass {
	GtkVBoxClass parent_class;

	/* signals */
	void (* text_changed) (GnomeDbEditor editor);
};
</STRUCT>
<MACRO>
<NAME>GNOME_DB_EDITOR_LANGUAGE_SQL</NAME>
#define GNOME_DB_EDITOR_LANGUAGE_SQL "sql"
</MACRO>
<FUNCTION>
<NAME>gnome_db_editor_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_editor_new</NAME>
<RETURNS>GtkWidget  *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_editor_get_editable</NAME>
<RETURNS>gboolean  </RETURNS>
GnomeDbEditor *editor
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_editor_set_editable</NAME>
<RETURNS>void  </RETURNS>
GnomeDbEditor *editor, gboolean editable
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_editor_get_highlight</NAME>
<RETURNS>gboolean  </RETURNS>
GnomeDbEditor *editor
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_editor_set_highlight</NAME>
<RETURNS>void  </RETURNS>
GnomeDbEditor *editor, gboolean highlight
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_editor_set_text</NAME>
<RETURNS>void  </RETURNS>
GnomeDbEditor *editor, const gchar *text, gint len
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_editor_get_all_text</NAME>
<RETURNS>gchar      *</RETURNS>
GnomeDbEditor *editor
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_editor_load_from_file</NAME>
<RETURNS>gboolean  </RETURNS>
GnomeDbEditor *editor, const gchar *filename
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_editor_save_to_file</NAME>
<RETURNS>gboolean  </RETURNS>
GnomeDbEditor *editor, const gchar *filename
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_editor_copy_clipboard</NAME>
<RETURNS>void  </RETURNS>
GnomeDbEditor *editor
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_editor_cut_clipboard</NAME>
<RETURNS>void  </RETURNS>
GnomeDbEditor *editor
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_editor_paste_clipboard</NAME>
<RETURNS>void  </RETURNS>
GnomeDbEditor *editor
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_ERROR</NAME>
#define GNOME_DB_TYPE_ERROR            (gnome_db_error_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_ERROR</NAME>
#define GNOME_DB_ERROR(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GNOME_DB_TYPE_ERROR, GnomeDbError))
</MACRO>
<MACRO>
<NAME>GNOME_DB_ERROR_CLASS</NAME>
#define GNOME_DB_ERROR_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GNOME_DB_TYPE_ERROR, GnomeDbErrorClass))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_ERROR</NAME>
#define GNOME_DB_IS_ERROR(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GNOME_DB_TYPE_ERROR))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_ERROR_CLASS</NAME>
#define GNOME_DB_IS_ERROR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GNOME_DB_TYPE_ERROR))
</MACRO>
<STRUCT>
<NAME>GnomeDbError</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbErrorClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbErrorPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbError</NAME>
struct GnomeDbError {
	GtkVBox              box;
	GnomeDbErrorPrivate* priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbErrorClass</NAME>
struct GnomeDbErrorClass {
	GtkVBoxClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_error_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_error_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_error_clear</NAME>
<RETURNS>void  </RETURNS>
GnomeDbError *error_widget
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_error_show</NAME>
<RETURNS>void  </RETURNS>
GnomeDbError *error_widget,GList *errors
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_error_prev</NAME>
<RETURNS>void  </RETURNS>
GnomeDbError *error_widget
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_error_next</NAME>
<RETURNS>void  </RETURNS>
GnomeDbError *error_widget
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_error_get_position</NAME>
<RETURNS>gint 	</RETURNS>
GnomeDbError *error_widget
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_SELECTOR_TABLE</NAME>
#define GNOME_DB_TYPE_SELECTOR_TABLE            (gnome_db_selector_table_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_SELECTOR_TABLE</NAME>
#define GNOME_DB_SELECTOR_TABLE(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GNOME_DB_TYPE_SELECTOR_TABLE, GnomeDbSelectorTable))
</MACRO>
<MACRO>
<NAME>GNOME_DB_SELECTOR_TABLE_CLASS</NAME>
#define GNOME_DB_SELECTOR_TABLE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GNOME_DB_TYPE_SELECTOR_TABLE, GnomeDbSelectorTableClass))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_SELECTOR_TABLE</NAME>
#define GNOME_DB_IS_SELECTOR_TABLE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GNOME_DB_TYPE_SELECTOR_TABLE))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_SELECTOR_TABLE_CLASS</NAME>
#define GNOME_DB_IS_SELECTOR_TABLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GNOME_DB_TYPE_SELECTOR_TABLE))
</MACRO>
<STRUCT>
<NAME>GnomeDbSelectorTable</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbSelectorTableClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbSelectorTablePrivate</NAME>
</STRUCT>
<ENUM>
<NAME>GnomeDbSelectorTableNodeType</NAME>
typedef enum {
	GNOME_DB_SELECTOR_TABLE_COLUMNS = 0,
	GNOME_DB_SELECTOR_TABLE_INDEXES,
	GNOME_DB_SELECTOR_TABLE_CONSTRAINTS,
	GNOME_DB_SELECTOR_TABLE_TRIGGERS,
	GNOME_DB_SELECTOR_TABLE_RULES,

	GNOME_DB_SELECTOR_TABLE_LAST
} GnomeDbSelectorTableNodeType;
</ENUM>
<STRUCT>
<NAME>GnomeDbSelectorTable</NAME>
struct GnomeDbSelectorTable {
	GObject                 object;
	GnomeDbSelectorTablePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbSelectorTableClass</NAME>
struct GnomeDbSelectorTableClass {
	GObjectClass            parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_selector_table_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_selector_table_new</NAME>
<RETURNS>GnomeDbSelectorPart  *</RETURNS>
GdaMetaStore *store
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_ERROR_DIALOG</NAME>
#define GNOME_DB_TYPE_ERROR_DIALOG            (gnome_db_error_dialog_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_ERROR_DIALOG</NAME>
#define GNOME_DB_ERROR_DIALOG(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GNOME_DB_TYPE_ERROR_DIALOG, GnomeDbErrorDialog))
</MACRO>
<MACRO>
<NAME>GNOME_DB_ERROR_DIALOG_CLASS</NAME>
#define GNOME_DB_ERROR_DIALOG_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GNOME_DB_TYPE_ERROR_DIALOG, GnomeDbErrorDialogClass))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_ERROR_DIALOG</NAME>
#define GNOME_DB_IS_ERROR_DIALOG(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GNOME_DB_TYPE_ERROR_DIALOG))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_ERROR_DIALOG_CLASS</NAME>
#define GNOME_DB_IS_ERROR_DIALOG_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GNOME_DB_TYPE_ERROR_DIALOG))
</MACRO>
<STRUCT>
<NAME>GnomeDbErrorDialog</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbErrorDialogClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbErrorDialogPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbErrorDialog</NAME>
struct GnomeDbErrorDialog {
	GtkDialog dialog;
	GnomeDbErrorDialogPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbErrorDialogClass</NAME>
struct GnomeDbErrorDialogClass {
	GtkDialogClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_error_dialog_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_error_dialog_new</NAME>
<RETURNS>GtkWidget    *</RETURNS>
gchar *title
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_error_dialog_show_errors</NAME>
<RETURNS>void  </RETURNS>
GnomeDbErrorDialog *dialog,GList *error_list
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_error_dialog_get_title</NAME>
<RETURNS>const gchar  *</RETURNS>
GnomeDbErrorDialog *dialog
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_error_dialog_set_title</NAME>
<RETURNS>void  </RETURNS>
GnomeDbErrorDialog *dialog,const gchar *title
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_GRAY_BAR</NAME>
#define GNOME_DB_TYPE_GRAY_BAR            (gnome_db_gray_bar_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_GRAY_BAR</NAME>
#define GNOME_DB_GRAY_BAR(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GNOME_DB_TYPE_GRAY_BAR, GnomeDbGrayBar))
</MACRO>
<MACRO>
<NAME>GNOME_DB_GRAY_BAR_CLASS</NAME>
#define GNOME_DB_GRAY_BAR_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GNOME_DB_TYPE_GRAY_BAR, GnomeDbGrayBarClass))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_GRAY_BAR</NAME>
#define GNOME_DB_IS_GRAY_BAR(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GNOME_DB_TYPE_GRAY_BAR))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_GRAY_BAR_CLASS</NAME>
#define GNOME_DB_IS_GRAY_BAR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GNOME_DB_TYPE_GRAY_BAR))
</MACRO>
<STRUCT>
<NAME>GnomeDbGrayBar</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbGrayBarClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbGrayBarPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbGrayBar</NAME>
struct GnomeDbGrayBar {
	GtkBin bin;
	GnomeDbGrayBarPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbGrayBarClass</NAME>
struct GnomeDbGrayBarClass {
	GtkBinClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_gray_bar_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_gray_bar_new</NAME>
<RETURNS>GtkWidget    *</RETURNS>
const gchar *label
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_gray_bar_get_text</NAME>
<RETURNS>const gchar  *</RETURNS>
GnomeDbGrayBar *bar
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_gray_bar_set_text</NAME>
<RETURNS>void  </RETURNS>
GnomeDbGrayBar *bar, const gchar *text
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_gray_bar_set_icon_from_file</NAME>
<RETURNS>void  </RETURNS>
GnomeDbGrayBar *bar, const gchar *file
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_gray_bar_set_icon_from_stock</NAME>
<RETURNS>void  </RETURNS>
GnomeDbGrayBar *bar, const gchar *stock_id, GtkIconSize size
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_gray_bar_set_show_icon</NAME>
<RETURNS>void  </RETURNS>
GnomeDbGrayBar *bar, gboolean show
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_gray_bar_get_show_icon</NAME>
<RETURNS>gboolean  </RETURNS>
GnomeDbGrayBar *bar
</FUNCTION>
<MACRO>
<NAME>extra_marshal_VOID__OBJECT</NAME>
#define extra_marshal_VOID__OBJECT	g_cclosure_marshal_VOID__OBJECT
</MACRO>
<FUNCTION>
<NAME>extra_marshal_STRING__STRING</NAME>
<RETURNS>void  </RETURNS>
GClosure     *closure,GValue       *return_value,guint         n_param_values,const GValue *param_values,gpointer      invocation_hint,gpointer      marshal_data
</FUNCTION>
<FUNCTION>
<NAME>extra_marshal_VOID__POINTER_POINTER</NAME>
<RETURNS>void  </RETURNS>
GClosure     *closure,GValue       *return_value,guint         n_param_values,const GValue *param_values,gpointer      invocation_hint,gpointer      marshal_data
</FUNCTION>
<FUNCTION>
<NAME>extra_marshal_VOID__STRING_POINTER</NAME>
<RETURNS>void  </RETURNS>
GClosure     *closure,GValue       *return_value,guint         n_param_values,const GValue *param_values,gpointer      invocation_hint,gpointer      marshal_data
</FUNCTION>
<FUNCTION>
<NAME>extra_marshal_VOID__OBJECT_OBJECT_POINTER</NAME>
<RETURNS>void  </RETURNS>
GClosure     *closure,GValue       *return_value,guint         n_param_values,const GValue *param_values,gpointer      invocation_hint,gpointer      marshal_data
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_REPORT_EDITOR</NAME>
#define GNOME_DB_TYPE_REPORT_EDITOR            (gnome_db_report_editor_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_REPORT_EDITOR</NAME>
#define GNOME_DB_REPORT_EDITOR(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GNOME_DB_TYPE_REPORT_EDITOR, GnomeDbReportEditor))
</MACRO>
<MACRO>
<NAME>GNOME_DB_REPORT_EDITOR_CLASS</NAME>
#define GNOME_DB_REPORT_EDITOR_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GNOME_DB_TYPE_REPORT_EDITOR, GnomeDbReportEditorClass))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_REPORT_EDITOR</NAME>
#define GNOME_DB_IS_REPORT_EDITOR(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GNOME_DB_TYPE_REPORT_EDITOR))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_REPORT_EDITOR_CLASS</NAME>
#define GNOME_DB_IS_REPORT_EDITOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GNOME_DB_TYPE_REPORT_EDITOR))
</MACRO>
<STRUCT>
<NAME>GnomeDbReportEditor</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbReportEditorClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbReportEditorPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbReportEditor</NAME>
struct GnomeDbReportEditor {
	GtkVBox box;
	GnomeDbReportEditorPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbReportEditorClass</NAME>
struct GnomeDbReportEditorClass {
	GtkVBoxClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_report_editor_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_report_editor_new</NAME>
<RETURNS>GtkWidget  *</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_DSN_EDITOR</NAME>
#define GNOME_DB_TYPE_DSN_EDITOR            (gnome_db_dsn_editor_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_DSN_EDITOR</NAME>
#define GNOME_DB_DSN_EDITOR(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GNOME_DB_TYPE_DSN_EDITOR, GnomeDbDsnEditor))
</MACRO>
<MACRO>
<NAME>GNOME_DB_DSN_EDITOR_CLASS</NAME>
#define GNOME_DB_DSN_EDITOR_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GNOME_DB_TYPE_DSN_EDITOR, GnomeDbDsnEditorClass))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_DSN_EDITOR</NAME>
#define GNOME_DB_IS_DSN_EDITOR(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GNOME_DB_TYPE_DSN_EDITOR))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_DSN_EDITOR_CLASS</NAME>
#define GNOME_DB_IS_DSN_EDITOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GNOME_DB_TYPE_DSN_EDITOR))
</MACRO>
<STRUCT>
<NAME>GnomeDbDsnEditor</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbDsnEditorClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbDsnEditorPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbDsnEditor</NAME>
struct GnomeDbDsnEditor {
	GtkVBox box;
	GnomeDbDsnEditorPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbDsnEditorClass</NAME>
struct GnomeDbDsnEditorClass {
	GtkVBoxClass parent_class;

	/* signals */
	void (* changed) (GnomeDbDsnEditor *config);
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_dsn_editor_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_dsn_editor_new</NAME>
<RETURNS>GtkWidget                *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_dsn_editor_get_dsn</NAME>
<RETURNS>const GdaDsnInfo         *</RETURNS>
GnomeDbDsnEditor *config
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_dsn_editor_set_dsn</NAME>
<RETURNS>void  </RETURNS>
GnomeDbDsnEditor *config,const GdaDsnInfo *dsn_info
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_LOGIN</NAME>
#define GNOME_DB_TYPE_LOGIN            (gnome_db_login_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_LOGIN</NAME>
#define GNOME_DB_LOGIN(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GNOME_DB_TYPE_LOGIN, GnomeDbLogin))
</MACRO>
<MACRO>
<NAME>GNOME_DB_LOGIN_CLASS</NAME>
#define GNOME_DB_LOGIN_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GNOME_DB_TYPE_LOGIN, GnomeDbLoginClass))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_LOGIN</NAME>
#define GNOME_DB_IS_LOGIN(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GNOME_DB_TYPE_LOGIN))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_LOGIN_CLASS</NAME>
#define GNOME_DB_IS_LOGIN_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GNOME_DB_TYPE_LOGIN))
</MACRO>
<STRUCT>
<NAME>GnomeDbLogin</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbLoginClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbLoginPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbLogin</NAME>
struct GnomeDbLogin {
	GtkVBox              parent;
	GnomeDbLoginPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbLoginClass</NAME>
struct GnomeDbLoginClass {
	GtkVBoxClass         parent_class;

	/* signals */
	void               (*dsn_changed) (GnomeDbLogin *login);
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_login_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_login_new</NAME>
<RETURNS>GtkWidget    *</RETURNS>
const gchar *dsn
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_login_get_dsn</NAME>
<RETURNS>const gchar  *</RETURNS>
GnomeDbLogin *login
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_login_set_dsn</NAME>
<RETURNS>void  </RETURNS>
GnomeDbLogin *login, const gchar *dsn
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_login_get_auth</NAME>
<RETURNS>const gchar  *</RETURNS>
GnomeDbLogin *login
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_login_set_auth</NAME>
<RETURNS>void  </RETURNS>
GnomeDbLogin *login, const gchar *auth
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_login_get_username</NAME>
<RETURNS>const gchar  *</RETURNS>
GnomeDbLogin *login
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_login_set_username</NAME>
<RETURNS>void  </RETURNS>
GnomeDbLogin *login, const gchar *username
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_login_get_password</NAME>
<RETURNS>const gchar  *</RETURNS>
GnomeDbLogin *login
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_login_set_password</NAME>
<RETURNS>void  </RETURNS>
GnomeDbLogin *login, const gchar *password
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_login_set_enable_create_button</NAME>
<RETURNS>void  </RETURNS>
GnomeDbLogin *login, gboolean enable
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_login_get_enable_create_button</NAME>
<RETURNS>gboolean  </RETURNS>
GnomeDbLogin *login
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_login_set_show_dsn_selector</NAME>
<RETURNS>void  </RETURNS>
GnomeDbLogin *login, gboolean show
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_login_get_show_dsn_selector</NAME>
<RETURNS>gboolean  </RETURNS>
GnomeDbLogin *login
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_TRANSACTION_STATUS</NAME>
#define GNOME_DB_TYPE_TRANSACTION_STATUS          (gnome_db_transaction_status_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_TRANSACTION_STATUS</NAME>
#define GNOME_DB_TRANSACTION_STATUS(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gnome_db_transaction_status_get_type(), GnomeDbTransactionStatus)
</MACRO>
<MACRO>
<NAME>GNOME_DB_TRANSACTION_STATUS_CLASS</NAME>
#define GNOME_DB_TRANSACTION_STATUS_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gnome_db_transaction_status_get_type (), GnomeDbTransactionStatusClass)
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_TRANSACTION_STATUS</NAME>
#define GNOME_DB_IS_TRANSACTION_STATUS(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gnome_db_transaction_status_get_type ())
</MACRO>
<STRUCT>
<NAME>GnomeDbTransactionStatus</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbTransactionStatusClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbTransactionStatusPriv</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbTransactionStatus</NAME>
struct GnomeDbTransactionStatus
{
	GtkVBox                       object;
	GnomeDbTransactionStatusPriv *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbTransactionStatusClass</NAME>
struct GnomeDbTransactionStatusClass
{
	GtkVBoxClass                  parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_transaction_status_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_transaction_status_new</NAME>
<RETURNS>GtkWidget         *</RETURNS>
GdaConnection *cnc
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_init</NAME>
<RETURNS>void  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_get_application_exec_path</NAME>
<RETURNS>gchar  *</RETURNS>
const gchar *app_name
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_DATA_WIDGET</NAME>
#define GNOME_DB_TYPE_DATA_WIDGET          (gnome_db_data_widget_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_DATA_WIDGET</NAME>
#define GNOME_DB_DATA_WIDGET(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, GNOME_DB_TYPE_DATA_WIDGET, GnomeDbDataWidget)
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_DATA_WIDGET</NAME>
#define GNOME_DB_IS_DATA_WIDGET(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, GNOME_DB_TYPE_DATA_WIDGET)
</MACRO>
<MACRO>
<NAME>GNOME_DB_DATA_WIDGET_GET_IFACE</NAME>
#define GNOME_DB_DATA_WIDGET_GET_IFACE(obj)  (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GNOME_DB_TYPE_DATA_WIDGET, GnomeDbDataWidgetIface))
</MACRO>
<ENUM>
<NAME>GnomeDbDataWidgetWriteMode</NAME>
typedef enum {
	GNOME_DB_DATA_WIDGET_WRITE_ON_DEMAND           = 0, /* write only when explicitely requested */
	GNOME_DB_DATA_WIDGET_WRITE_ON_ROW_CHANGE       = 1, /* write when the current selected row changes */
	GNOME_DB_DATA_WIDGET_WRITE_ON_VALUE_ACTIVATED  = 2, /* write when user activates a value change */
	GNOME_DB_DATA_WIDGET_WRITE_ON_VALUE_CHANGE     = 3  /* write when a parameters's value changes */
} GnomeDbDataWidgetWriteMode;
</ENUM>
<STRUCT>
<NAME>GnomeDbDataWidgetIface</NAME>
struct GnomeDbDataWidgetIface
{
	GTypeInterface           g_iface;

	/* virtual table */
	GdaDataProxy        *(* get_proxy)           (GnomeDbDataWidget *iface);
	void                 (* col_set_show)        (GnomeDbDataWidget *iface, gint column, gboolean shown);
	void                 (* set_column_editable) (GnomeDbDataWidget *iface, gint column, gboolean editable);
	void                 (* show_column_actions) (GnomeDbDataWidget *iface, gint column, gboolean show_actions);
	GtkActionGroup      *(* get_actions_group)   (GnomeDbDataWidget *iface);
	GdaDataModelIter    *(* get_data_set)        (GnomeDbDataWidget *iface);

	GdaDataModel        *(* get_gda_model)       (GnomeDbDataWidget *iface);
	void                 (* set_gda_model)       (GnomeDbDataWidget *iface, GdaDataModel *model);
	gboolean             (* set_write_mode)      (GnomeDbDataWidget *iface, GnomeDbDataWidgetWriteMode mode);
	GnomeDbDataWidgetWriteMode (* get_write_mode)(GnomeDbDataWidget *iface);

	/* signals */
	void                 (* proxy_changed)       (GnomeDbDataWidget *iface, GdaDataProxy *proxy);
	void                 (* iter_changed)        (GnomeDbDataWidget *iface, GdaDataModelIter *iter);
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_data_widget_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_data_widget_get_proxy</NAME>
<RETURNS>GdaDataProxy      *</RETURNS>
GnomeDbDataWidget *iface
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_data_widget_get_actions_group</NAME>
<RETURNS>GtkActionGroup    *</RETURNS>
GnomeDbDataWidget *iface
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_data_widget_perform_action</NAME>
<RETURNS>void  </RETURNS>
GnomeDbDataWidget *iface, GnomeDbAction action
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_data_widget_column_show</NAME>
<RETURNS>void  </RETURNS>
GnomeDbDataWidget *iface, gint column
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_data_widget_column_hide</NAME>
<RETURNS>void  </RETURNS>
GnomeDbDataWidget *iface, gint column
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_data_widget_column_set_editable</NAME>
<RETURNS>void  </RETURNS>
GnomeDbDataWidget *iface, gint column, gboolean editable
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_data_widget_column_show_actions</NAME>
<RETURNS>void  </RETURNS>
GnomeDbDataWidget *iface, gint column, gboolean show_actions
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_data_widget_get_gda_model</NAME>
<RETURNS>GdaDataModel      *</RETURNS>
GnomeDbDataWidget *iface
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_data_widget_set_gda_model</NAME>
<RETURNS>void  </RETURNS>
GnomeDbDataWidget *iface,GdaDataModel *model
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_data_widget_get_current_data</NAME>
<RETURNS>GdaDataModelIter  *</RETURNS>
GnomeDbDataWidget *iface
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_data_widget_set_write_mode</NAME>
<RETURNS>gboolean  </RETURNS>
GnomeDbDataWidget *iface, GnomeDbDataWidgetWriteMode mode
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_data_widget_get_write_mode</NAME>
<RETURNS>GnomeDbDataWidgetWriteMode  </RETURNS>
GnomeDbDataWidget *iface
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_GRID</NAME>
#define GNOME_DB_TYPE_GRID          (gnome_db_grid_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_GRID</NAME>
#define GNOME_DB_GRID(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gnome_db_grid_get_type(), GnomeDbGrid)
</MACRO>
<MACRO>
<NAME>GNOME_DB_GRID_CLASS</NAME>
#define GNOME_DB_GRID_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gnome_db_grid_get_type (), GnomeDbGridClass)
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_GRID</NAME>
#define GNOME_DB_IS_GRID(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gnome_db_grid_get_type ())
</MACRO>
<STRUCT>
<NAME>GnomeDbGrid</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbGridClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbGridPriv</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbGrid</NAME>
struct GnomeDbGrid
{
	GtkVBox             object;

	GnomeDbGridPriv     *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbGridClass</NAME>
struct GnomeDbGridClass
{
	GtkVBoxClass       parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_grid_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_grid_new</NAME>
<RETURNS>GtkWidget         *</RETURNS>
GdaDataModel *model
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_grid_get_selection</NAME>
<RETURNS>GList             *</RETURNS>
GnomeDbGrid *grid
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_grid_set_sample_size</NAME>
<RETURNS>void  </RETURNS>
GnomeDbGrid *grid, gint sample_size
</FUNCTION>
<USER_FUNCTION>
<NAME>GnomeDbPluginInit</NAME>
<RETURNS>GSList *</RETURNS>
GError **
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GnomeDbEntryCreateFunc</NAME>
<RETURNS>GnomeDbDataEntry *</RETURNS>
GdaDataHandler *, GType, const gchar *
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GnomeDbCellCreateFunc</NAME>
<RETURNS>GtkCellRenderer *</RETURNS>
GdaDataHandler *, GType, const gchar *
</USER_FUNCTION>
<STRUCT>
<NAME>GnomeDbPlugin</NAME>
struct GnomeDbPlugin
{
	gchar                  *plugin_name;
	gchar                  *plugin_descr;
	gchar                  *plugin_file;

	guint                   nb_g_types; /* 0 if all types are accepted */
        GType                  *valid_g_types; /* not NULL if @nb_g_types is not 0 */

	gchar                  *options_xml_spec; /* NULL if no option possible */

	/* actual widget creation: one of them must be not NULL */
	GnomeDbEntryCreateFunc  entry_create_func;
	GnomeDbCellCreateFunc   cell_create_func;
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_utility_entry_build_actions_menu</NAME>
<RETURNS>GtkWidget               *</RETURNS>
GObject *obj_data, guint attrs, GCallback function
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_utility_entry_build_info_colors_array</NAME>
<RETURNS>GdkColor               **</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_utility_markup_title</NAME>
<RETURNS>gchar                   *</RETURNS>
const gchar *title, gboolean optional
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_utility_proxy_compute_attributes_for_group</NAME>
<RETURNS>guint  </RETURNS>
GdaSetGroup *group,GnomeDbDataStore *store, GdaDataModelIter *model_iter,GtkTreeIter *tree_iter,gboolean *to_be_deleted
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_utility_proxy_compute_values_for_group</NAME>
<RETURNS>GList            *</RETURNS>
GdaSetGroup *group,GnomeDbDataStore *store, GdaDataModelIter *model_iter,GtkTreeIter *tree_iter, gboolean model_values
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_utility_display_error_with_keep_or_discard_choice</NAME>
<RETURNS>gboolean  </RETURNS>
GnomeDbDataWidget *form, GError *filled_error
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_utility_display_error</NAME>
<RETURNS>void  </RETURNS>
GnomeDbDataWidget *form, gboolean can_discard, GError *filled_error
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_util_init_plugins</NAME>
<RETURNS>void  </RETURNS>

</FUNCTION>
<FUNCTION>
<NAME>gnome_db_util_new_data_entry</NAME>
<RETURNS>GnomeDbDataEntry  *</RETURNS>
GType type, const gchar *plugin_name
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_util_new_cell_renderer</NAME>
<RETURNS>GtkCellRenderer   *</RETURNS>
GType type, const gchar *plugin_name
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_DSN_SELECTOR</NAME>
#define GNOME_DB_TYPE_DSN_SELECTOR            (gnome_db_dsn_selector_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_DSN_SELECTOR</NAME>
#define GNOME_DB_DSN_SELECTOR(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GNOME_DB_TYPE_DSN_SELECTOR, GnomeDbDsnSelector))
</MACRO>
<MACRO>
<NAME>GNOME_DB_DSN_SELECTOR_CLASS</NAME>
#define GNOME_DB_DSN_SELECTOR_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GNOME_DB_TYPE_DSN_SELECTOR, GnomeDbDsnSelectorClass))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_DSN_SELECTOR</NAME>
#define GNOME_DB_IS_DSN_SELECTOR(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GNOME_DB_TYPE_DSN_SELECTOR))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_DSN_SELECTOR_CLASS</NAME>
#define GNOME_DB_IS_DSN_SELECTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GNOME_DB_TYPE_DSN_SELECTOR))
</MACRO>
<STRUCT>
<NAME>GnomeDbDsnSelector</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbDsnSelectorClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbDsnSelectorPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbDsnSelector</NAME>
struct GnomeDbDsnSelector {
	GnomeDbCombo                      combo;
	GnomeDbDsnSelectorPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbDsnSelectorClass</NAME>
struct GnomeDbDsnSelectorClass {
	GnomeDbComboClass                 parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_dsn_selector_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_dsn_selector_new</NAME>
<RETURNS>GtkWidget  *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_dsn_selector_get_dsn</NAME>
<RETURNS>gchar      *</RETURNS>
GnomeDbDsnSelector *selector
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_dsn_selector_set_dsn</NAME>
<RETURNS>void  </RETURNS>
GnomeDbDsnSelector *selector, const gchar *dsn
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_RAW_FORM</NAME>
#define GNOME_DB_TYPE_RAW_FORM          (gnome_db_raw_form_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_RAW_FORM</NAME>
#define GNOME_DB_RAW_FORM(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gnome_db_raw_form_get_type(), GnomeDbRawForm)
</MACRO>
<MACRO>
<NAME>GNOME_DB_RAW_FORM_CLASS</NAME>
#define GNOME_DB_RAW_FORM_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gnome_db_raw_form_get_type (), GnomeDbRawFormClass)
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_RAW_FORM</NAME>
#define GNOME_DB_IS_RAW_FORM(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gnome_db_raw_form_get_type ())
</MACRO>
<STRUCT>
<NAME>GnomeDbRawForm</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbRawFormClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbRawFormPriv</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbRawForm</NAME>
struct GnomeDbRawForm
{
	GnomeDbBasicForm      object;

	GnomeDbRawFormPriv   *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbRawFormClass</NAME>
struct GnomeDbRawFormClass
{
	GnomeDbBasicFormClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_raw_form_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_raw_form_new</NAME>
<RETURNS>GtkWidget    *</RETURNS>
GdaDataModel *model
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_DATA_ENTRY</NAME>
#define GNOME_DB_TYPE_DATA_ENTRY          (gnome_db_data_entry_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_DATA_ENTRY</NAME>
#define GNOME_DB_DATA_ENTRY(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, GNOME_DB_TYPE_DATA_ENTRY, GnomeDbDataEntry)
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_DATA_ENTRY</NAME>
#define GNOME_DB_IS_DATA_ENTRY(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, GNOME_DB_TYPE_DATA_ENTRY)
</MACRO>
<MACRO>
<NAME>GNOME_DB_DATA_ENTRY_GET_IFACE</NAME>
#define GNOME_DB_DATA_ENTRY_GET_IFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GNOME_DB_TYPE_DATA_ENTRY, GnomeDbDataEntryIface))
</MACRO>
<STRUCT>
<NAME>GnomeDbDataEntryIface</NAME>
struct GnomeDbDataEntryIface
{
	GTypeInterface           g_iface;

	/* signals */
	void            (* contents_modified)    (GnomeDbDataEntry *de);
	void            (* contents_activated)   (GnomeDbDataEntry *de);
	void            (* status_changed)       (GnomeDbDataEntry *de);
	gboolean        (* contents_valid)       (GnomeDbDataEntry *de, GError **error);

	/* virtual table */
	void            (*set_value_type)        (GnomeDbDataEntry *de, GType type);
	GType           (*get_value_type)        (GnomeDbDataEntry *de);
	void            (*set_value)             (GnomeDbDataEntry *de, const GValue * value);
	GValue         *(*get_value)             (GnomeDbDataEntry *de);
	void            (*set_value_orig)        (GnomeDbDataEntry *de, const GValue * value);
	const GValue   *(*get_value_orig)        (GnomeDbDataEntry *de);
	void            (*set_value_default)     (GnomeDbDataEntry *de, const GValue * value);
	void            (*set_attributes)        (GnomeDbDataEntry *de, GdaValueAttribute attrs, GdaValueAttribute mask);
	GdaValueAttribute (*get_attributes)      (GnomeDbDataEntry *de);
	GdaDataHandler *(*get_handler)           (GnomeDbDataEntry *de);
	gboolean        (*expand_in_layout)      (GnomeDbDataEntry *de);
	void            (*set_editable)          (GnomeDbDataEntry *de, gboolean editable);
	void            (*grab_focus)            (GnomeDbDataEntry *de);
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_data_entry_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_data_entry_set_value_type</NAME>
<RETURNS>void  </RETURNS>
GnomeDbDataEntry *de, GType type
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_data_entry_get_value_type</NAME>
<RETURNS>GType  </RETURNS>
GnomeDbDataEntry *de
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_data_entry_set_value</NAME>
<RETURNS>void  </RETURNS>
GnomeDbDataEntry *de, const GValue * value
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_data_entry_get_value</NAME>
<RETURNS>GValue          *</RETURNS>
GnomeDbDataEntry *de
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_data_entry_is_contents_valid</NAME>
<RETURNS>gboolean  </RETURNS>
GnomeDbDataEntry *de, GError **error
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_data_entry_set_value_orig</NAME>
<RETURNS>void  </RETURNS>
GnomeDbDataEntry *de, const GValue * value
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_data_entry_get_value_orig</NAME>
<RETURNS>const GValue    *</RETURNS>
GnomeDbDataEntry *de
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_data_entry_set_current_as_orig</NAME>
<RETURNS>void  </RETURNS>
GnomeDbDataEntry *de
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_data_entry_set_value_default</NAME>
<RETURNS>void  </RETURNS>
GnomeDbDataEntry *de, const GValue * value
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_data_entry_set_attributes</NAME>
<RETURNS>void  </RETURNS>
GnomeDbDataEntry *de, GdaValueAttribute attrs, GdaValueAttribute mask
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_data_entry_get_attributes</NAME>
<RETURNS>GdaValueAttribute  </RETURNS>
GnomeDbDataEntry *de
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_data_entry_get_handler</NAME>
<RETURNS>GdaDataHandler  *</RETURNS>
GnomeDbDataEntry *de
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_data_entry_expand_in_layout</NAME>
<RETURNS>gboolean  </RETURNS>
GnomeDbDataEntry *de
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_data_entry_set_editable</NAME>
<RETURNS>void  </RETURNS>
GnomeDbDataEntry *de, gboolean editable
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_data_entry_grab_focus</NAME>
<RETURNS>void  </RETURNS>
GnomeDbDataEntry *de
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_PROVIDER_SPEC_EDITOR</NAME>
#define GNOME_DB_TYPE_PROVIDER_SPEC_EDITOR            (gnome_db_provider_spec_editor_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_PROVIDER_SPEC_EDITOR</NAME>
#define GNOME_DB_PROVIDER_SPEC_EDITOR(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GNOME_DB_TYPE_PROVIDER_SPEC_EDITOR, GnomeDbProviderSpecEditor))
</MACRO>
<MACRO>
<NAME>GNOME_DB_PROVIDER_SPEC_EDITOR_CLASS</NAME>
#define GNOME_DB_PROVIDER_SPEC_EDITOR_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GNOME_DB_TYPE_PROVIDER_SPEC_EDITOR, GnomeDbProviderSpecEditorClass))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_PROVIDER_SPEC_EDITOR</NAME>
#define GNOME_DB_IS_PROVIDER_SPEC_EDITOR(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GNOME_DB_TYPE_PROVIDER_SPEC_EDITOR))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_PROVIDER_SPEC_EDITOR_CLASS</NAME>
#define GNOME_DB_IS_PROVIDER_SPEC_EDITOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GNOME_DB_TYPE_PROVIDER_SPEC_EDITOR))
</MACRO>
<STRUCT>
<NAME>GnomeDbProviderSpecEditor</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbProviderSpecEditorClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbProviderSpecEditorPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbProviderSpecEditor</NAME>
struct GnomeDbProviderSpecEditor {
	GtkVBox                box;
	GnomeDbProviderSpecEditorPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbProviderSpecEditorClass</NAME>
struct GnomeDbProviderSpecEditorClass {
	GtkVBoxClass           parent_class;

	/* signals */
	void                (* changed) (GnomeDbProviderSpecEditor *spec);
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_provider_spec_editor_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_provider_spec_editor_new</NAME>
<RETURNS>GtkWidget   *</RETURNS>
const gchar *provider
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_provider_spec_editor_set_provider</NAME>
<RETURNS>void  </RETURNS>
GnomeDbProviderSpecEditor *spec, const gchar *provider
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_provider_spec_editor_is_valid</NAME>
<RETURNS>gboolean  </RETURNS>
GnomeDbProviderSpecEditor *spec
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_provider_spec_editor_get_specs</NAME>
<RETURNS>gchar       *</RETURNS>
GnomeDbProviderSpecEditor *spec
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_provider_spec_editor_set_specs</NAME>
<RETURNS>void  </RETURNS>
GnomeDbProviderSpecEditor *spec, const gchar *specs_string
</FUNCTION>
<ENUM>
<NAME>GnomeDbActionMode</NAME>
typedef enum {
	/* navigation modes */
	GNOME_DB_ACTION_NAVIGATION_ARROWS       = 1 << 0,
	GNOME_DB_ACTION_NAVIGATION_SCROLL       = 1 << 1,

	/* modifications */
	GNOME_DB_ACTION_MODIF_AUTO_COMMIT       = 1 << 2,
	GNOME_DB_ACTION_MODIF_COMMIT_IMMEDIATE  = 1 << 3,
	GNOME_DB_ACTION_ASK_CONFIRM_UPDATE      = 1 << 4,
	GNOME_DB_ACTION_ASK_CONFIRM_DELETE      = 1 << 5,
	GNOME_DB_ACTION_ASK_CONFIRM_INSERT      = 1 << 6,

	/* Error reporting */
	GNOME_DB_ACTION_REPORT_ERROR            = 1 << 7
} GnomeDbActionMode;
</ENUM>
<ENUM>
<NAME>GnomeDbAction</NAME>
typedef enum {
	/* actions in GnomeDbDataWidget widgets */
	GNOME_DB_ACTION_NEW_DATA,
	GNOME_DB_ACTION_WRITE_MODIFIED_DATA,
	GNOME_DB_ACTION_DELETE_SELECTED_DATA,
	GNOME_DB_ACTION_UNDELETE_SELECTED_DATA,
	GNOME_DB_ACTION_RESET_DATA,
	GNOME_DB_ACTION_MOVE_FIRST_RECORD,
	GNOME_DB_ACTION_MOVE_PREV_RECORD,
	GNOME_DB_ACTION_MOVE_NEXT_RECORD,
	GNOME_DB_ACTION_MOVE_LAST_RECORD,
	GNOME_DB_ACTION_MOVE_FIRST_CHUNCK,
        GNOME_DB_ACTION_MOVE_PREV_CHUNCK,
        GNOME_DB_ACTION_MOVE_NEXT_CHUNCK,
        GNOME_DB_ACTION_MOVE_LAST_CHUNCK
} GnomeDbAction;
</ENUM>
<MACRO>
<NAME>GNOME_DB_ATTRIBUTE_PLUGIN</NAME>
#define GNOME_DB_ATTRIBUTE_PLUGIN "__gnomedb_attr_plugin" /* G_TYPE_STRING expected */
</MACRO>
<MACRO>
<NAME>GNOME_DB_TYPE_PROVIDER_AUTH_EDITOR</NAME>
#define GNOME_DB_TYPE_PROVIDER_AUTH_EDITOR            (gnome_db_provider_auth_editor_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_PROVIDER_AUTH_EDITOR</NAME>
#define GNOME_DB_PROVIDER_AUTH_EDITOR(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GNOME_DB_TYPE_PROVIDER_AUTH_EDITOR, GnomeDbProviderAuthEditor))
</MACRO>
<MACRO>
<NAME>GNOME_DB_PROVIDER_AUTH_EDITOR_CLASS</NAME>
#define GNOME_DB_PROVIDER_AUTH_EDITOR_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GNOME_DB_TYPE_PROVIDER_AUTH_EDITOR, GnomeDbProviderAuthEditorClass))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_PROVIDER_AUTH_EDITOR</NAME>
#define GNOME_DB_IS_PROVIDER_AUTH_EDITOR(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GNOME_DB_TYPE_PROVIDER_AUTH_EDITOR))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_PROVIDER_AUTH_EDITOR_CLASS</NAME>
#define GNOME_DB_IS_PROVIDER_AUTH_EDITOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GNOME_DB_TYPE_PROVIDER_AUTH_EDITOR))
</MACRO>
<STRUCT>
<NAME>GnomeDbProviderAuthEditor</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbProviderAuthEditorClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbProviderAuthEditorPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbProviderAuthEditor</NAME>
struct GnomeDbProviderAuthEditor {
	GtkVBox                box;
	GnomeDbProviderAuthEditorPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbProviderAuthEditorClass</NAME>
struct GnomeDbProviderAuthEditorClass {
	GtkVBoxClass           parent_class;

	/* signals */
	void                (* changed) (GnomeDbProviderAuthEditor *auth);
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_provider_auth_editor_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_provider_auth_editor_new</NAME>
<RETURNS>GtkWidget   *</RETURNS>
const gchar *provider
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_provider_auth_editor_set_provider</NAME>
<RETURNS>void  </RETURNS>
GnomeDbProviderAuthEditor *auth, const gchar *provider
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_provider_auth_editor_is_valid</NAME>
<RETURNS>gboolean  </RETURNS>
GnomeDbProviderAuthEditor *auth
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_provider_auth_editor_get_auth</NAME>
<RETURNS>gchar       *</RETURNS>
GnomeDbProviderAuthEditor *auth
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_provider_auth_editor_set_auth</NAME>
<RETURNS>void  </RETURNS>
GnomeDbProviderAuthEditor *auth, const gchar *auth_string
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_DATA_STORE</NAME>
#define GNOME_DB_TYPE_DATA_STORE          (gnome_db_data_store_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_DATA_STORE</NAME>
#define GNOME_DB_DATA_STORE(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gnome_db_data_store_get_type(), GnomeDbDataStore)
</MACRO>
<MACRO>
<NAME>GNOME_DB_DATA_STORE_CLASS</NAME>
#define GNOME_DB_DATA_STORE_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gnome_db_data_store_get_type (), GnomeDbDataStoreClass)
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_DATA_STORE</NAME>
#define GNOME_DB_IS_DATA_STORE(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gnome_db_data_store_get_type ())
</MACRO>
<STRUCT>
<NAME>GnomeDbDataStore</NAME>
struct GnomeDbDataStore
{
	GObject                object;

	GnomeDbDataStorePriv  *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbDataStoreClass</NAME>
struct GnomeDbDataStoreClass
{
	GObjectClass           parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_data_store_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_data_store_new</NAME>
<RETURNS>GtkTreeModel    *</RETURNS>
GdaDataModel *model
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_data_store_get_proxy</NAME>
<RETURNS>GdaDataProxy    *</RETURNS>
GnomeDbDataStore *store
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_data_store_get_row_from_iter</NAME>
<RETURNS>gint  </RETURNS>
GnomeDbDataStore *store, GtkTreeIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_data_store_get_iter_from_values</NAME>
<RETURNS>gboolean  </RETURNS>
GnomeDbDataStore *store, GtkTreeIter *iter,GSList *values, gint *cols_index
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_data_store_set_value</NAME>
<RETURNS>gboolean  </RETURNS>
GnomeDbDataStore *store, GtkTreeIter *iter,gint col, const GValue *value
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_data_store_delete</NAME>
<RETURNS>void  </RETURNS>
GnomeDbDataStore *store, GtkTreeIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_data_store_undelete</NAME>
<RETURNS>void  </RETURNS>
GnomeDbDataStore *store, GtkTreeIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_data_store_append</NAME>
<RETURNS>gboolean  </RETURNS>
GnomeDbDataStore *store, GtkTreeIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_data_widget_write_mode_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_DB_DATA_WIDGET_WRITE_MODE</NAME>
#define GNOME_DB_TYPE_DB_DATA_WIDGET_WRITE_MODE (gnome_db_data_widget_write_mode_get_type())
</MACRO>
<FUNCTION>
<NAME>gnome_db_data_widget_info_flag_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_DB_DATA_WIDGET_INFO_FLAG</NAME>
#define GNOME_DB_TYPE_DB_DATA_WIDGET_INFO_FLAG (gnome_db_data_widget_info_flag_get_type())
</MACRO>
<FUNCTION>
<NAME>gnome_db_action_mode_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_DB_ACTION_MODE</NAME>
#define GNOME_DB_TYPE_DB_ACTION_MODE (gnome_db_action_mode_get_type())
</MACRO>
<FUNCTION>
<NAME>gnome_db_action_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_DB_ACTION</NAME>
#define GNOME_DB_TYPE_DB_ACTION (gnome_db_action_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_TYPE_FIND_DIALOG</NAME>
#define GNOME_DB_TYPE_FIND_DIALOG            (gnome_db_find_dialog_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_FIND_DIALOG</NAME>
#define GNOME_DB_FIND_DIALOG(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GNOME_DB_TYPE_FIND_DIALOG,  GnomeDbFindDialog))
</MACRO>
<MACRO>
<NAME>GNOME_DB_FIND_DIALOG_CLASS</NAME>
#define GNOME_DB_FIND_DIALOG_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (obj, GNOME_DB_TYPE_FIND_DIALOG, GnomeDbFindDialogClass))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_FIND_DIALOG</NAME>
#define GNOME_DB_IS_FIND_DIALOG(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GNOME_DB_TYPE_FIND_DIALOG))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_FIND_DIALOG_CLASS</NAME>
#define GNOME_DB_IS_FIND_DIALOG_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GNOME_DB_TYPE_FIND_DIALOG))
</MACRO>
<STRUCT>
<NAME>GnomeDbFindDialog</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbFindDialogClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbFindDialogPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbFindDialog</NAME>
struct GnomeDbFindDialog {
	/*< PRIVATE >*/
	GtkDialog dialog;
	GnomeDbFindDialogPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbFindDialogClass</NAME>
struct GnomeDbFindDialogClass {
	GtkDialogClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_find_dialog_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_find_dialog_new</NAME>
<RETURNS>GtkWidget              *</RETURNS>
const gchar *title
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_find_dialog_new_with_model</NAME>
<RETURNS>GtkWidget              *</RETURNS>
const gchar *title, GdaDataModel *dm
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_find_dialog_run</NAME>
<RETURNS>gboolean  </RETURNS>
GnomeDbFindDialog *dialog
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_find_dialog_add_field</NAME>
<RETURNS>void  </RETURNS>
GnomeDbFindDialog *dialog, const gchar *field
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_find_dialog_add_fields_from_model</NAME>
<RETURNS>void  </RETURNS>
GnomeDbFindDialog *dialog, GdaDataModel *dm
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_find_dialog_get_field</NAME>
<RETURNS>G_CONST_RETURN gchar *</RETURNS>
GnomeDbFindDialog *dialog
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_find_dialog_get_text</NAME>
<RETURNS>G_CONST_RETURN gchar *</RETURNS>
GnomeDbFindDialog *dialog
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_DSN_ASSISTANT</NAME>
#define GNOME_DB_TYPE_DSN_ASSISTANT            (gnome_db_dsn_assistant_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_DSN_ASSISTANT</NAME>
#define GNOME_DB_DSN_ASSISTANT(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GNOME_DB_TYPE_DSN_ASSISTANT, GnomeDbDsnAssistant))
</MACRO>
<MACRO>
<NAME>GNOME_DB_DSN_ASSISTANT_CLASS</NAME>
#define GNOME_DB_DSN_ASSISTANT_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GNOME_DB_TYPE_DSN_ASSISTANT, GnomeDbDsnAssistantClass))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_DSN_ASSISTANT</NAME>
#define GNOME_DB_IS_DSN_ASSISTANT(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GNOME_DB_TYPE_DSN_ASSISTANT))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_DSN_ASSISTANT_CLASS</NAME>
#define GNOME_DB_IS_DSN_ASSISTANT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GNOME_DB_TYPE_DSN_ASSISTANT))
</MACRO>
<STRUCT>
<NAME>GnomeDbDsnAssistant</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbDsnAssistantClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbDsnAssistantPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbDsnAssistant</NAME>
struct GnomeDbDsnAssistant {
	GtkAssistant                assistant;
	GnomeDbDsnAssistantPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbDsnAssistantClass</NAME>
struct GnomeDbDsnAssistantClass {
	GtkAssistantClass           parent_class;

	void                     (* finished) (GnomeDbDsnAssistant *assistant, gboolean error);
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_dsn_assistant_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_dsn_assistant_new</NAME>
<RETURNS>GtkWidget                *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_dsn_assistant_get_dsn</NAME>
<RETURNS>const GdaDsnInfo  *</RETURNS>
GnomeDbDsnAssistant *assistant
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_BASIC_FORM</NAME>
#define GNOME_DB_TYPE_BASIC_FORM          (gnome_db_basic_form_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_BASIC_FORM</NAME>
#define GNOME_DB_BASIC_FORM(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gnome_db_basic_form_get_type(), GnomeDbBasicForm)
</MACRO>
<MACRO>
<NAME>GNOME_DB_BASIC_FORM_CLASS</NAME>
#define GNOME_DB_BASIC_FORM_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gnome_db_basic_form_get_type (), GnomeDbBasicFormClass)
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_BASIC_FORM</NAME>
#define GNOME_DB_IS_BASIC_FORM(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gnome_db_basic_form_get_type ())
</MACRO>
<STRUCT>
<NAME>GnomeDbFormLayoutSpec</NAME>
struct GnomeDbFormLayoutSpec
{
#ifdef HAVE_LIBGLADE
	GladeXML *xml_object; /* one of xml_object or */
#endif
	gchar    *xml_file;   /* xml_file is required */

	gchar    *root_element; /* required */
	gchar    *form_prefix;  /* required */
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbBasicForm</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbBasicFormClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbBasicFormPriv</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbBasicForm</NAME>
struct GnomeDbBasicForm
{
	GtkVBox               object;

	GnomeDbBasicFormPriv *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbBasicFormClass</NAME>
struct GnomeDbBasicFormClass
{
	GtkVBoxClass          parent_class;

	/* signals */
        void       (*param_changed)         (GnomeDbBasicForm *form, GdaHolder *param, gboolean is_user_modif);
	void       (*activated)             (GnomeDbBasicForm *form);
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_basic_form_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_basic_form_new</NAME>
<RETURNS>GtkWidget         *</RETURNS>
GdaSet *data_set
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_basic_form_new_custom</NAME>
<RETURNS>GtkWidget         *</RETURNS>
GdaSet *data_set, const gchar *glade_file,const gchar *root_element, const gchar *form_prefix
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_basic_form_new_in_dialog</NAME>
<RETURNS>GtkWidget         *</RETURNS>
GdaSet *data_set, GtkWindow *parent,const gchar *title, const gchar *header
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_basic_form_get_data_set</NAME>
<RETURNS>GdaSet            *</RETURNS>
GnomeDbBasicForm *form
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_basic_form_is_valid</NAME>
<RETURNS>gboolean  </RETURNS>
GnomeDbBasicForm *form
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_basic_form_has_been_changed</NAME>
<RETURNS>gboolean  </RETURNS>
GnomeDbBasicForm *form
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_basic_form_reset</NAME>
<RETURNS>void  </RETURNS>
GnomeDbBasicForm *form
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_basic_form_set_current_as_orig</NAME>
<RETURNS>void  </RETURNS>
GnomeDbBasicForm *form
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_basic_form_show_entry_actions</NAME>
<RETURNS>void  </RETURNS>
GnomeDbBasicForm *form, gboolean show_actions
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_basic_form_entry_show</NAME>
<RETURNS>void  </RETURNS>
GnomeDbBasicForm *form,GdaHolder *param, gboolean show
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_basic_form_entry_grab_focus</NAME>
<RETURNS>void  </RETURNS>
GnomeDbBasicForm *form, GdaHolder *param
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_basic_form_entry_set_editable</NAME>
<RETURNS>void  </RETURNS>
GnomeDbBasicForm *form, GdaHolder *param,gboolean editable
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_basic_form_set_entries_auto_default</NAME>
<RETURNS>void  </RETURNS>
GnomeDbBasicForm *form, gboolean auto_default
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_basic_form_set_entries_default</NAME>
<RETURNS>void  </RETURNS>
GnomeDbBasicForm *form
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_basic_form_get_entry_widget</NAME>
<RETURNS>GtkWidget         *</RETURNS>
GnomeDbBasicForm *form, GdaHolder *param
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_basic_form_get_label_widget</NAME>
<RETURNS>GtkWidget         *</RETURNS>
GnomeDbBasicForm *form, GdaHolder *param
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_DATA_IMPORT</NAME>
#define GNOME_DB_TYPE_DATA_IMPORT          (gnome_db_data_import_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_DATA_IMPORT</NAME>
#define GNOME_DB_DATA_IMPORT(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gnome_db_data_import_get_type(), GnomeDbDataImport)
</MACRO>
<MACRO>
<NAME>GNOME_DB_DATA_IMPORT_CLASS</NAME>
#define GNOME_DB_DATA_IMPORT_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gnome_db_data_import_get_type (), GnomeDbDataImportClass)
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_DATA_IMPORT</NAME>
#define GNOME_DB_IS_DATA_IMPORT(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gnome_db_data_import_get_type ())
</MACRO>
<STRUCT>
<NAME>GnomeDbDataImport</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbDataImportClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbDataImportPriv</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbDataImport</NAME>
struct GnomeDbDataImport
{
	GtkVPaned              object;

	GnomeDbDataImportPriv *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbDataImportClass</NAME>
struct GnomeDbDataImportClass
{
	GtkVPanedClass         parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_data_import_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_data_import_new</NAME>
<RETURNS>GtkWidget     *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_data_import_get_model</NAME>
<RETURNS>GdaDataModel  *</RETURNS>
GnomeDbDataImport *import
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_LOGIN_DIALOG</NAME>
#define GNOME_DB_TYPE_LOGIN_DIALOG            (gnome_db_login_dialog_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_LOGIN_DIALOG</NAME>
#define GNOME_DB_LOGIN_DIALOG(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GNOME_DB_TYPE_LOGIN_DIALOG, GnomeDbLoginDialog))
</MACRO>
<MACRO>
<NAME>GNOME_DB_LOGIN_DIALOG_CLASS</NAME>
#define GNOME_DB_LOGIN_DIALOG_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GNOME_DB_TYPE_LOGIN_DIALOG, GnomeDbLoginDialogClass))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_LOGIN_DIALOG</NAME>
#define GNOME_DB_IS_LOGIN_DIALOG(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GNOME_DB_TYPE_LOGIN_DIALOG))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_LOGIN_DIALOG_CLASS</NAME>
#define GNOME_DB_IS_LOGIN_DIALOG_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GNOME_DB_TYPE_LOGIN_DIALOG))
</MACRO>
<STRUCT>
<NAME>GnomeDbLoginDialog</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbLoginDialogClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbLoginDialogPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbLoginDialog</NAME>
struct GnomeDbLoginDialog {
	GtkDialog dialog;
	GnomeDbLoginDialogPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbLoginDialogClass</NAME>
struct GnomeDbLoginDialogClass {
	GtkDialogClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_login_dialog_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_login_dialog_new</NAME>
<RETURNS>GtkWidget    *</RETURNS>
const gchar *title, GtkWindow *parent
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_login_dialog_run</NAME>
<RETURNS>gboolean  </RETURNS>
GnomeDbLoginDialog *dialog
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_login_dialog_get_dsn</NAME>
<RETURNS>const gchar  *</RETURNS>
GnomeDbLoginDialog *dialog
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_login_dialog_get_auth</NAME>
<RETURNS>const gchar  *</RETURNS>
GnomeDbLoginDialog *dialog
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_login_dialog_get_username</NAME>
<RETURNS>const gchar  *</RETURNS>
GnomeDbLoginDialog *dialog
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_login_dialog_get_password</NAME>
<RETURNS>const gchar  *</RETURNS>
GnomeDbLoginDialog *dialog
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_login_dialog_get_login_widget</NAME>
<RETURNS>GnomeDbLogin    *</RETURNS>
GnomeDbLoginDialog *dialog
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_COMBO</NAME>
#define GNOME_DB_TYPE_COMBO            (gnome_db_combo_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_COMBO</NAME>
#define GNOME_DB_COMBO(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GNOME_DB_TYPE_COMBO, GnomeDbCombo))
</MACRO>
<MACRO>
<NAME>GNOME_DB_COMBO_CLASS</NAME>
#define GNOME_DB_COMBO_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GNOME_DB_TYPE_COMBO, GnomeDbComboClass))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_COMBO</NAME>
#define GNOME_DB_IS_COMBO(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GNOME_DB_TYPE_COMBO))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_COMBO_CLASS</NAME>
#define GNOME_DB_IS_COMBO_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GNOME_DB_TYPE_COMBO))
</MACRO>
<STRUCT>
<NAME>GnomeDbCombo</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbComboClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbComboPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbCombo</NAME>
struct GnomeDbCombo {
	GtkComboBox          object;
	GnomeDbComboPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbComboClass</NAME>
struct GnomeDbComboClass {
	GtkComboBoxClass     parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_combo_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_combo_new</NAME>
<RETURNS>GtkWidget     *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_combo_new_with_model</NAME>
<RETURNS>GtkWidget     *</RETURNS>
GdaDataModel *model, gint n_cols, gint *cols_index
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_combo_set_model</NAME>
<RETURNS>void  </RETURNS>
GnomeDbCombo *combo, GdaDataModel *model, gint n_cols, gint *cols_index
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_combo_get_model</NAME>
<RETURNS>GdaDataModel  *</RETURNS>
GnomeDbCombo *combo
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_combo_add_undef_choice</NAME>
<RETURNS>void  </RETURNS>
GnomeDbCombo *combo, gboolean add_undef_choice
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_combo_set_values</NAME>
<RETURNS>gboolean  </RETURNS>
GnomeDbCombo *combo, const GSList *values
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_combo_get_values</NAME>
<RETURNS>GSList        *</RETURNS>
GnomeDbCombo *combo
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_combo_undef_selected</NAME>
<RETURNS>gboolean  </RETURNS>
GnomeDbCombo *combo
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_combo_set_values_ext</NAME>
<RETURNS>gboolean  </RETURNS>
GnomeDbCombo *combo, const GSList *values, gint *cols_index
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_combo_get_values_ext</NAME>
<RETURNS>GSList        *</RETURNS>
GnomeDbCombo *combo, gint n_cols, gint *cols_index
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_DATA_WIDGET_FILTER</NAME>
#define GNOME_DB_TYPE_DATA_WIDGET_FILTER          (gnome_db_data_widget_filter_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_DATA_WIDGET_FILTER</NAME>
#define GNOME_DB_DATA_WIDGET_FILTER(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gnome_db_data_widget_filter_get_type(), GnomeDbDataWidgetFilter)
</MACRO>
<MACRO>
<NAME>GNOME_DB_DATA_WIDGET_FILTER_CLASS</NAME>
#define GNOME_DB_DATA_WIDGET_FILTER_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gnome_db_data_widget_filter_get_type (), GnomeDbDataWidgetFilterClass)
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_DATA_WIDGET_FILTER</NAME>
#define GNOME_DB_IS_DATA_WIDGET_FILTER(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gnome_db_data_widget_filter_get_type ())
</MACRO>
<STRUCT>
<NAME>GnomeDbDataWidgetFilter</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbDataWidgetFilterClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbDataWidgetFilterPriv</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbDataWidgetFilter</NAME>
struct GnomeDbDataWidgetFilter
{
	GtkVBox                      object;

	GnomeDbDataWidgetFilterPriv *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbDataWidgetFilterClass</NAME>
struct GnomeDbDataWidgetFilterClass
{
	GtkVBoxClass                 parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_data_widget_filter_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_data_widget_filter_new</NAME>
<RETURNS>GtkWidget         *</RETURNS>
GnomeDbDataWidget *data_widget
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_STOCK_AGGREGATES</NAME>
#define GNOME_DB_STOCK_AGGREGATES         "gnome-db-aggregates"
</MACRO>
<MACRO>
<NAME>GNOME_DB_STOCK_COMMIT</NAME>
#define GNOME_DB_STOCK_COMMIT             "gnome-db-commit"
</MACRO>
<MACRO>
<NAME>GNOME_DB_STOCK_CONNECT</NAME>
#define GNOME_DB_STOCK_CONNECT            "gnome-db-connect"
</MACRO>
<MACRO>
<NAME>GNOME_DB_STOCK_DISCONNECT</NAME>
#define GNOME_DB_STOCK_DISCONNECT         "gnome-db-disconnect"
</MACRO>
<MACRO>
<NAME>GNOME_DB_STOCK_DATABASE</NAME>
#define GNOME_DB_STOCK_DATABASE           "gnome-db-database"
</MACRO>
<MACRO>
<NAME>GNOME_DB_STOCK_DESIGNER</NAME>
#define GNOME_DB_STOCK_DESIGNER           "gnome-db-designer"
</MACRO>
<MACRO>
<NAME>GNOME_DB_STOCK_NO_TRANSACTION</NAME>
#define GNOME_DB_STOCK_NO_TRANSACTION     "gnome-db-no-transaction"
</MACRO>
<MACRO>
<NAME>GNOME_DB_STOCK_PROCEDURES</NAME>
#define GNOME_DB_STOCK_PROCEDURES         "gnome-db-procedures"
</MACRO>
<MACRO>
<NAME>GNOME_DB_STOCK_QUERY</NAME>
#define GNOME_DB_STOCK_QUERY              "gnome-db-query"
</MACRO>
<MACRO>
<NAME>GNOME_DB_STOCK_ROLLBACK</NAME>
#define GNOME_DB_STOCK_ROLLBACK           "gnome-db-rollback"
</MACRO>
<MACRO>
<NAME>GNOME_DB_STOCK_SEQUENCES</NAME>
#define GNOME_DB_STOCK_SEQUENCES          "gnome-db-sequences"
</MACRO>
<MACRO>
<NAME>GNOME_DB_STOCK_SQL</NAME>
#define GNOME_DB_STOCK_SQL                "gnome-db-sql"
</MACRO>
<MACRO>
<NAME>GNOME_DB_STOCK_TABLES</NAME>
#define GNOME_DB_STOCK_TABLES             "gnome-db-tables"
</MACRO>
<MACRO>
<NAME>GNOME_DB_STOCK_TYPES</NAME>
#define GNOME_DB_STOCK_TYPES              "gnome-db-types"
</MACRO>
<MACRO>
<NAME>GNOME_DB_STOCK_WITHIN_TRANSACTION</NAME>
#define GNOME_DB_STOCK_WITHIN_TRANSACTION "gnome-db-within-transaction"
</MACRO>
<MACRO>
<NAME>GNOME_DB_STOCK_RELATIONS</NAME>
#define GNOME_DB_STOCK_RELATIONS          "gnome-db-relations"
</MACRO>
<MACRO>
<NAME>GNOME_DB_STOCK_SQL_CONSOLE</NAME>
#define GNOME_DB_STOCK_SQL_CONSOLE        "gnome-db-console"
</MACRO>
<FUNCTION>
<NAME>gnome_db_stock_get_icon_pixbuf</NAME>
<RETURNS>GdkPixbuf  *</RETURNS>
const gchar *stock_id
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_stock_get_icon_pixbuf_file</NAME>
<RETURNS>GdkPixbuf  *</RETURNS>
const gchar *pixmapfile
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_stock_get_icon_path</NAME>
<RETURNS>gchar      *</RETURNS>
const gchar *stock_id
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_SERVER_OPERATION</NAME>
#define GNOME_DB_TYPE_SERVER_OPERATION          (gnome_db_server_operation_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_SERVER_OPERATION</NAME>
#define GNOME_DB_SERVER_OPERATION(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gnome_db_server_operation_get_type(), GnomeDbServerOperation)
</MACRO>
<MACRO>
<NAME>GNOME_DB_SERVER_OPERATION_CLASS</NAME>
#define GNOME_DB_SERVER_OPERATION_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gnome_db_server_operation_get_type (), GnomeDbServerOperationClass)
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_SERVER_OPERATION</NAME>
#define GNOME_DB_IS_SERVER_OPERATION(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gnome_db_server_operation_get_type ())
</MACRO>
<STRUCT>
<NAME>GnomeDbServerOperation</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbServerOperationClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbServerOperationPriv</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbServerOperation</NAME>
struct GnomeDbServerOperation
{
	GtkVBox                     object;
	GnomeDbServerOperationPriv *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbServerOperationClass</NAME>
struct GnomeDbServerOperationClass
{
	GtkVBoxClass                parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_server_operation_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_server_operation_new</NAME>
<RETURNS>GtkWidget         *</RETURNS>
GdaServerOperation *op
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_server_operation_new_in_dialog</NAME>
<RETURNS>GtkWidget         *</RETURNS>
GdaServerOperation *op, GtkWindow *parent,const gchar *title, const gchar *header
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_PROVIDER_SELECTOR</NAME>
#define GNOME_DB_TYPE_PROVIDER_SELECTOR            (gnome_db_provider_selector_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_PROVIDER_SELECTOR</NAME>
#define GNOME_DB_PROVIDER_SELECTOR(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GNOME_DB_TYPE_PROVIDER_SELECTOR, GnomeDbProviderSelector))
</MACRO>
<MACRO>
<NAME>GNOME_DB_PROVIDER_SELECTOR_CLASS</NAME>
#define GNOME_DB_PROVIDER_SELECTOR_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GNOME_DB_TYPE_PROVIDER_SELECTOR, GnomeDbProviderSelectorClass))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_PROVIDER_SELECTOR</NAME>
#define GNOME_DB_IS_PROVIDER_SELECTOR(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GNOME_DB_TYPE_PROVIDER_SELECTOR))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_PROVIDER_SELECTOR_CLASS</NAME>
#define GNOME_DB_IS_PROVIDER_SELECTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GNOME_DB_TYPE_PROVIDER_SELECTOR))
</MACRO>
<STRUCT>
<NAME>GnomeDbProviderSelector</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbProviderSelectorClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbProviderSelectorPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbProviderSelector</NAME>
struct GnomeDbProviderSelector {
	GnomeDbCombo                    parent;
	GnomeDbProviderSelectorPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbProviderSelectorClass</NAME>
struct GnomeDbProviderSelectorClass {
	GnomeDbComboClass               parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_provider_selector_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_provider_selector_new</NAME>
<RETURNS>GtkWidget          *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_provider_selector_get_provider_obj</NAME>
<RETURNS>GdaServerProvider  *</RETURNS>
GnomeDbProviderSelector *selector
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_provider_selector_get_provider</NAME>
<RETURNS>const gchar        *</RETURNS>
GnomeDbProviderSelector *selector
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_provider_selector_set_provider</NAME>
<RETURNS>gboolean  </RETURNS>
GnomeDbProviderSelector *selector, const gchar *provider
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_CONNECTION_PROPERTIES</NAME>
#define GNOME_DB_TYPE_CONNECTION_PROPERTIES            (gnome_db_connection_properties_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_CONNECTION_PROPERTIES</NAME>
#define GNOME_DB_CONNECTION_PROPERTIES(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, GNOME_DB_TYPE_CONNECTION_PROPERTIES, GnomeDbConnectionProperties))
</MACRO>
<MACRO>
<NAME>GNOME_DB_CONNECTION_PROPERTIES_CLASS</NAME>
#define GNOME_DB_CONNECTION_PROPERTIES_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, GNOME_DB_TYPE_CONNECTION_PROPERTIES, GnomeDbConnectionPropertiesClass))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_CONNECTION_PROPERTIES</NAME>
#define GNOME_DB_IS_CONNECTION_PROPERTIES(obj)         (G_TYPE_CHECK_INSTANCE_TYPE (obj, GNOME_DB_TYPE_CONNECTION_PROPERTIES))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_CONNECTION_PROPERTIES_CLASS</NAME>
#define GNOME_DB_IS_CONNECTION_PROPERTIES_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GNOME_DB_TYPE_CONNECTION_PROPERTIES))
</MACRO>
<STRUCT>
<NAME>GnomeDbConnectionProperties</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbConnectionPropertiesClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbConnectionPropertiesPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbConnectionProperties</NAME>
struct GnomeDbConnectionProperties {
	GtkVBox vbox;
	GnomeDbConnectionPropertiesPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbConnectionPropertiesClass</NAME>
struct GnomeDbConnectionPropertiesClass {
	GtkVBoxClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_connection_properties_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_connection_properties_new</NAME>
<RETURNS>GtkWidget      *</RETURNS>
GdaConnection *cnc
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_connection_properties_get_connection</NAME>
<RETURNS>GdaConnection  *</RETURNS>
GnomeDbConnectionProperties *props
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_connection_properties_set_connection</NAME>
<RETURNS>void  </RETURNS>
GnomeDbConnectionProperties *props,GdaConnection *cnc
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_DATA_WIDGET_INFO</NAME>
#define GNOME_DB_TYPE_DATA_WIDGET_INFO          (gnome_db_data_widget_info_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_DATA_WIDGET_INFO</NAME>
#define GNOME_DB_DATA_WIDGET_INFO(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gnome_db_data_widget_info_get_type(), GnomeDbDataWidgetInfo)
</MACRO>
<MACRO>
<NAME>GNOME_DB_DATA_WIDGET_INFO_CLASS</NAME>
#define GNOME_DB_DATA_WIDGET_INFO_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gnome_db_data_widget_info_get_type (), GnomeDbDataWidgetInfoClass)
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_DATA_WIDGET_INFO</NAME>
#define GNOME_DB_IS_DATA_WIDGET_INFO(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gnome_db_data_widget_info_get_type ())
</MACRO>
<STRUCT>
<NAME>GnomeDbDataWidgetInfo</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbDataWidgetInfoClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbDataWidgetInfoPriv</NAME>
</STRUCT>
<ENUM>
<NAME>GnomeDbDataWidgetInfoFlag</NAME>
typedef enum 
{
	GNOME_DB_DATA_WIDGET_INFO_NONE = 0,
	GNOME_DB_DATA_WIDGET_INFO_CURRENT_ROW    = 1 << 0,
	GNOME_DB_DATA_WIDGET_INFO_ROW_MODIFY_BUTTONS = 1 << 2,
	GNOME_DB_DATA_WIDGET_INFO_ROW_MOVE_BUTTONS = 1 << 3,
	GNOME_DB_DATA_WIDGET_INFO_CHUNCK_CHANGE_BUTTONS = 1 << 4,
	GNOME_DB_DATA_WIDGET_INFO_NO_FILTER = 1 << 5
} GnomeDbDataWidgetInfoFlag;
</ENUM>
<STRUCT>
<NAME>GnomeDbDataWidgetInfo</NAME>
struct GnomeDbDataWidgetInfo
{
	GtkHBox                    object;

	GnomeDbDataWidgetInfoPriv *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbDataWidgetInfoClass</NAME>
struct GnomeDbDataWidgetInfoClass
{
	GtkHBoxClass               parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_data_widget_info_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_data_widget_info_new</NAME>
<RETURNS>GtkWidget         *</RETURNS>
GnomeDbDataWidget *data_widget, GnomeDbDataWidgetInfoFlag flags
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_RAW_GRID</NAME>
#define GNOME_DB_TYPE_RAW_GRID          (gnome_db_raw_grid_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_RAW_GRID</NAME>
#define GNOME_DB_RAW_GRID(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gnome_db_raw_grid_get_type(), GnomeDbRawGrid)
</MACRO>
<MACRO>
<NAME>GNOME_DB_RAW_GRID_CLASS</NAME>
#define GNOME_DB_RAW_GRID_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gnome_db_raw_grid_get_type (), GnomeDbRawGridClass)
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_RAW_GRID</NAME>
#define GNOME_DB_IS_RAW_GRID(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gnome_db_raw_grid_get_type ())
</MACRO>
<STRUCT>
<NAME>GnomeDbRawGrid</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbRawGridClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbRawGridPriv</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbRawGrid</NAME>
struct GnomeDbRawGrid
{
	GtkTreeView             object;

	GnomeDbRawGridPriv     *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbRawGridClass</NAME>
struct GnomeDbRawGridClass
{
	GtkTreeViewClass        parent_class;

	void             (* selection_changed) (GnomeDbRawGrid *grid, gboolean row_selected);
	void             (* double_clicked)    (GnomeDbRawGrid *grid, gint row);
        void             (* populate_popup)    (GnomeDbRawGrid *grid, GtkMenu *menu);
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_raw_grid_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_raw_grid_new</NAME>
<RETURNS>GtkWidget         *</RETURNS>
GdaDataModel *model
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_raw_grid_set_sample_size</NAME>
<RETURNS>void  </RETURNS>
GnomeDbRawGrid *grid, gint sample_size
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_raw_grid_set_sample_start</NAME>
<RETURNS>void  </RETURNS>
GnomeDbRawGrid *grid, gint sample_start
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_raw_grid_get_selection</NAME>
<RETURNS>GList             *</RETURNS>
GnomeDbRawGrid *grid
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_FORM</NAME>
#define GNOME_DB_TYPE_FORM          (gnome_db_form_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_FORM</NAME>
#define GNOME_DB_FORM(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gnome_db_form_get_type(), GnomeDbForm)
</MACRO>
<MACRO>
<NAME>GNOME_DB_FORM_CLASS</NAME>
#define GNOME_DB_FORM_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gnome_db_form_get_type (), GnomeDbFormClass)
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_FORM</NAME>
#define GNOME_DB_IS_FORM(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gnome_db_form_get_type ())
</MACRO>
<STRUCT>
<NAME>GnomeDbForm</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbFormClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbFormPriv</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbForm</NAME>
struct GnomeDbForm
{
	GtkVBox             object;

	GnomeDbFormPriv     *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbFormClass</NAME>
struct GnomeDbFormClass
{
	GtkVBoxClass       parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_form_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_form_new</NAME>
<RETURNS>GtkWidget         *</RETURNS>
GdaDataModel *model
</FUNCTION>
<STRUCT>
<NAME>GnomeDbDataStore</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbDataStoreClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbDataStorePriv</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbDataEntry</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbDataEntryIface</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbDataWidget</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbDataWidgetIface</NAME>
</STRUCT>
<MACRO>
<NAME>GNOME_DB_COLOR_NORMAL_NULL</NAME>
#define GNOME_DB_COLOR_NORMAL_NULL "#00cd66"
</MACRO>
<MACRO>
<NAME>GNOME_DB_COLOR_PRELIGHT_NULL</NAME>
#define GNOME_DB_COLOR_PRELIGHT_NULL "#00ef77"
</MACRO>
<MACRO>
<NAME>GNOME_DB_COLOR_NORMAL_DEFAULT</NAME>
#define GNOME_DB_COLOR_NORMAL_DEFAULT "#6495ed"
</MACRO>
<MACRO>
<NAME>GNOME_DB_COLOR_PRELIGHT_DEFAULT</NAME>
#define GNOME_DB_COLOR_PRELIGHT_DEFAULT "#75a6fe"
</MACRO>
<MACRO>
<NAME>GNOME_DB_COLOR_NORMAL_MODIF</NAME>
#define GNOME_DB_COLOR_NORMAL_MODIF "#cacaee"
</MACRO>
<MACRO>
<NAME>GNOME_DB_COLOR_PRELIGHT_MODIF</NAME>
#define GNOME_DB_COLOR_PRELIGHT_MODIF "#cfcffe"
</MACRO>
<MACRO>
<NAME>GNOME_DB_COLOR_NORMAL_INVALID</NAME>
#define GNOME_DB_COLOR_NORMAL_INVALID "#ff6a6a"
</MACRO>
<MACRO>
<NAME>GNOME_DB_COLOR_PRELIGHT_INVALID</NAME>
#define GNOME_DB_COLOR_PRELIGHT_INVALID "#ff7b7b"
</MACRO>
<MACRO>
<NAME>GNOME_DB_REFERER_ACTIVE</NAME>
#define GNOME_DB_REFERER_ACTIVE   "#e0ffe0"
</MACRO>
<MACRO>
<NAME>GNOME_DB_REFERER_INACTIVE</NAME>
#define GNOME_DB_REFERER_INACTIVE "#ffe0e0"
</MACRO>
<MACRO>
<NAME>GNOME_DB_REFERER_UNKNOWN</NAME>
#define GNOME_DB_REFERER_UNKNOWN  "#e0e0ff"
</MACRO>
<FUNCTION>
<NAME>gnome_db_new_button_widget</NAME>
<RETURNS>GtkWidget    *</RETURNS>
const gchar *label
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_new_button_widget_from_stock</NAME>
<RETURNS>GtkWidget    *</RETURNS>
const gchar *stock_id
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_new_entry_widget</NAME>
<RETURNS>GtkWidget    *</RETURNS>
gint max_length, gboolean editable
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_new_hbox_widget</NAME>
<RETURNS>GtkWidget    *</RETURNS>
gboolean homogenous, gint spacing
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_new_label_widget</NAME>
<RETURNS>GtkWidget    *</RETURNS>
const gchar *text
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_new_notebook_widget</NAME>
<RETURNS>GtkWidget    *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_new_scrolled_window_widget</NAME>
<RETURNS>GtkWidget    *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_new_table_widget</NAME>
<RETURNS>GtkWidget    *</RETURNS>
gint rows, gint cols, gboolean homogenous
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_new_text_widget</NAME>
<RETURNS>GtkWidget    *</RETURNS>
const gchar *contents
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_new_tree_view_widget</NAME>
<RETURNS>GtkWidget    *</RETURNS>
GtkTreeModel *model
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_new_vbox_widget</NAME>
<RETURNS>GtkWidget    *</RETURNS>
gboolean homogenous, gint spacing
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_option_menu_add_item</NAME>
<RETURNS>GtkWidget    *</RETURNS>
GtkOptionMenu *option_menu, const gchar *label
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_option_menu_add_stock_item</NAME>
<RETURNS>GtkWidget    *</RETURNS>
GtkOptionMenu *option_menu, const gchar *stock_id
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_option_menu_add_separator</NAME>
<RETURNS>void  </RETURNS>
GtkOptionMenu *option_menu
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_option_menu_get_selection</NAME>
<RETURNS>const gchar  *</RETURNS>
GtkOptionMenu *option_menu
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_option_menu_set_selection</NAME>
<RETURNS>void  </RETURNS>
GtkOptionMenu *option_menu,const gchar *selection
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_text_clear</NAME>
<RETURNS>void  </RETURNS>
GtkTextView *text
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_text_copy_clipboard</NAME>
<RETURNS>void  </RETURNS>
GtkTextView *text
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_text_cut_clipboard</NAME>
<RETURNS>void  </RETURNS>
GtkTextView *text
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_text_get_char_count</NAME>
<RETURNS>gint  </RETURNS>
GtkTextView *text
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_text_get_line_count</NAME>
<RETURNS>gint  </RETURNS>
GtkTextView *text
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_text_get_text</NAME>
<RETURNS>gchar        *</RETURNS>
GtkTextView *text
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_text_insert_at_cursor</NAME>
<RETURNS>void  </RETURNS>
GtkTextView *text, const gchar *contents, gint len
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_text_paste_clipboard</NAME>
<RETURNS>void  </RETURNS>
GtkTextView *text
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_text_set_text</NAME>
<RETURNS>void  </RETURNS>
GtkTextView *text, const gchar *contents, gint len
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_select_file_dialog</NAME>
<RETURNS>gchar        *</RETURNS>
GtkWidget *parent, const gchar *title
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_new_alert</NAME>
<RETURNS>GtkWidget    *</RETURNS>
GtkWindow *parent,GtkMessageType type,const gchar *primary_text,const gchar *secondary_text
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_show_error</NAME>
<RETURNS>void  </RETURNS>
GtkWindow *parent, const gchar *format, ...
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_push_cursor_busy</NAME>
<RETURNS>void  </RETURNS>
GtkWidget *window
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_pop_cursor_busy</NAME>
<RETURNS>void  </RETURNS>
GtkWidget *window
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_new_menu_item</NAME>
<RETURNS>GtkWidget    *</RETURNS>
const gchar *label,gboolean pixmap,GCallback cb_func,gpointer user_data
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_new_check_menu_item</NAME>
<RETURNS>GtkWidget    *</RETURNS>
const gchar *label,gboolean active,GCallback cb_func,gpointer user_data
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_DATA_CELL_RENDERER_PASSWORD</NAME>
#define GNOME_DB_TYPE_DATA_CELL_RENDERER_PASSWORD		(gnome_db_data_cell_renderer_password_get_type ())
</MACRO>
<MACRO>
<NAME>GNOME_DB_DATA_CELL_RENDERER_PASSWORD</NAME>
#define GNOME_DB_DATA_CELL_RENDERER_PASSWORD(obj)		(G_TYPE_CHECK_INSTANCE_CAST ((obj), GNOME_DB_TYPE_DATA_CELL_RENDERER_PASSWORD, GnomeDbDataCellRendererPassword))
</MACRO>
<MACRO>
<NAME>GNOME_DB_DATA_CELL_RENDERER_PASSWORD_CLASS</NAME>
#define GNOME_DB_DATA_CELL_RENDERER_PASSWORD_CLASS(klass)	(G_TYPE_CHECK_CLASS_CAST ((klass), GNOME_DB_TYPE_DATA_CELL_RENDERER_PASSWORD, GnomeDbDataCellRendererPasswordClass))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_DATA_CELL_RENDERER_PASSWORD</NAME>
#define GNOME_DB_IS_DATA_CELL_RENDERER_PASSWORD(obj)		(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GNOME_DB_TYPE_DATA_CELL_RENDERER_PASSWORD))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_DATA_CELL_RENDERER_PASSWORD_CLASS</NAME>
#define GNOME_DB_IS_DATA_CELL_RENDERER_PASSWORD_CLASS(klass)	(G_TYPE_CHECK_CLASS_TYPE ((klass), GNOME_DB_TYPE_DATA_CELL_RENDERER_PASSWORD))
</MACRO>
<MACRO>
<NAME>GNOME_DB_DATA_CELL_RENDERER_PASSWORD_GET_CLASS</NAME>
#define GNOME_DB_DATA_CELL_RENDERER_PASSWORD_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GNOME_DB_TYPE_DATA_CELL_RENDERER_PASSWORD, GnomeDbDataCellRendererPasswordClass))
</MACRO>
<STRUCT>
<NAME>GnomeDbDataCellRendererPassword</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbDataCellRendererPasswordClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbDataCellRendererPasswordPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbDataCellRendererPassword</NAME>
struct GnomeDbDataCellRendererPassword
{
	GtkCellRendererText                     parent;
	
	GnomeDbDataCellRendererPasswordPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbDataCellRendererPasswordClass</NAME>
struct GnomeDbDataCellRendererPasswordClass
{
	GtkCellRendererTextClass                parent_class;
	
	void (* changed) (GnomeDbDataCellRendererPassword *cell_renderer,
			  const gchar                     *path,
			  const GValue                    *new_value);
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_data_cell_renderer_password_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_data_cell_renderer_password_new</NAME>
<RETURNS>GtkCellRenderer  *</RETURNS>
GdaDataHandler *dh, GType type, const gchar *options
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_ENTRY_PASSWORD_TYPE</NAME>
#define GNOME_DB_ENTRY_PASSWORD_TYPE          (gnome_db_entry_password_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_ENTRY_PASSWORD</NAME>
#define GNOME_DB_ENTRY_PASSWORD(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gnome_db_entry_password_get_type(), GnomeDbEntryPassword)
</MACRO>
<MACRO>
<NAME>GNOME_DB_ENTRY_PASSWORD_CLASS</NAME>
#define GNOME_DB_ENTRY_PASSWORD_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gnome_db_entry_password_get_type (), GnomeDbEntryPasswordClass)
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_ENTRY_PASSWORD</NAME>
#define GNOME_DB_IS_ENTRY_PASSWORD(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gnome_db_entry_password_get_type ())
</MACRO>
<STRUCT>
<NAME>GnomeDbEntryPassword</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryPasswordClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryPasswordPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryPassword</NAME>
struct GnomeDbEntryPassword
{
	GnomeDbEntryWrapper              object;
	GnomeDbEntryPasswordPrivate         *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryPasswordClass</NAME>
struct GnomeDbEntryPasswordClass
{
	GnomeDbEntryWrapperClass         parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_entry_password_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_entry_password_new</NAME>
<RETURNS>GtkWidget    *</RETURNS>
GdaDataHandler *dh, GType type, const gchar *options
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_ENTRY_CIDR</NAME>
#define GNOME_DB_TYPE_ENTRY_CIDR          (gnome_db_entry_cidr_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_ENTRY_CIDR</NAME>
#define GNOME_DB_ENTRY_CIDR(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gnome_db_entry_cidr_get_type(), GnomeDbEntryCidr)
</MACRO>
<MACRO>
<NAME>GNOME_DB_ENTRY_CIDR_CLASS</NAME>
#define GNOME_DB_ENTRY_CIDR_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gnome_db_entry_cidr_get_type (), GnomeDbEntryCidrClass)
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_ENTRY_CIDR</NAME>
#define GNOME_DB_IS_ENTRY_CIDR(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gnome_db_entry_cidr_get_type ())
</MACRO>
<STRUCT>
<NAME>GnomeDbEntryCidr</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryCidrClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryCidrPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryCidr</NAME>
struct GnomeDbEntryCidr
{
	GnomeDbEntryWrapper              object;
	GnomeDbEntryCidrPrivate         *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryCidrClass</NAME>
struct GnomeDbEntryCidrClass
{
	GnomeDbEntryWrapperClass         parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_entry_cidr_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_entry_cidr_new</NAME>
<RETURNS>GtkWidget    *</RETURNS>
GdaDataHandler *dh, GType type
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_ENTRY_PICT</NAME>
#define GNOME_DB_TYPE_ENTRY_PICT          (gnome_db_entry_pict_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_ENTRY_PICT</NAME>
#define GNOME_DB_ENTRY_PICT(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gnome_db_entry_pict_get_type(), GnomeDbEntryPict)
</MACRO>
<MACRO>
<NAME>GNOME_DB_ENTRY_PICT_CLASS</NAME>
#define GNOME_DB_ENTRY_PICT_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gnome_db_entry_pict_get_type (), GnomeDbEntryPictClass)
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_ENTRY_PICT</NAME>
#define GNOME_DB_IS_ENTRY_PICT(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gnome_db_entry_pict_get_type ())
</MACRO>
<STRUCT>
<NAME>GnomeDbEntryPict</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryPictClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryPictPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryPict</NAME>
struct GnomeDbEntryPict
{
	GnomeDbEntryWrapper              object;
	GnomeDbEntryPictPrivate         *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryPictClass</NAME>
struct GnomeDbEntryPictClass
{
	GnomeDbEntryWrapperClass         parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_entry_pict_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_entry_pict_new</NAME>
<RETURNS>GtkWidget    *</RETURNS>
GdaDataHandler *dh, GType type, const gchar *options
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_ENTRY_TEXT</NAME>
#define GNOME_DB_TYPE_ENTRY_TEXT          (gnome_db_entry_text_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_ENTRY_TEXT</NAME>
#define GNOME_DB_ENTRY_TEXT(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gnome_db_entry_text_get_type(), GnomeDbEntryText)
</MACRO>
<MACRO>
<NAME>GNOME_DB_ENTRY_TEXT_CLASS</NAME>
#define GNOME_DB_ENTRY_TEXT_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gnome_db_entry_text_get_type (), GnomeDbEntryTextClass)
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_ENTRY_TEXT</NAME>
#define GNOME_DB_IS_ENTRY_TEXT(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gnome_db_entry_text_get_type ())
</MACRO>
<STRUCT>
<NAME>GnomeDbEntryText</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryTextClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryTextPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryText</NAME>
struct GnomeDbEntryText
{
	GnomeDbEntryWrapper              object;
	GnomeDbEntryTextPrivate         *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryTextClass</NAME>
struct GnomeDbEntryTextClass
{
	GnomeDbEntryWrapperClass         parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_entry_text_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_entry_text_new</NAME>
<RETURNS>GtkWidget    *</RETURNS>
GdaDataHandler *dh, GType type
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_DATA_CELL_RENDERER_CGRID</NAME>
#define GNOME_DB_TYPE_DATA_CELL_RENDERER_CGRID            (gnome_db_data_cell_renderer_cgrid_get_type ())
</MACRO>
<MACRO>
<NAME>GNOME_DB_DATA_CELL_RENDERER_CGRID</NAME>
#define GNOME_DB_DATA_CELL_RENDERER_CGRID(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GNOME_DB_TYPE_DATA_CELL_RENDERER_CGRID, GnomeDbDataCellRendererCGrid))
</MACRO>
<MACRO>
<NAME>GNOME_DB_DATA_CELL_RENDERER_CGRID_CLASS</NAME>
#define GNOME_DB_DATA_CELL_RENDERER_CGRID_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GNOME_DB_TYPE_DATA_CELL_RENDERER_CGRID, GnomeDbDataCellRendererCGridClass))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_DATA_CELL_RENDERER_CGRID</NAME>
#define GNOME_DB_IS_DATA_CELL_RENDERER_CGRID(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GNOME_DB_TYPE_DATA_CELL_RENDERER_CGRID))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_DATA_CELL_RENDERER_CGRID_CLASS</NAME>
#define GNOME_DB_IS_DATA_CELL_RENDERER_CGRID_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GNOME_DB_TYPE_DATA_CELL_RENDERER_CGRID))
</MACRO>
<MACRO>
<NAME>GNOME_DB_DATA_CELL_RENDERER_CGRID_GET_CLASS</NAME>
#define GNOME_DB_DATA_CELL_RENDERER_CGRID_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GNOME_DB_TYPE_DATA_CELL_RENDERER_CGRID, GnomeDbDataCellRendererCGridClass))
</MACRO>
<STRUCT>
<NAME>GnomeDbDataCellRendererCGrid</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbDataCellRendererCGridClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbDataCellRendererCGridPrivate</NAME>
</STRUCT>
<USER_FUNCTION>
<NAME>GnomeDbDataCellRendererCGridCgridChangedFunc</NAME>
<RETURNS>void </RETURNS>
GnomeDbDataCellRendererCGrid  *cgrid,
							       const GValue                  *gvalue
</USER_FUNCTION>
<STRUCT>
<NAME>GnomeDbDataCellRendererCGrid</NAME>
struct GnomeDbDataCellRendererCGrid
{
	GtkCellRendererText                  parent;
	GnomeDbDataCellRendererCGridPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbDataCellRendererCGridClass</NAME>
struct GnomeDbDataCellRendererCGridClass
{
	GtkCellRendererTextClass  parent;
	void                     (* changed) (GnomeDbDataCellRendererCGrid  *cgrid,
					      const GValue                  *gvalue);
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_data_cell_renderer_cgrid_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_data_cell_renderer_cgrid_new</NAME>
<RETURNS>GnomeDbDataCellRendererCGrid  *</RETURNS>
GdaDataHandler *data_handler,GType gtype, const gchar *options
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_data_cell_renderer_cgrid_get_data_handler</NAME>
<RETURNS>GdaDataHandler                *</RETURNS>
GnomeDbDataCellRendererCGrid *cgrid
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_data_cell_renderer_cgrid_set_data_handler</NAME>
<RETURNS>void  </RETURNS>
GnomeDbDataCellRendererCGrid *cgrid,GdaDataHandler *data_handler
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_data_cell_renderer_cgrid_get_gtype</NAME>
<RETURNS>GType  </RETURNS>
GnomeDbDataCellRendererCGrid *cgrid
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_data_cell_renderer_cgrid_set_gtype</NAME>
<RETURNS>void  </RETURNS>
GnomeDbDataCellRendererCGrid  *cgrid,GType gtype
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_data_cell_renderer_cgrid_get_editable</NAME>
<RETURNS>gboolean  </RETURNS>
GnomeDbDataCellRendererCGrid *cgrid
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_data_cell_renderer_cgrid_set_editable</NAME>
<RETURNS>void  </RETURNS>
GnomeDbDataCellRendererCGrid  *cgrid,gboolean editable
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_data_cell_renderer_cgrid_get_to_be_deleted</NAME>
<RETURNS>gboolean  </RETURNS>
GnomeDbDataCellRendererCGrid *cgrid
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_data_cell_renderer_cgrid_set_to_be_deleted</NAME>
<RETURNS>void  </RETURNS>
GnomeDbDataCellRendererCGrid  *cgrid,gboolean to_be_deleted
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_ENTRY_CGRID</NAME>
#define GNOME_DB_TYPE_ENTRY_CGRID            (gnome_db_entry_cgrid_get_type ())
</MACRO>
<MACRO>
<NAME>GNOME_DB_ENTRY_CGRID</NAME>
#define GNOME_DB_ENTRY_CGRID(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GNOME_DB_TYPE_ENTRY_CGRID, GnomeDbEntryCGrid))
</MACRO>
<MACRO>
<NAME>GNOME_DB_ENTRY_CGRID_CLASS</NAME>
#define GNOME_DB_ENTRY_CGRID_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GNOME_DB_TYPE_ENTRY_CGRID, GnomeDbEntryCGridClass))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_ENTRY_CGRID</NAME>
#define GNOME_DB_IS_ENTRY_CGRID(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GNOME_DB_TYPE_ENTRY_CGRID))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_ENTRY_CGRID_CLASS</NAME>
#define GNOME_DB_IS_ENTRY_CGRID_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GNOME_DB_TYPE_ENTRY_CGRID))
</MACRO>
<MACRO>
<NAME>GNOME_DB_ENTRY_CGRID_GET_CLASS</NAME>
#define GNOME_DB_ENTRY_CGRID_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GNOME_DB_TYPE_ENTRY_CGRID, GnomeDbEntryCGridClass))
</MACRO>
<STRUCT>
<NAME>GnomeDbEntryCGrid</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryCGridClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryCGridPrivate</NAME>
</STRUCT>
<USER_FUNCTION>
<NAME>GnomeDbEntryCGridCgridChangedFunc</NAME>
<RETURNS>void </RETURNS>
GnomeDbEntryCGrid  *cgrid
</USER_FUNCTION>
<STRUCT>
<NAME>GnomeDbEntryCGrid</NAME>
struct GnomeDbEntryCGrid
{
	GnomeDbEntryWrapper       parent;
	GnomeDbEntryCGridPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryCGridClass</NAME>
struct GnomeDbEntryCGridClass
{
	GnomeDbEntryWrapperClass   parent;
	void                      (* cgrid_changed) (GnomeDbEntryCGrid  *cgrid);
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_entry_cgrid_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_entry_cgrid_new</NAME>
<RETURNS>GnomeDbEntryCGrid   *</RETURNS>
GdaDataHandler *data_handler, GType gtype,const gchar *options
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_entry_cgrid_get_text_column</NAME>
<RETURNS>gint  </RETURNS>
GnomeDbEntryCGrid *cgrid
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_entry_cgrid_set_text_column</NAME>
<RETURNS>void  </RETURNS>
GnomeDbEntryCGrid *cgrid, gint text_column
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_entry_cgrid_get_grid_height</NAME>
<RETURNS>gint  </RETURNS>
GnomeDbEntryCGrid *cgrid
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_entry_cgrid_set_grid_height</NAME>
<RETURNS>void  </RETURNS>
GnomeDbEntryCGrid *cgrid, gint grid_height
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_entry_cgrid_get_headers_visible</NAME>
<RETURNS>gboolean  </RETURNS>
GnomeDbEntryCGrid *cgrid
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_entry_cgrid_set_headers_visible</NAME>
<RETURNS>void  </RETURNS>
GnomeDbEntryCGrid *cgrid, gboolean headers_visible
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_entry_cgrid_get_model</NAME>
<RETURNS>GdaDataModel        *</RETURNS>
GnomeDbEntryCGrid *cgrid
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_entry_cgrid_set_model</NAME>
<RETURNS>void  </RETURNS>
GnomeDbEntryCGrid *cgrid, GdaDataModel *model
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_entry_cgrid_append_column</NAME>
<RETURNS>void  </RETURNS>
GnomeDbEntryCGrid *cgrid, GtkTreeViewColumn *column
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_entry_cgrid_get_active_iter</NAME>
<RETURNS>gboolean  </RETURNS>
GnomeDbEntryCGrid *cgrid, GtkTreeIter *iter
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_ENTRY_FILESEL</NAME>
#define GNOME_DB_TYPE_ENTRY_FILESEL          (gnome_db_entry_filesel_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_ENTRY_FILESEL</NAME>
#define GNOME_DB_ENTRY_FILESEL(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gnome_db_entry_filesel_get_type(), GnomeDbEntryFilesel)
</MACRO>
<MACRO>
<NAME>GNOME_DB_ENTRY_FILESEL_CLASS</NAME>
#define GNOME_DB_ENTRY_FILESEL_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gnome_db_entry_filesel_get_type (), GnomeDbEntryFileselClass)
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_ENTRY_FILESEL</NAME>
#define GNOME_DB_IS_ENTRY_FILESEL(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gnome_db_entry_filesel_get_type ())
</MACRO>
<STRUCT>
<NAME>GnomeDbEntryFilesel</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryFileselClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryFileselPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryFilesel</NAME>
struct GnomeDbEntryFilesel
{
	GnomeDbEntryWrapper              object;
	GnomeDbEntryFileselPrivate      *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryFileselClass</NAME>
struct GnomeDbEntryFileselClass
{
	GnomeDbEntryWrapperClass         parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_entry_filesel_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_entry_filesel_new</NAME>
<RETURNS>GtkWidget    *</RETURNS>
GdaDataHandler *dh, GType type, const gchar *options
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_DATA_CELL_RENDERER_PICT</NAME>
#define GNOME_DB_TYPE_DATA_CELL_RENDERER_PICT		(gnome_db_data_cell_renderer_pict_get_type ())
</MACRO>
<MACRO>
<NAME>GNOME_DB_DATA_CELL_RENDERER_PICT</NAME>
#define GNOME_DB_DATA_CELL_RENDERER_PICT(obj)		(G_TYPE_CHECK_INSTANCE_CAST ((obj), GNOME_DB_TYPE_DATA_CELL_RENDERER_PICT, GnomeDbDataCellRendererPict))
</MACRO>
<MACRO>
<NAME>GNOME_DB_DATA_CELL_RENDERER_PICT_CLASS</NAME>
#define GNOME_DB_DATA_CELL_RENDERER_PICT_CLASS(klass)	(G_TYPE_CHECK_CLASS_CAST ((klass), GNOME_DB_TYPE_DATA_CELL_RENDERER_PICT, GnomeDbDataCellRendererPictClass))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_DATA_CELL_RENDERER_PICT</NAME>
#define GNOME_DB_IS_DATA_CELL_RENDERER_PICT(obj)		(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GNOME_DB_TYPE_DATA_CELL_RENDERER_PICT))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_DATA_CELL_RENDERER_PICT_CLASS</NAME>
#define GNOME_DB_IS_DATA_CELL_RENDERER_PICT_CLASS(klass)	(G_TYPE_CHECK_CLASS_TYPE ((klass), GNOME_DB_TYPE_DATA_CELL_RENDERER_PICT))
</MACRO>
<MACRO>
<NAME>GNOME_DB_DATA_CELL_RENDERER_PICT_GET_CLASS</NAME>
#define GNOME_DB_DATA_CELL_RENDERER_PICT_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GNOME_DB_TYPE_DATA_CELL_RENDERER_PICT, GnomeDbDataCellRendererPictClass))
</MACRO>
<STRUCT>
<NAME>GnomeDbDataCellRendererPict</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbDataCellRendererPictClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbDataCellRendererPictPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbDataCellRendererPict</NAME>
struct GnomeDbDataCellRendererPict
{
	GtkCellRendererPixbuf               parent;
	
	GnomeDbDataCellRendererPictPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbDataCellRendererPictClass</NAME>
struct GnomeDbDataCellRendererPictClass
{
	GtkCellRendererPixbufClass          parent_class;
	
	void (* changed) (GnomeDbDataCellRendererPict *cell_renderer,
			  const gchar                 *path,
			  const GValue                *new_value);
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_data_cell_renderer_pict_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_data_cell_renderer_pict_new</NAME>
<RETURNS>GtkCellRenderer  *</RETURNS>
GdaDataHandler *dh, GType type, const gchar *options
</FUNCTION>
<ENUM>
<NAME>PictEncodeType</NAME>
typedef enum {
        ENCODING_NONE,
        ENCODING_BASE64
} PictEncodeType;
</ENUM>
<STRUCT>
<NAME>PictBinData</NAME>
struct PictBinData
{
	guchar    *data;
        glong      data_length;
};
</STRUCT>
<STRUCT>
<NAME>PictOptions</NAME>
struct PictOptions
{
	PictEncodeType encoding;
        gboolean       serialize; /* TRUE if must use gdk_pixdata_serialize() */
	GHashTable    *pixbuf_hash; /* key = GValue pointer, value = a GdkPixbuf */
};
</STRUCT>
<STRUCT>
<NAME>PictAllocation</NAME>
struct PictAllocation
{
	gint width;
	gint height;
};
</STRUCT>
<USER_FUNCTION>
<NAME>PictCallback</NAME>
<RETURNS>void </RETURNS>
gpointer
</USER_FUNCTION>
<STRUCT>
<NAME>PictMenu</NAME>
struct PictMenu
{
	GtkWidget    *menu; /* popup menu */
	GtkWidget    *load_mitem;
	GtkWidget    *save_mitem;
};
</STRUCT>
<FUNCTION>
<NAME>common_pict_parse_options</NAME>
<RETURNS>void  </RETURNS>
PictOptions *options, const gchar *options_str
</FUNCTION>
<FUNCTION>
<NAME>common_pict_init_cache</NAME>
<RETURNS>void  </RETURNS>
PictOptions *options
</FUNCTION>
<FUNCTION>
<NAME>common_pict_add_cached_pixbuf</NAME>
<RETURNS>void  </RETURNS>
PictOptions *options, const GValue *value, GdkPixbuf *pixbuf
</FUNCTION>
<FUNCTION>
<NAME>common_pict_fetch_cached_pixbuf</NAME>
<RETURNS>GdkPixbuf    *</RETURNS>
PictOptions *options, const GValue *value
</FUNCTION>
<FUNCTION>
<NAME>common_pict_clear_pixbuf_cache</NAME>
<RETURNS>void  </RETURNS>
PictOptions *options
</FUNCTION>
<FUNCTION>
<NAME>common_pict_load_data</NAME>
<RETURNS>gboolean  </RETURNS>
PictOptions *options, const GValue *value, PictBinData *bindata,const gchar **stock, GError **error
</FUNCTION>
<FUNCTION>
<NAME>common_pict_make_pixbuf</NAME>
<RETURNS>GdkPixbuf    *</RETURNS>
PictOptions *options, PictBinData *bindata, PictAllocation *allocation,const gchar **stock, GError **error
</FUNCTION>
<FUNCTION>
<NAME>common_pict_create_menu</NAME>
<RETURNS>void  </RETURNS>
PictMenu *pictmenu, GtkWidget *attach_to, PictBinData *bindata, PictOptions  *options,PictCallback callback, gpointer data
</FUNCTION>
<FUNCTION>
<NAME>common_pict_adjust_menu_sensitiveness</NAME>
<RETURNS>void  </RETURNS>
PictMenu *pictmenu, gboolean editable, PictBinData *bindata
</FUNCTION>
<FUNCTION>
<NAME>common_pict_get_value</NAME>
<RETURNS>GValue       *</RETURNS>
PictBinData *bindata, PictOptions *options, GType gtype
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_ENTRY_COMMON_TIME</NAME>
#define GNOME_DB_TYPE_ENTRY_COMMON_TIME          (gnome_db_entry_common_time_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_ENTRY_COMMON_TIME</NAME>
#define GNOME_DB_ENTRY_COMMON_TIME(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gnome_db_entry_common_time_get_type(), GnomeDbEntryCommonTime)
</MACRO>
<MACRO>
<NAME>GNOME_DB_ENTRY_COMMON_TIME_CLASS</NAME>
#define GNOME_DB_ENTRY_COMMON_TIME_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gnome_db_entry_common_time_get_type (), GnomeDbEntryCommonTimeClass)
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_ENTRY_COMMON_TIME</NAME>
#define GNOME_DB_IS_ENTRY_COMMON_TIME(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gnome_db_entry_common_time_get_type ())
</MACRO>
<STRUCT>
<NAME>GnomeDbEntryCommonTime</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryCommonTimeClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryCommonTimePrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryCommonTime</NAME>
struct GnomeDbEntryCommonTime
{
	GnomeDbEntryWrapper              object;
	GnomeDbEntryCommonTimePrivate   *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryCommonTimeClass</NAME>
struct GnomeDbEntryCommonTimeClass
{
	GnomeDbEntryWrapperClass         parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_entry_common_time_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_DATA_CELL_RENDERER_INFO</NAME>
#define GNOME_DB_TYPE_DATA_CELL_RENDERER_INFO			(gnome_db_data_cell_renderer_info_get_type ())
</MACRO>
<MACRO>
<NAME>GNOME_DB_DATA_CELL_RENDERER_INFO</NAME>
#define GNOME_DB_DATA_CELL_RENDERER_INFO(obj)			(G_TYPE_CHECK_INSTANCE_CAST ((obj), GNOME_DB_TYPE_DATA_CELL_RENDERER_INFO, GnomeDbDataCellRendererInfo))
</MACRO>
<MACRO>
<NAME>GNOME_DB_DATA_CELL_RENDERER_INFO_CLASS</NAME>
#define GNOME_DB_DATA_CELL_RENDERER_INFO_CLASS(klass)		(G_TYPE_CHECK_CLASS_CAST ((klass), GNOME_DB_TYPE_DATA_CELL_RENDERER_INFO, GnomeDbDataCellRendererInfoClass))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_DATA_CELL_RENDERER_INFO</NAME>
#define GNOME_DB_IS_DATA_CELL_RENDERER_INFO(obj)		(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GNOME_DB_TYPE_DATA_CELL_RENDERER_INFO))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_DATA_CELL_RENDERER_INFO_CLASS</NAME>
#define GNOME_DB_IS_DATA_CELL_RENDERER_INFO_CLASS(klass)	(G_TYPE_CHECK_CLASS_TYPE ((klass), GNOME_DB_TYPE_DATA_CELL_RENDERER_INFO))
</MACRO>
<MACRO>
<NAME>GNOME_DB_DATA_CELL_RENDERER_INFO_GET_CLASS</NAME>
#define GNOME_DB_DATA_CELL_RENDERER_INFO_GET_CLASS(obj)         (G_TYPE_INSTANCE_GET_CLASS ((obj), GNOME_DB_TYPE_DATA_CELL_RENDERER_INFO, GnomeDbDataCellRendererInfoClass))
</MACRO>
<STRUCT>
<NAME>GnomeDbDataCellRendererInfo</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbDataCellRendererInfoClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbDataCellRendererInfoPriv</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbDataCellRendererInfo</NAME>
struct GnomeDbDataCellRendererInfo
{
	GtkCellRenderer             parent;

	GnomeDbDataCellRendererInfoPriv *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbDataCellRendererInfoClass</NAME>
struct GnomeDbDataCellRendererInfoClass
{
	GtkCellRendererClass parent_class;
	
	void (* status_changed) (GnomeDbDataCellRendererInfo *cell_renderer_info,
				 const gchar                 *path,
				 GdaValueAttribute            requested_action);
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_data_cell_renderer_info_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_data_cell_renderer_info_new</NAME>
<RETURNS>GtkCellRenderer  *</RETURNS>
GnomeDbDataStore *store,GdaDataModelIter *iter,GdaSetGroup *group
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_DATA_CELL_RENDERER_COMBO</NAME>
#define GNOME_DB_TYPE_DATA_CELL_RENDERER_COMBO		(gnome_db_data_cell_renderer_combo_get_type ())
</MACRO>
<MACRO>
<NAME>GNOME_DB_DATA_CELL_RENDERER_COMBO</NAME>
#define GNOME_DB_DATA_CELL_RENDERER_COMBO(obj)		(G_TYPE_CHECK_INSTANCE_CAST ((obj), GNOME_DB_TYPE_DATA_CELL_RENDERER_COMBO, GnomeDbDataCellRendererCombo))
</MACRO>
<MACRO>
<NAME>GNOME_DB_DATA_CELL_RENDERER_COMBO_CLASS</NAME>
#define GNOME_DB_DATA_CELL_RENDERER_COMBO_CLASS(klass)	(G_TYPE_CHECK_CLASS_CAST ((klass), GNOME_DB_TYPE_DATA_CELL_RENDERER_COMBO, GnomeDbDataCellRendererComboClass))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_DATA_CELL_RENDERER_COMBO</NAME>
#define GNOME_DB_IS_DATA_CELL_RENDERER_COMBO(obj)		(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GNOME_DB_TYPE_DATA_CELL_RENDERER_COMBO))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_DATA_CELL_RENDERER_COMBO_CLASS</NAME>
#define GNOME_DB_IS_DATA_CELL_RENDERER_COMBO_CLASS(klass)	(G_TYPE_CHECK_CLASS_TYPE ((klass), GNOME_DB_TYPE_DATA_CELL_RENDERER_COMBO))
</MACRO>
<MACRO>
<NAME>GNOME_DB_DATA_CELL_RENDERER_COMBO_GET_CLASS</NAME>
#define GNOME_DB_DATA_CELL_RENDERER_COMBO_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), GNOME_DB_TYPE_DATA_CELL_RENDERER_COMBO, GnomeDbDataCellRendererComboClass))
</MACRO>
<STRUCT>
<NAME>GnomeDbDataCellRendererCombo</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbDataCellRendererComboClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbDataCellRendererComboPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbDataCellRendererCombo</NAME>
struct GnomeDbDataCellRendererCombo
{
	GtkCellRendererText            parent;

	GnomeDbDataCellRendererComboPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbDataCellRendererComboClass</NAME>
struct GnomeDbDataCellRendererComboClass
{
	GtkCellRendererTextClass parent_class;
	
	void (* changed) (GnomeDbDataCellRendererCombo *cell_renderer_combo,
			  const gchar *path,
			  GSList *new_values, GSList *all_new_values);
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_data_cell_renderer_combo_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_data_cell_renderer_combo_new</NAME>
<RETURNS>GtkCellRenderer  *</RETURNS>
GdaSet *paramlist, GdaSetSource *source
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_ENTRY_DATE</NAME>
#define GNOME_DB_TYPE_ENTRY_DATE          (gnome_db_entry_date_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_ENTRY_DATE</NAME>
#define GNOME_DB_ENTRY_DATE(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gnome_db_entry_date_get_type(), GnomeDbEntryDate)
</MACRO>
<MACRO>
<NAME>GNOME_DB_ENTRY_DATE_CLASS</NAME>
#define GNOME_DB_ENTRY_DATE_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gnome_db_entry_date_get_type (), GnomeDbEntryDateClass)
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_ENTRY_DATE</NAME>
#define GNOME_DB_IS_ENTRY_DATE(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gnome_db_entry_date_get_type ())
</MACRO>
<STRUCT>
<NAME>GnomeDbEntryDate</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryDateClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryDatePrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryDate</NAME>
struct GnomeDbEntryDate
{
	GnomeDbEntryCommonTime           object;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryDateClass</NAME>
struct GnomeDbEntryDateClass
{
	GnomeDbEntryCommonTimeClass      parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_entry_date_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_entry_date_new</NAME>
<RETURNS>GtkWidget    *</RETURNS>
GdaDataHandler *dh
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_ENTRY_NONE</NAME>
#define GNOME_DB_TYPE_ENTRY_NONE          (gnome_db_entry_none_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_ENTRY_NONE</NAME>
#define GNOME_DB_ENTRY_NONE(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gnome_db_entry_none_get_type(), GnomeDbEntryNone)
</MACRO>
<MACRO>
<NAME>GNOME_DB_ENTRY_NONE_CLASS</NAME>
#define GNOME_DB_ENTRY_NONE_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gnome_db_entry_none_get_type (), GnomeDbEntryNoneClass)
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_ENTRY_NONE</NAME>
#define GNOME_DB_IS_ENTRY_NONE(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gnome_db_entry_none_get_type ())
</MACRO>
<STRUCT>
<NAME>GnomeDbEntryNone</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryNoneClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryNonePrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryNone</NAME>
struct GnomeDbEntryNone
{
	GnomeDbEntryWrapper            object;
	GnomeDbEntryNonePrivate       *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryNoneClass</NAME>
struct GnomeDbEntryNoneClass
{
	GnomeDbEntryWrapperClass       parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_entry_none_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_entry_none_new</NAME>
<RETURNS>GtkWidget    *</RETURNS>
GType type
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_ENTRY_TIMESTAMP</NAME>
#define GNOME_DB_TYPE_ENTRY_TIMESTAMP          (gnome_db_entry_timestamp_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_ENTRY_TIMESTAMP</NAME>
#define GNOME_DB_ENTRY_TIMESTAMP(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gnome_db_entry_timestamp_get_type(), GnomeDbEntryTimestamp)
</MACRO>
<MACRO>
<NAME>GNOME_DB_ENTRY_TIMESTAMP_CLASS</NAME>
#define GNOME_DB_ENTRY_TIMESTAMP_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gnome_db_entry_timestamp_get_type (), GnomeDbEntryTimestampClass)
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_ENTRY_TIMESTAMP</NAME>
#define GNOME_DB_IS_ENTRY_TIMESTAMP(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gnome_db_entry_timestamp_get_type ())
</MACRO>
<STRUCT>
<NAME>GnomeDbEntryTimestamp</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryTimestampClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryTimestampPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryTimestamp</NAME>
struct GnomeDbEntryTimestamp
{
	GnomeDbEntryCommonTime           object;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryTimestampClass</NAME>
struct GnomeDbEntryTimestampClass
{
	GnomeDbEntryCommonTimeClass      parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_entry_timestamp_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_entry_timestamp_new</NAME>
<RETURNS>GtkWidget    *</RETURNS>
GdaDataHandler *dh
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_DATA_CELL_RENDERER_BOOLEAN</NAME>
#define GNOME_DB_TYPE_DATA_CELL_RENDERER_BOOLEAN		(gnome_db_data_cell_renderer_boolean_get_type ())
</MACRO>
<MACRO>
<NAME>GNOME_DB_DATA_CELL_RENDERER_BOOLEAN</NAME>
#define GNOME_DB_DATA_CELL_RENDERER_BOOLEAN(obj)		(G_TYPE_CHECK_INSTANCE_CAST ((obj), GNOME_DB_TYPE_DATA_CELL_RENDERER_BOOLEAN, GnomeDbDataCellRendererBoolean))
</MACRO>
<MACRO>
<NAME>GNOME_DB_DATA_CELL_RENDERER_BOOLEAN_CLASS</NAME>
#define GNOME_DB_DATA_CELL_RENDERER_BOOLEAN_CLASS(klass)	(G_TYPE_CHECK_CLASS_CAST ((klass), GNOME_DB_TYPE_DATA_CELL_RENDERER_BOOLEAN, GnomeDbDataCellRendererBooleanClass))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_DATA_CELL_RENDERER_BOOLEAN</NAME>
#define GNOME_DB_IS_DATA_CELL_RENDERER_BOOLEAN(obj)		(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GNOME_DB_TYPE_DATA_CELL_RENDERER_BOOLEAN))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_DATA_CELL_RENDERER_BOOLEAN_CLASS</NAME>
#define GNOME_DB_IS_DATA_CELL_RENDERER_BOOLEAN_CLASS(klass)	(G_TYPE_CHECK_CLASS_TYPE ((klass), GNOME_DB_TYPE_DATA_CELL_RENDERER_BOOLEAN))
</MACRO>
<MACRO>
<NAME>GNOME_DB_DATA_CELL_RENDERER_BOOLEAN_GET_CLASS</NAME>
#define GNOME_DB_DATA_CELL_RENDERER_BOOLEAN_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GNOME_DB_TYPE_DATA_CELL_RENDERER_BOOLEAN, GnomeDbDataCellRendererBooleanClass))
</MACRO>
<STRUCT>
<NAME>GnomeDbDataCellRendererBoolean</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbDataCellRendererBooleanClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbDataCellRendererBooleanPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbDataCellRendererBoolean</NAME>
struct GnomeDbDataCellRendererBoolean
{
	GtkCellRendererToggle             parent;
	
	GnomeDbDataCellRendererBooleanPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbDataCellRendererBooleanClass</NAME>
struct GnomeDbDataCellRendererBooleanClass
{
	GtkCellRendererToggleClass  parent_class;
	
	void (* changed) (GnomeDbDataCellRendererBoolean *cell_renderer,
			  const gchar               *path,
			  const GValue            *new_value);
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_data_cell_renderer_boolean_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_data_cell_renderer_boolean_new</NAME>
<RETURNS>GtkCellRenderer  *</RETURNS>
GdaDataHandler *dh, GType type
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_ENTRY_COMBO</NAME>
#define GNOME_DB_TYPE_ENTRY_COMBO          (gnome_db_entry_combo_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_ENTRY_COMBO</NAME>
#define GNOME_DB_ENTRY_COMBO(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gnome_db_entry_combo_get_type(), GnomeDbEntryCombo)
</MACRO>
<MACRO>
<NAME>GNOME_DB_ENTRY_COMBO_CLASS</NAME>
#define GNOME_DB_ENTRY_COMBO_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gnome_db_entry_combo_get_type (), GnomeDbEntryComboClass)
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_ENTRY_COMBO</NAME>
#define GNOME_DB_IS_ENTRY_COMBO(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gnome_db_entry_combo_get_type ())
</MACRO>
<STRUCT>
<NAME>GnomeDbEntryCombo</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryComboClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryComboPriv</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryCombo</NAME>
struct GnomeDbEntryCombo
{
	GnomeDbEntryShell        object;
	GnomeDbEntryComboPriv   *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryComboClass</NAME>
struct GnomeDbEntryComboClass
{
	GnomeDbEntryShellClass   parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_entry_combo_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_entry_combo_new</NAME>
<RETURNS>GtkWidget       *</RETURNS>
GdaSet *paramlist, GdaSetSource *source
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_entry_combo_set_values</NAME>
<RETURNS>gboolean  </RETURNS>
GnomeDbEntryCombo *combo, GSList *values
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_entry_combo_get_values</NAME>
<RETURNS>GSList          *</RETURNS>
GnomeDbEntryCombo *combo
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_entry_combo_get_all_values</NAME>
<RETURNS>GSList          *</RETURNS>
GnomeDbEntryCombo *combo
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_entry_combo_set_values_orig</NAME>
<RETURNS>void  </RETURNS>
GnomeDbEntryCombo *combo, GSList *values
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_entry_combo_get_values_orig</NAME>
<RETURNS>GSList          *</RETURNS>
GnomeDbEntryCombo *combo
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_entry_combo_set_values_default</NAME>
<RETURNS>void  </RETURNS>
GnomeDbEntryCombo *combo, GSList *values
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_ENTRY_STRING</NAME>
#define GNOME_DB_TYPE_ENTRY_STRING          (gnome_db_entry_string_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_ENTRY_STRING</NAME>
#define GNOME_DB_ENTRY_STRING(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gnome_db_entry_string_get_type(), GnomeDbEntryString)
</MACRO>
<MACRO>
<NAME>GNOME_DB_ENTRY_STRING_CLASS</NAME>
#define GNOME_DB_ENTRY_STRING_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gnome_db_entry_string_get_type (), GnomeDbEntryStringClass)
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_ENTRY_STRING</NAME>
#define GNOME_DB_IS_ENTRY_STRING(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gnome_db_entry_string_get_type ())
</MACRO>
<STRUCT>
<NAME>GnomeDbEntryString</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryStringClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryStringPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryString</NAME>
struct GnomeDbEntryString
{
	GnomeDbEntryWrapper              object;
	GnomeDbEntryStringPrivate       *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryStringClass</NAME>
struct GnomeDbEntryStringClass
{
	GnomeDbEntryWrapperClass         parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_entry_string_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_entry_string_new</NAME>
<RETURNS>GtkWidget    *</RETURNS>
GdaDataHandler *dh, GType type, const gchar *options
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_ENTRY_TIME</NAME>
#define GNOME_DB_TYPE_ENTRY_TIME          (gnome_db_entry_time_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_ENTRY_TIME</NAME>
#define GNOME_DB_ENTRY_TIME(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gnome_db_entry_time_get_type(), GnomeDbEntryTime)
</MACRO>
<MACRO>
<NAME>GNOME_DB_ENTRY_TIME_CLASS</NAME>
#define GNOME_DB_ENTRY_TIME_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gnome_db_entry_time_get_type (), GnomeDbEntryTimeClass)
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_ENTRY_TIME</NAME>
#define GNOME_DB_IS_ENTRY_TIME(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gnome_db_entry_time_get_type ())
</MACRO>
<STRUCT>
<NAME>GnomeDbEntryTime</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryTimeClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryTimePrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryTime</NAME>
struct GnomeDbEntryTime
{
	GnomeDbEntryCommonTime           object;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryTimeClass</NAME>
struct GnomeDbEntryTimeClass
{
	GnomeDbEntryCommonTimeClass      parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_entry_time_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_entry_time_new</NAME>
<RETURNS>GtkWidget    *</RETURNS>
GdaDataHandler *dh
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_ENTRY_BOOLEAN</NAME>
#define GNOME_DB_TYPE_ENTRY_BOOLEAN          (gnome_db_entry_boolean_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_ENTRY_BOOLEAN</NAME>
#define GNOME_DB_ENTRY_BOOLEAN(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gnome_db_entry_boolean_get_type(), GnomeDbEntryBoolean)
</MACRO>
<MACRO>
<NAME>GNOME_DB_ENTRY_BOOLEAN_CLASS</NAME>
#define GNOME_DB_ENTRY_BOOLEAN_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gnome_db_entry_boolean_get_type (), GnomeDbEntryBooleanClass)
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_ENTRY_BOOLEAN</NAME>
#define GNOME_DB_IS_ENTRY_BOOLEAN(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gnome_db_entry_boolean_get_type ())
</MACRO>
<STRUCT>
<NAME>GnomeDbEntryBoolean</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryBooleanClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryBooleanPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryBoolean</NAME>
struct GnomeDbEntryBoolean
{
	GnomeDbEntryWrapper              object;
	GnomeDbEntryBooleanPrivate       *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryBooleanClass</NAME>
struct GnomeDbEntryBooleanClass
{
	GnomeDbEntryWrapperClass         parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_entry_boolean_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_entry_boolean_new</NAME>
<RETURNS>GtkWidget    *</RETURNS>
GdaDataHandler *dh, GType type
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_ENTRY_SHELL</NAME>
#define GNOME_DB_TYPE_ENTRY_SHELL          (gnome_db_entry_shell_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_ENTRY_SHELL</NAME>
#define GNOME_DB_ENTRY_SHELL(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gnome_db_entry_shell_get_type(), GnomeDbEntryShell)
</MACRO>
<MACRO>
<NAME>GNOME_DB_ENTRY_SHELL_CLASS</NAME>
#define GNOME_DB_ENTRY_SHELL_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gnome_db_entry_shell_get_type (), GnomeDbEntryShellClass)
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_ENTRY_SHELL</NAME>
#define GNOME_DB_IS_ENTRY_SHELL(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gnome_db_entry_shell_get_type ())
</MACRO>
<STRUCT>
<NAME>GnomeDbEntryShell</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryShellClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryShellPriv</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryShell</NAME>
struct GnomeDbEntryShell
{
	GtkViewport         object;

	GnomeDbEntryShellPriv  *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryShellClass</NAME>
struct GnomeDbEntryShellClass
{
	GtkViewportClass    parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_entry_shell_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_entry_shell_pack_entry</NAME>
<RETURNS>void  </RETURNS>
GnomeDbEntryShell *shell, GtkWidget *main_widget
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_entry_shell_refresh</NAME>
<RETURNS>void  </RETURNS>
GnomeDbEntryShell *shell
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_FORMAT_ENTRY</NAME>
#define GNOME_DB_TYPE_FORMAT_ENTRY                 (gnome_db_format_entry_get_type ())
</MACRO>
<MACRO>
<NAME>GNOME_DB_FORMAT_ENTRY</NAME>
#define GNOME_DB_FORMAT_ENTRY(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), GNOME_DB_TYPE_FORMAT_ENTRY, GnomeDbFormatEntry))
</MACRO>
<MACRO>
<NAME>GNOME_DB_FORMAT_ENTRY_CLASS</NAME>
#define GNOME_DB_FORMAT_ENTRY_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), GNOME_DB_TYPE_FORMAT_ENTRY, GnomeDbFormatEntry))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_FORMAT_ENTRY</NAME>
#define GNOME_DB_IS_FORMAT_ENTRY(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GNOME_DB_TYPE_FORMAT_ENTRY))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_FORMAT_ENTRY_CLASS</NAME>
#define GNOME_DB_IS_FORMAT_ENTRY_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), GNOME_DB_TYPE_FORMAT_ENTRY))
</MACRO>
<MACRO>
<NAME>GNOME_DB_FORMAT_ENTRY_GET_CLASS</NAME>
#define GNOME_DB_FORMAT_ENTRY_GET_CLASS(obj)       (G_TYPE_INSTANCE_GET_CLASS ((obj), GNOME_DB_TYPE_FORMAT_ENTRY, GnomeDbFormatEntry))
</MACRO>
<STRUCT>
<NAME>GnomeDbFormatEntry</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbFormatEntryClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbFormatEntryPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbFormatEntry</NAME>
struct GnomeDbFormatEntry
{
	GtkEntry                   entry;
	GnomeDbFormatEntryPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbFormatEntryClass</NAME>
struct GnomeDbFormatEntryClass
{
	GtkEntryClass              parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_format_entry_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_format_entry_new</NAME>
<RETURNS>GtkWidget             *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_format_entry_set_max_length</NAME>
<RETURNS>void  </RETURNS>
GnomeDbFormatEntry *entry, gint max
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_format_entry_set_format</NAME>
<RETURNS>void  </RETURNS>
GnomeDbFormatEntry *entry,const gchar *format, const gchar *mask, const gchar *completion
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_format_entry_set_decimal_places</NAME>
<RETURNS>void  </RETURNS>
GnomeDbFormatEntry *entry, gint nb_decimals
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_format_entry_set_separators</NAME>
<RETURNS>void  </RETURNS>
GnomeDbFormatEntry *entry, guchar decimal, guchar thousands
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_format_entry_set_edited_type</NAME>
<RETURNS>void  </RETURNS>
GnomeDbFormatEntry *entry, GType type
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_format_entry_set_prefix</NAME>
<RETURNS>void  </RETURNS>
GnomeDbFormatEntry *entry, const gchar *prefix
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_format_entry_set_suffix</NAME>
<RETURNS>void  </RETURNS>
GnomeDbFormatEntry *entry, const gchar *suffix
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_format_entry_set_text</NAME>
<RETURNS>void  </RETURNS>
GnomeDbFormatEntry *entry, const gchar *text
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_format_entry_get_text</NAME>
<RETURNS>gchar                 *</RETURNS>
GnomeDbFormatEntry *entry
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_DATA_CELL_RENDERER_TEXTUAL</NAME>
#define GNOME_DB_TYPE_DATA_CELL_RENDERER_TEXTUAL		(gnome_db_data_cell_renderer_textual_get_type ())
</MACRO>
<MACRO>
<NAME>GNOME_DB_DATA_CELL_RENDERER_TEXTUAL</NAME>
#define GNOME_DB_DATA_CELL_RENDERER_TEXTUAL(obj)		(G_TYPE_CHECK_INSTANCE_CAST ((obj), GNOME_DB_TYPE_DATA_CELL_RENDERER_TEXTUAL, GnomeDbDataCellRendererTextual))
</MACRO>
<MACRO>
<NAME>GNOME_DB_DATA_CELL_RENDERER_TEXTUAL_CLASS</NAME>
#define GNOME_DB_DATA_CELL_RENDERER_TEXTUAL_CLASS(klass)	(G_TYPE_CHECK_CLASS_CAST ((klass), GNOME_DB_TYPE_DATA_CELL_RENDERER_TEXTUAL, GnomeDbDataCellRendererTextualClass))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_DATA_CELL_RENDERER_TEXTUAL</NAME>
#define GNOME_DB_IS_DATA_CELL_RENDERER_TEXTUAL(obj)		(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GNOME_DB_TYPE_DATA_CELL_RENDERER_TEXTUAL))
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_DATA_CELL_RENDERER_TEXTUAL_CLASS</NAME>
#define GNOME_DB_IS_DATA_CELL_RENDERER_TEXTUAL_CLASS(klass)	(G_TYPE_CHECK_CLASS_TYPE ((klass), GNOME_DB_TYPE_DATA_CELL_RENDERER_TEXTUAL))
</MACRO>
<MACRO>
<NAME>GNOME_DB_DATA_CELL_RENDERER_TEXTUAL_GET_CLASS</NAME>
#define GNOME_DB_DATA_CELL_RENDERER_TEXTUAL_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), GNOME_DB_TYPE_DATA_CELL_RENDERER_TEXTUAL, GnomeDbDataCellRendererTextualClass))
</MACRO>
<STRUCT>
<NAME>GnomeDbDataCellRendererTextual</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbDataCellRendererTextualClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbDataCellRendererTextualPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbDataCellRendererTextual</NAME>
struct GnomeDbDataCellRendererTextual
{
	GtkCellRendererText                    parent;

	GnomeDbDataCellRendererTextualPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbDataCellRendererTextualClass</NAME>
struct GnomeDbDataCellRendererTextualClass
{
	GtkCellRendererTextClass               parent_class;
	
	void (* changed) (GnomeDbDataCellRendererTextual  *cell_renderer_textual,
			  const gchar         *path,
			  const GValue      *new_value);
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_data_cell_renderer_textual_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_data_cell_renderer_textual_new</NAME>
<RETURNS>GtkCellRenderer  *</RETURNS>
GdaDataHandler *dh, GType type,const gchar *options
</FUNCTION>
<MACRO>
<NAME>GNOME_DB_TYPE_ENTRY_WRAPPER</NAME>
#define GNOME_DB_TYPE_ENTRY_WRAPPER          (gnome_db_entry_wrapper_get_type())
</MACRO>
<MACRO>
<NAME>GNOME_DB_ENTRY_WRAPPER</NAME>
#define GNOME_DB_ENTRY_WRAPPER(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, gnome_db_entry_wrapper_get_type(), GnomeDbEntryWrapper)
</MACRO>
<MACRO>
<NAME>GNOME_DB_ENTRY_WRAPPER_CLASS</NAME>
#define GNOME_DB_ENTRY_WRAPPER_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, gnome_db_entry_wrapper_get_type (), GnomeDbEntryWrapperClass)
</MACRO>
<MACRO>
<NAME>GNOME_DB_IS_ENTRY_WRAPPER</NAME>
#define GNOME_DB_IS_ENTRY_WRAPPER(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, gnome_db_entry_wrapper_get_type ())
</MACRO>
<STRUCT>
<NAME>GnomeDbEntryWrapper</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryWrapperClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryWrapperPriv</NAME>
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryWrapper</NAME>
struct GnomeDbEntryWrapper
{
	GnomeDbEntryShell        object;

	GnomeDbEntryWrapperPriv  *priv;
};
</STRUCT>
<STRUCT>
<NAME>GnomeDbEntryWrapperClass</NAME>
struct GnomeDbEntryWrapperClass
{
	GnomeDbEntryShellClass   parent_class;

	/* pure virtual functions */
	GtkWidget        *(*create_entry)     (GnomeDbEntryWrapper *mgwrp);
	void              (*real_set_value)   (GnomeDbEntryWrapper *mgwrp, const GValue *value);
	GValue           *(*real_get_value)   (GnomeDbEntryWrapper *mgwrp);
	void              (*connect_signals)  (GnomeDbEntryWrapper *mgwrp, GCallback modify_cb, GCallback activate_cb);
	gboolean          (*expand_in_layout) (GnomeDbEntryWrapper *mgwrp);
	void              (*set_editable)     (GnomeDbEntryWrapper *mgwrp, gboolean editable);

	gboolean          (*value_is_equal_to)(GnomeDbEntryWrapper *mgwrp, const GValue *value);
	gboolean          (*value_is_null)    (GnomeDbEntryWrapper *mgwrp);
	gboolean          (*is_valid)         (GnomeDbEntryWrapper *mgwrp); /* not used yet */
	void              (*grab_focus)       (GnomeDbEntryWrapper *mgwrp);
};
</STRUCT>
<FUNCTION>
<NAME>gnome_db_entry_wrapper_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_entry_wrapper_contents_changed</NAME>
<RETURNS>void  </RETURNS>
GnomeDbEntryWrapper *mgwrp
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_entry_wrapper_contents_activated</NAME>
<RETURNS>void  </RETURNS>
GnomeDbEntryWrapper *mgwrp
</FUNCTION>
<ENUM>
<NAME>GbrInitError</NAME>
typedef enum {
	/** Cannot allocate memory. */
	_GNOME_DB_GBR_INIT_ERROR_NOMEM,
	/** Unable to open /proc/self/maps; see errno for details. */
	_GNOME_DB_GBR_INIT_ERROR_OPEN_MAPS,
	/** Unable to read from /proc/self/maps; see errno for details. */
	_GNOME_DB_GBR_INIT_ERROR_READ_MAPS,
	/** The file format of /proc/self/maps is invalid; kernel bug? */
	_GNOME_DB_GBR_INIT_ERROR_INVALID_MAPS,
	/** BinReloc is disabled (the ENABLE_BINRELOC macro is not defined). */
	_GNOME_DB_GBR_INIT_ERROR_DISABLED
} GbrInitError;
</ENUM>
<ENUM>
<NAME>GnomeDbPrefixDir</NAME>
typedef enum {
	GNOME_DB_NO_DIR,
	GNOME_DB_BIN_DIR,
	GNOME_DB_SBIN_DIR,
	GNOME_DB_DATA_DIR,
	GNOME_DB_LOCALE_DIR,
	GNOME_DB_LIB_DIR,
	GNOME_DB_LIBEXEC_DIR,
	GNOME_DB_ETC_DIR
} GnomeDbPrefixDir;
</ENUM>
<FUNCTION>
<NAME>gnome_db_gbr_init</NAME>
<RETURNS>void  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_gbr_get_file_path</NAME>
<RETURNS>gchar    *</RETURNS>
GnomeDbPrefixDir where, ...
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_gbr_get_icon_path</NAME>
<RETURNS>gchar    *</RETURNS>
const gchar *icon_name
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_gbr_get_data_dir_path</NAME>
<RETURNS>gchar    *</RETURNS>
const gchar *file_name
</FUNCTION>
<FUNCTION>
<NAME>gnome_db_gbr_get_locale_dir_path</NAME>
<RETURNS>gchar    *</RETURNS>
void
</FUNCTION>
