duifield-gtk.c File Reference

---

Detailed Description

Implements the gtk type of the field.

Author:

2002, 2003 Linas Vepstas <linas@linas.org>

This is the most broken part of estron - lots of work needed to remove Gtk1.2 and deprecated GtkCTree support.

Definition in file duifield-gtk.c.

#include "config.h"
#include <string.h>
#include <glib.h>
#include <gtk/gtk.h>
#include <gnome.h>
#include "duifield.h"
#include "duifield-gtk.h"
#include "duifilter.h"
#include "duiresolver.h"
#include "perr.h"
#include "util.h"
#include "util-gtk.h"
#include "window.h"

Go to the source code of this file.

Functions
static void	widget_field_clear (DuiField *f)
static void	widata_field_clear (DuiField *f)
static void	widarg_field_clear (DuiField *f)
static void	where_field_clear (DuiField *f)
static const char *	widget_get_value (DuiField *fs)
static void	widget_set_value (DuiField *fs, const char *val)
static const char *	widget_get_data (DuiField *fs)
static void	widget_set_data (DuiField *fs, const char *val)
static void	ctree_pre (DuiField *fld, gboolean do_clear)
static void	ctree_post (DuiField *fld)
static GtkCTreeNode *	ctree_recur (GtkCTree *ctree, GtkCTreeNode *start_ctn, int match_col, const char *match_value)
static gboolean	ctree_iter (DuiField *fld)
static void	clist_pre (DuiField *fld, gboolean do_clear)
static void	clist_post (DuiField *fld)
static gboolean	clist_iter (DuiField *fld)
static void	resolve_target (DuiField *target, DuiField *matcher)
static void	set_match_value (DuiField *fld, const char *val)
void	dui_field_set_widget (DuiField *fs, const char *widname, int colnum)
void	dui_field_set_wid_data (DuiField *fs, const char *widname, int colnum, const char *datakey)
void	dui_field_set_wid_arg (DuiField *fs, const char *widname, int colnum, const char *arg)
void	dui_field_set_wid_where (DuiField *fs, const char *widname, int colnum, const char *compareop)
static void	get_clist_row (GtkCList *clist, gint row, gint column, GdkEvent *event, DuiField *fs)
static void	unget_clist_row (GtkCList *clist, gint row, gint column, GdkEvent *event, DuiField *fs)
static void	get_ctree_row (GtkCList *clist, GtkCTreeNode *ctn, gint column, DuiField *fs)
static void	unget_ctree_row (GtkCList *clist, GtkCTreeNode *ctn, gint column, DuiField *fs)
static void	add_watcher (DuiField *fs, GtkWidget *w)
static void	clist_sort_column (GtkCList *clist, gint column, DuiField *f)
static void	add_sorter (DuiField *fld, GtkWidget *w)
static void	resolve_where (DuiField *fld)
static void	resolve_widget (DuiField *fs, GtkWidget *w)
void	dui_field_resolve_widget (DuiField *fld, gpointer ud)

---

Function Documentation

static const char* widget_get_value

(

DuiField *

fs

)

[static]

Bug:

hack alert static buffer not thread safe

Definition at line 150 of file duifield-gtk.c.

{
    GtkWidget *widget;
    const gchar * val = NULL;
    struct gtk_widget_s * gw = (struct gtk_widget_s *) get_gobj_field (fs);

    /* ft->type is a const char, as is DUI_FIELD_WIDGET, 
     but this condition should still never happen */
    if (0 != g_ascii_strncasecmp(DUI_FIELD_WIDGET, fs->type, 0)) return NULL;

    widget = gw->widget;
    if (!widget) return NULL;   /* this shouldn't happen, really */

    /* Supported GTK-1.2 widgets, in pseudo-alpha order;
     * Gotta handle ctree first */
    if (GTK_IS_CTREE(widget))
    {
        if (NULL == gw->ctn) return NULL;
        gtk_ctree_node_get_text (GTK_CTREE(widget), gw->ctn, gw->column, (gchar **) &val);
    }
    else
    if (GTK_IS_CLIST(widget))
    {
        if (0 > gw->row) return NULL;
        gtk_clist_get_text (GTK_CLIST(widget), gw->row, gw->column, (gchar **) &val);
    }
    else
    if (GTK_IS_MENU(widget))
    {
        static char menuval[18];  
        GList *node; 
        int i=0;
        GtkWidget *w = gtk_menu_get_active (GTK_MENU(widget));
        for (node=GTK_MENU_SHELL(widget)->children; node; node=node->next)
        {
            if (w == node->data)
            {
                snprintf (menuval, 18, "%d", i);
                return menuval;
            }
            i++;
        }
    }
    else
    if (GTK_IS_OPTION_MENU(widget))
    {
        DuiField dfs;
        dfs = *fs;
        struct gtk_widget_s * dgw;
        
        dgw = (struct gtk_widget_s *) get_gobj_field (&dfs);
        dgw->widget = GTK_OPTION_MENU(widget)->menu;

        /* pass-through on menu, let the child report */
        val = widget_get_value (&dfs);
    }
    else
    if (GTK_IS_RADIO_BUTTON(widget))
    {
        GSList *node;

        /* loop over buttons in group, get data for the one that was pushed */
        node = gtk_radio_button_get_group (GTK_RADIO_BUTTON (widget));
        for ( ; node; node=node->next)
        {
            gboolean pushed;
            pushed = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(node->data));
            if (pushed) break;
        }
        if (!node) return NULL;
        val = gtk_object_get_data (GTK_OBJECT(node->data), "/system/data");
    }
    else
    if (GTK_IS_TOGGLE_BUTTON(widget))
    {
        static char togbuff[2];  /* XXX hack alert not thread safe */
        gboolean state;
        state = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(widget));
        if (state) togbuff[0] = '1'; else togbuff[0] = '0';
        togbuff[1] = 0;  
        val = togbuff;
    }
    else
    if (GTK_IS_SPIN_BUTTON(widget))
    {
        static char spinbuff[40];    /* hack alert not thread safe */
        gdouble dbl = gtk_spin_button_get_value (GTK_SPIN_BUTTON(widget));
        snprintf (spinbuff, 40, "%24.18g", dbl);
        return spinbuff;
    }
    else
    if (GTK_IS_ENTRY(widget))
    {
        val = gtk_entry_get_text (GTK_ENTRY(widget));
    }
    else
    if (GTK_IS_LABEL(widget))
    {
        gtk_label_get (GTK_LABEL(widget), (gchar **) &val);
    }
    else
    if (GTK_IS_TEXT_VIEW(widget))
    {
        val = xxxgtk_textview_get_text (GTK_TEXT_VIEW(widget));
    }
    else
    if (GTK_IS_COMBO(widget))
    {
        val = gtk_entry_get_text (GTK_ENTRY(GTK_COMBO(widget)->entry));
    }
    else
    if (GTK_IS_RANGE(widget))
    {
        GtkAdjustment *adj = gtk_range_get_adjustment (GTK_RANGE(widget));
        double flt = adj->value;
        static char rangebuff[40];
        snprintf (rangebuff, 40, "%24.18g", flt);
        val = rangebuff;
    }
    else
    if (GNOME_IS_FILE_ENTRY (widget))
    {
        GtkWidget * entry = gnome_file_entry_gtk_entry (GNOME_FILE_ENTRY(widget));
        val = gtk_entry_get_text (GTK_ENTRY (entry));
    }
    else
    if (GTK_IS_FILE_SELECTION (widget))
    {
        val = gtk_entry_get_text (GTK_ENTRY (GTK_FILE_SELECTION
                           (widget)->selection_entry));
    }
    else
    if (GNOME_IS_DATE_EDIT(widget))
    {
        static char datebuff[50];
        time_t thyme = gnome_date_edit_get_time (GNOME_DATE_EDIT(widget));
        xxxgnc_secs_to_iso8601_buff (thyme, datebuff);
        return datebuff;
    }
    else
    if (GTK_IS_BIN(widget))
    {
        /* catch-all handles both GtkButton and GtkOptionMenu */
        DuiField dfs;
        dfs = *fs;
        struct gtk_widget_s * dgw = (struct gtk_widget_s *) get_gobj_field (&dfs);
        dgw->widget = GTK_BIN(widget)->child;

        /* pass-through on bin, let the child report */
        val = widget_get_value (&dfs);
    }
    else
    {
        PERR ("unsupported <where> or <update> widget type %s",
            gtk_type_name(GTK_OBJECT_TYPE(widget)));
    }
    return val;
}

static void widget_set_data	(	DuiField *	fs,
		const char *	val
	)			[static]

Bug:

hack alert -- we need to create destructors as well, otherwise a memory leak

Bug:

hack alert -- we need to create destructors as well, otherwise a memory leak

Definition at line 586 of file duifield-gtk.c.

{
    GtkWidget *widget;
    struct gtk_widata_s *gw = (struct gtk_widata_s*) get_gobj_field (fs);
    const char * datakey;

    /* ft->type is a const char, as is DUI_FIELD_WID_DATA
    but this condition should still never happen */
    if (0 != g_ascii_strncasecmp(DUI_FIELD_WID_DATA, fs->type, 0)) return;

    widget = gw->widget;
    if (!widget) return;   /* this shouldn't happen, really */

    datakey = gw->datakey;

    if (GTK_IS_CTREE(widget))
    {
        GHashTable *tbl;
        if (NULL == gw->ctn) return;
        tbl = gtk_ctree_node_get_row_data (GTK_CTREE(widget), gw->ctn);
        if (!tbl)
        {
            tbl = g_hash_table_new (g_str_hash, g_str_equal);

            /* gtk_ctree_set_row_data_full() has destructor */
            gtk_ctree_node_set_row_data (GTK_CTREE(widget), gw->ctn, tbl);
        }
        g_hash_table_insert (tbl, g_strdup(datakey), g_strdup(val));
    }
    else
    if (GTK_IS_CLIST(widget))
    {
        GHashTable *tbl;
        if (0 > gw->row) return;
        tbl = gtk_clist_get_row_data (GTK_CLIST(widget), gw->row);
        if (!tbl)
        {
            tbl = g_hash_table_new (g_str_hash, g_str_equal);

            /* gtk_clist_set_row_data_full() has destructor */
            gtk_clist_set_row_data (GTK_CLIST(widget), gw->row, tbl);
        }
        g_hash_table_insert (tbl, g_strdup(datakey), g_strdup(val));
    }
#if 0
    else
    if (GTK_IS_RADIO_BUTTON(widget))
    {
        /* XXX uhh, we are supposed to do something special here ... !? */
    }
#endif
    else
    {
        gtk_object_set_data (GTK_OBJECT (widget), datakey, g_strdup(val));
    }
}