Estron support library

Modules
	SQL Query Builder
	Resolve names into objects
	Database Queries
	Database Reports
	User interface activities
	Data Fields
	Populate values from queries
	Query Object Framework support
Data Structures
struct	DuiResolver_s
Defines
#define	DUI_DATABASE_TYPE   (dui_database_get_type())
#define	DUI_DATABASE(object)   (G_TYPE_CHECK_INSTANCE_CAST ((object), DUI_DATABASE_TYPE, DuiDatabase))
#define	IS_DUI_DATABASE(object)   (G_TYPE_CHECK_INSTANCE_TYPE ((object), DUI_DATABASE_TYPE))
Typedefs
typedef struct DuiResolver_s	DuiResolver
typedef void(*	DuiResolverFieldFunc )(DuiField *, gpointer)
typedef void(*	DuiResolverRealizeFunc )(gpointer)
typedef struct _escape	sqlEscape
typedef struct DuiGtkTop_s	DuiGtkTop
typedef struct DuiSignal_s	DuiSignal
typedef struct DuiWindow_s	DuiWindow
typedef struct DwiGtkParseCtxt_s	DwiGtkParseCtxt
Functions
DuiResolver *	dui_resolver_new (void)
void	dui_resolver_destroy (DuiResolver *res)
void	dui_resolver_add_field (DuiResolver *, DuiField *)
void	dui_resolver_add_resolver (DuiResolver *, DuiResolverFieldFunc, gpointer user_data)
void	dui_resolver_remove_resolver (DuiResolver *, DuiResolverFieldFunc, gpointer user_data)
void	dui_resolver_add_realizer (DuiResolver *, DuiResolverRealizeFunc, gpointer)
void	dui_resolver_resolve (DuiResolver *)
void	dui_resolver_realize (DuiResolver *)
sqlEscape *	sqlEscape_new (void)
void	sqlEscape_destroy (sqlEscape *)
const gchar *	sqlEscapeString (sqlEscape *, const gchar *orig_string)
GType	dui_database_get_type (void)
DuiDatabase *	dui_database_new (const gchar *name, const gchar *provider, const gchar *dbname, const gchar *hostname, const gchar *username, const gchar *authentication_token)
void	dui_database_destroy (DuiDatabase *)
DuiDBConnection *	dui_database_do_realize (DuiDatabase *)
const gchar *	dui_database_get_name (DuiDatabase *)
DuiGtkTop *	dui_gtk_top_new (void)
void	dui_gtk_top_destroy (DuiGtkTop *top)
void	dui_gtk_top_add_window (DuiGtkTop *top, DuiWindow *win)
DuiWindow *	dui_gtk_top_find_window_by_name (DuiGtkTop *top, const char *name)
DuiInterfacePlugin *	dui_gtk_top_plugin_new (DuiGtkTop *top)
DwiGtkParseCtxt *	dwi_gtk_parser_new (DuiParser *par)
void	dui_show_message (const char *, GLogLevelFlags, const gchar *, gpointer)
DuiSignal *	dui_signal_new (const gchar *objname, const gchar *signalname, const gchar *act)
void	dui_signal_destroy (DuiSignal *sig)
const gchar *	dui_signal_get_widgetname (DuiSignal *sig)
void	dui_signal_connect (DuiSignal *sig, GObject *obj, GCallback sigfunc, gpointer user_data)
void	dui_signal_do_realize (DuiSignal *sig, DuiWindow *)
void	xxxgtk_textview_set_text (GtkTextView *text, const gchar *str)
gchar *	xxxgtk_textview_get_text (GtkTextView *text)
DuiWindow *	dui_window_new (const char *name, DuiGtkTop *)
void	dui_window_destroy (DuiWindow *)
const char *	dui_window_get_name (DuiWindow *)
void	dui_window_set_glade (DuiWindow *, const char *glade_xml_filepath, const char *root_widget, int is_app_main_window)
void	dui_window_add_action (DuiWindow *, DuiAction *)
void	dui_window_add_report (DuiWindow *, DuiReport *)
void	dui_window_add_signal (DuiWindow *, DuiSignal *, DuiAction *)
GtkWidget *	dui_window_get_widget (DuiWindow *, const char *widgetname)
void	dui_window_resolve (DuiWindow *)
void	dui_window_realize (DuiWindow *)
int	dui_window_is_realized (DuiWindow *)
int	dui_window_is_app_main_window (DuiWindow *)
void	dui_window_db_connect (DuiWindow *)

---

Typedef Documentation

typedef struct DwiGtkParseCtxt_s DwiGtkParseCtxt

The Gtk XML Parse context

Definition at line 37 of file parse-gtk.h.

---

Function Documentation

void dui_gtk_top_add_window	(	DuiGtkTop *	top,
		DuiWindow *	win
	)

The top leve holds a list of windows that can be retreived.

Definition at line 69 of file duitop-gtk.c.

{
    if (!win) return;
    top->window_list = g_list_append (top->window_list, win);
}

DuiGtkTop* dui_gtk_top_new

(

void

)

Create a new top-level structure to hold top-level stuff

Definition at line 43 of file duitop-gtk.c.

{
    DuiGtkTop *top;

    top = g_new0 (DuiGtkTop, 1);
    top->window_list = NULL;
    return top;
}

DuiInterfacePlugin* dui_gtk_top_plugin_new

(

DuiGtkTop *

top

)

Create a plugin that is needed to get the gtk widgets realized at the right time.

Definition at line 135 of file duitop-gtk.c.

{
    DuiInterfacePlugin *dip;

    dip = g_new0 (DuiInterfacePlugin, 1);
    dip->plugin_name = "dui_gtk_top";
    dip->self = top;
    dip->realize = dui_gtk_top_realize;

    return dip;
}

void dui_resolver_add_field	(	DuiResolver *	,
		DuiField *
	)

Add a field which will need resolution later

Definition at line 69 of file duiresolver.c.

{
    if (!res) return;
    res->field_list = g_list_prepend (res->field_list, fld);
}

void dui_resolver_add_realizer	(	DuiResolver *	,
		DuiResolverRealizeFunc	,
		gpointer
	)

Add a function which, when called, will realize objects

Definition at line 130 of file duiresolver.c.

{
    DuiResolverRealizer *rr;

    if (!res) return;
    rr = g_new0 (DuiResolverRealizer, 1);
    rr->realize_func = fn;
    rr->user_data = ud;

    res->realizer_list = g_list_prepend (res->realizer_list, rr);
}

void dui_resolver_add_resolver	(	DuiResolver *	,
		DuiResolverFieldFunc	,
		gpointer	user_data
	)

Add a function which is able to resolve fields

Definition at line 76 of file duiresolver.c.

{
    DuiResolverResolver *rr;

    if (!res) return;
    rr = g_new0 (DuiResolverResolver, 1);
    rr->resolver_func = fn;
    rr->user_data = ud;

    res->resolver_list = g_list_prepend (res->resolver_list, rr);
}

void dui_resolver_remove_resolver	(	DuiResolver *	,
		DuiResolverFieldFunc	,
		gpointer	user_data
	)

Remove function and its user_data from the resolver list. Note: This routine is intended for cleanup/shutdown. If you think you need this routine for any other purpose, you are wrong; what you really want is to use a different resolver function (and different user_data) that does what you need.

Definition at line 90 of file duiresolver.c.

{
    GList *n;
    if (!res) return;

    for (n=res->resolver_list; n; n=n->next)
    {
        DuiResolverResolver *rr = n->data;
        if ((rr->user_data == ud) && (rr->resolver_func == fn))
        {
            g_free (rr);
            res->resolver_list = g_list_delete_link (res->resolver_list, n);
            return;
        }
    }
}

void dui_resolver_resolve

(

DuiResolver *

)

Do the deed. Call the DuiResolverFunc once on each field in the list of fields.

Definition at line 109 of file duiresolver.c.

{
    GList *n, *f;

    if (!res) return;

    for (n=res->resolver_list; n; n=n->next)
    {
        DuiResolverResolver *rr = n->data;

        for (f= res->field_list; f; f=f->next)
        {
            DuiField *fld = f->data;
            (rr->resolver_func) (fld, rr->user_data);
        }
    }
}

void dui_signal_destroy

(

DuiSignal *

sig

)

Bug:

should probably be using GClosure in here

Definition at line 83 of file signal.c.

{
    if (!sig) return;
    if (sig->gobj && G_IS_OBJECT(sig->gobj) )
    {
        g_signal_handler_disconnect (sig->gobj, sig->signal_id);
    }
    g_free (sig->widgetname);
    g_free (sig->signalname);
    g_free (sig->actionname);

    sig->widgetname = NULL;
    sig->signalname = NULL;
    sig->actionname = NULL;

    sig->gobj = NULL;
    sig->signal_id = -1;
    sig->sigfunc = NULL;
    sig->user_data = NULL;

    g_free (sig);
}

DuiSignal* dui_signal_new	(	const gchar *	objname,
		const gchar *	signalname,
		const gchar *	act
	)

The objname must specify a GObject (possibly a GtkWidget) on which there exists a signal of name 'signalname'. The widgetname must specify the name of a widget that appears in the glade file for the window that this action is a part of.

Definition at line 61 of file signal.c.

{
    DuiSignal *sig;

    if (!signame || !wig || !act) return NULL;

    sig = g_new (DuiSignal, 1);
    sig->widgetname = g_strdup (wig);
    sig->signalname = g_strdup (signame);
    sig->actionname = g_strdup (act);
    sig->gobj = NULL;
    sig->signal_id = -1;
    sig->sigfunc = NULL;
    sig->user_data = NULL;

    return sig;
}

void dui_window_add_action	(	DuiWindow *	,
		DuiAction *
	)

Indicate that a fill-in form 'lives' in this window

Definition at line 178 of file window.c.

{
    if (!win || !act) return;
    win->actions = g_list_append (win->actions, act);
}

void dui_window_add_report	(	DuiWindow *	,
		DuiReport *
	)

Indicate that a report 'lives' in this window

Definition at line 185 of file window.c.

{
    if (!win || !rpt) return;
    win->reports = g_list_prepend (win->reports, rpt);
}

void dui_window_add_signal	(	DuiWindow *	,
		DuiSignal *	,
		DuiAction *
	)

Temporary implementation for signals. If action is non-null, then the action will be run. If null, then the signal is of type 'sigaction' and works independently.

Definition at line 198 of file window.c.

{
    if (!win || !sig) return;
    win->signals = g_list_append (win->signals, sig);

    if (!act) return;
    dui_signal_connect (sig, NULL, 
               G_CALLBACK(action_signal_handler), act);
}

void dui_window_db_connect

(

DuiWindow *

)

Force the database used for queries from this window to be connected to. This will cause any database-connection error messages to be displayed. XXX this is kind-of a hack. We should have a more formal error reporting chain.

Definition at line 373 of file window.c.

{
    GList *node;
    if (!win) return;

    for (node=win->actions; node; node=node->next)
    {
        DuiAction *act = node->data;
        dui_action_db_connect (act);
    }
}

GtkWidget* dui_window_get_widget	(	DuiWindow *	,
		const char *	widgetname
	)

Thin wrapper around glade_xml_get_widget() Gets the widget associated with the indicated name.

int dui_window_is_realized

(

DuiWindow *

)

Return non-zero value if the widget for this window exists

Definition at line 361 of file window.c.

{
    if (!win) return 0;
    /* Note that closing some windows destroys them,
     * we can check this by seeing if our pointer is still a widget */
    if (win->glxml && GTK_IS_WIDGET (win->widget)) return 1;
    return 0;
}

void dui_window_realize

(

DuiWindow *

)

Cause this window to actually exist on the screen

Bug:

the order in which actions and signals are realized affects the order in which they are delivered. This is kinda bad, resulting in ordering effects depending on the organization of the DUI files. This is kind-of a bug & needs fixing. Anyways, for right now, it is important to realize actions before signals, because otherwise database login won't work :-(

Definition at line 269 of file window.c.

{
    GList *node;
    if (!win) return;

    /* We don't want to enter into here twice; in particular, if
     * we accidentally gtk_widget_show() too soon, for example,
     * if we show before the signals are initialized, then the 
     * "show" signal will be missed, which will screw up dialogs
     * that depend on actions running as a result of window show.
     */
    if (win->recurse_cnt) return;
    win->recurse_cnt ++;

    ENTER ("(win=%p \"%s\")", win, win->name);
    /* If already realized, do (almost) nothing */
    /* Note that closing some windows destroys them,
     * so we need to re-realize when they're gone ... */
    if (win->glxml && win->widget && GTK_IS_WIDGET (win->widget))
    {
        gtk_widget_show (win->widget);
        win->recurse_cnt --;
        LEAVE ("(win=%p \"%s\") { already realized, just showing }", win, win->name);
        return;
    }

    win->glxml = glade_xml_new (win->glade_filepath, win->glade_top_widget, NULL);
    if (NULL == win->glxml)
    {
        SYNTAX ("can't open \"%s\"", win->glade_filepath);
        win->recurse_cnt --;
        return;
    }

    glade_xml_signal_autoconnect (win->glxml);
    win->widget = glade_xml_get_widget (win->glxml, win->glade_top_widget);
    if (NULL == win->widget)
    {
        SYNTAX ("can't find the widget \"%s\" in \"%s\"\n",
            win->glade_top_widget, win->glade_filepath);
        win->recurse_cnt --;
        return;
    }

    gtk_signal_connect (GTK_OBJECT(win->widget), "destroy", 
        GTK_SIGNAL_FUNC(destroy_cb), win);

    for (node=win->actions; node; node=node->next)
    {
        DuiAction *act = node->data;
        dui_action_do_realize (act);
    }

    for (node=win->signals; node; node=node->next)
    {
        DuiSignal *sig = node->data;
        dui_signal_do_realize (sig, win);
    }

    for (node=win->reports; node; node=node->next)
    {
        DuiReport *rpt = node->data;
        dui_report_do_realize (rpt);
    }
    
    gtk_widget_show (win->widget);
    
    win->recurse_cnt --;
    LEAVE ("(win=%p \"%s\")", win, win->name);
}

void dui_window_resolve

(

DuiWindow *

)

resolve dangling references

Definition at line 244 of file window.c.

{
    GList *node;
    if (!win) return;

    ENTER ("(win=%p)", win);
    /* Tell the reports, actions about where they will find thier
     * widgets */
    for (node=win->actions; node; node=node->next)
    {
        DuiAction *act = node->data;
        dui_action_add_resolver (act, dui_field_resolve_widget, win);
        dui_action_add_realizer (act, win_realize, win);
    }
    for (node=win->reports; node; node=node->next)
    {
        DuiReport *rpt = node->data;
        dui_report_add_resolver (rpt, dui_field_resolve_widget, win);
        dui_report_add_realizer (rpt, win_realize, win);
    }

    LEAVE ("(win=%p)", win);
}

void dui_window_set_glade	(	DuiWindow *	,
		const char *	glade_xml_filepath,
		const char *	root_widget,
		int	is_app_main_window
	)

This records the top-level widget for this window. its typically a top-level window If is_app_main_window is set, then this window will be automatially created on application startup.

DwiGtkParseCtxt* dwi_gtk_parser_new

(

DuiParser *

par

)

Add a parsing context to the parser that is capable of understanding the Gtk fields.

Bug:

ctx needs a full GIO path before this call so that estron can find the glade file if not in the current directory.

Definition at line 440 of file parse-gtk.c.

{
    DuiParserElementPlugin *plg;
    DwiGtkParseCtxt *ctx = g_new0 (DwiGtkParseCtxt, 1);

    ctx->top = dui_gtk_top_new();
    ctx->parser = par;
    ctx->window = NULL;
    ctx->action = NULL;

    /* Make sure the gtk interface is realized */
    DuiInterfacePlugin *dip = dui_gtk_top_plugin_new(ctx->top);
    DuiInterface *iface = dui_parser_get_interface (par);
    dui_interface_register_plugin (iface, dip);

    plg = dwi_sigaction_parser_plugin(ctx);
    dui_parser_register_element_plugin (par, plg);

    plg = dwi_submit_parser_plugin(ctx);
    dui_parser_register_element_plugin (par, plg);

    plg = dwi_window_parser_plugin(ctx);
    dui_parser_register_element_plugin (par, plg);

    DuiParserTablePlugin *tbl;
    tbl = gtk_parser_table_plugin (ctx);
    dui_parser_register_table_plugin (par, tbl);

   DuiParserFieldPlugin *fp;
    fp = dwi_widget_parser_plugin (ctx);
    dui_parser_register_field_plugin (par, fp);

    fp = dwi_widdata_parser_plugin (ctx);
    dui_parser_register_field_plugin (par, fp);

    fp = dwi_widarg_parser_plugin (ctx);
    dui_parser_register_field_plugin (par, fp);

    DuiParserStructPlugin *psp;
    psp = dwi_struct_plugin (ctx);
    dui_parser_register_struct_plugin (par, psp);

    return ctx;
}

gchar* xxxgtk_textview_get_text

(

GtkTextView *

text

)

Simplified interface to the textview widget

Definition at line 52 of file util-gtk.c.

{
    GtkTextIter start, end;
    GtkTextBuffer *buff = gtk_text_view_get_buffer (text);
    gtk_text_buffer_get_start_iter (buff, &start);
    gtk_text_buffer_get_end_iter (buff, &end);
    return gtk_text_buffer_get_text(buff, &start, &end, TRUE);
}

void xxxgtk_textview_set_text	(	GtkTextView *	text,
		const gchar *	str
	)

Simplified interface to the textview widget