GtkWidget *
gtkutil_treeview_new (GtkWidget *box, GtkTreeModel *model,
GtkTreeCellDataFunc mapper, ...)
{
GtkWidget *win, *view;
GtkCellRenderer *renderer = NULL;
GtkTreeViewColumn *col;
va_list args;
int col_id = 0;
GType type;
char *title, *attr;
win = gtk_scrolled_window_new (0, 0);
gtk_container_add (GTK_CONTAINER (box), win);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (win),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_widget_show (win);
view = gtk_tree_view_new_with_model (model);
/* the view now has a ref on the model, we can unref it */
g_object_unref (G_OBJECT (model));
gtk_container_add (GTK_CONTAINER (win), view);
va_start (args, mapper);
for (col_id = va_arg (args, int); col_id != -1; col_id = va_arg (args, int))
{
type = gtk_tree_model_get_column_type (model, col_id);
switch (type)
{
case G_TYPE_BOOLEAN:
renderer = gtk_cell_renderer_toggle_new ();
attr = "active";
break;
case G_TYPE_STRING: /* fall through */
default:
renderer = gtk_cell_renderer_text_new ();
attr = "text";
break;
}
title = va_arg (args, char *);
if (mapper) /* user-specified function to set renderer attributes */
{
col = gtk_tree_view_column_new_with_attributes (title, renderer, NULL);
gtk_tree_view_column_set_cell_data_func (col, renderer, mapper,
GINT_TO_POINTER (col_id), NULL);
} else
{
/* just set the typical attribute for this type of renderer */
col = gtk_tree_view_column_new_with_attributes (title, renderer,
attr, col_id, NULL);
}
gtk_tree_view_append_column (GTK_TREE_VIEW (view), col);
}
va_end (args);
return view;
}
/**
* gimp_string_combo_box_new:
* @id_column:
* @label_column:
*
* Return value: a new #GimpStringComboBox.
*
* Since: 2.4
**/
GtkWidget *
gimp_string_combo_box_new (GtkTreeModel *model,
gint id_column,
gint label_column)
{
g_return_val_if_fail (GTK_IS_TREE_MODEL (model), NULL);
g_return_val_if_fail (gtk_tree_model_get_column_type (model,
id_column) == G_TYPE_STRING, NULL);
g_return_val_if_fail (gtk_tree_model_get_column_type (model,
label_column) == G_TYPE_STRING, NULL);
return g_object_new (GIMP_TYPE_STRING_COMBO_BOX,
"model", model,
"id-column", id_column,
"label-column", label_column,
NULL);
}
/**
* gtk_combo_box_text_insert:
* @combo_box: A #GtkComboBoxText
* @position: An index to insert @text
* @id: (allow-none): a string ID for this value, or %NULL
* @text: A string to display
*
* Inserts @text at @position in the list of strings stored in @combo_box.
* If @id is non-%NULL then it is used as the ID of the row. See
* #GtkComboBox:id-column.
*
* If @position is negative then @text is appended.
*
* Since: 3.0
*/
void
gtk_combo_box_text_insert (GtkComboBoxText *combo_box,
gint position,
const gchar *id,
const gchar *text)
{
GtkListStore *store;
GtkTreeIter iter;
gint text_column;
gint column_type;
g_return_if_fail (GTK_IS_COMBO_BOX_TEXT (combo_box));
g_return_if_fail (text != NULL);
store = GTK_LIST_STORE (gtk_combo_box_get_model (GTK_COMBO_BOX (combo_box)));
g_return_if_fail (GTK_IS_LIST_STORE (store));
text_column = gtk_combo_box_get_entry_text_column (GTK_COMBO_BOX (combo_box));
if (gtk_combo_box_get_has_entry (GTK_COMBO_BOX (combo_box)))
g_return_if_fail (text_column >= 0);
else if (text_column < 0)
text_column = 0;
column_type = gtk_tree_model_get_column_type (GTK_TREE_MODEL (store), text_column);
g_return_if_fail (column_type == G_TYPE_STRING);
if (position < 0)
gtk_list_store_append (store, &iter);
else
gtk_list_store_insert (store, &iter, position);
gtk_list_store_set (store, &iter, text_column, text, -1);
if (id != NULL)
{
gint id_column;
id_column = gtk_combo_box_get_id_column (GTK_COMBO_BOX (combo_box));
g_return_if_fail (id_column >= 0);
column_type = gtk_tree_model_get_column_type (GTK_TREE_MODEL (store), id_column);
g_return_if_fail (column_type == G_TYPE_STRING);
gtk_list_store_set (store, &iter, id_column, id, -1);
}
}
static gboolean gsb_csv_export_tree_view_list_foreach_callback ( GtkTreeModel *model,
GtkTreePath *path,
GtkTreeIter *iter,
FILE *csv_file )
{
GtkTreeView *tree_view;
GList *list;
GList *list_tmp;
gint depth;
/* on n'exporte que les lignes de plus haut niveau */
depth = gtk_tree_path_get_depth ( path );
if ( depth > 1 )
return FALSE;
tree_view = g_object_get_data ( G_OBJECT ( model ), "tree_view" );
list = gtk_tree_view_get_columns ( tree_view );
list_tmp = list;
while ( list_tmp )
{
GtkTreeViewColumn *col;
gchar *text;
gint col_num_model;
GType col_type_model;
col = list_tmp -> data;
col_num_model = GPOINTER_TO_INT ( g_object_get_data ( G_OBJECT ( col ), "num_col_model" ) );
col_type_model = gtk_tree_model_get_column_type ( model, col_num_model );
/* get the text */
if ( col_type_model == G_TYPE_STRING )
gtk_tree_model_get ( model, iter, col_num_model, &text, -1 );
else if ( col_type_model == G_TYPE_INT )
{
gint number;
gtk_tree_model_get ( model, iter, col_num_model, &number, -1 );
text = utils_str_itoa ( number );
}
else
text = NULL;
CSV_STR_FIELD ( csv_file, text );
CSV_CLEAR_FIELD ( text );
list_tmp = list_tmp -> next;
}
CSV_END_RECORD( csv_file );
return FALSE;
}
void
tree_store_set_oop (GtkTreeStore *store,
GtkTreeIter *iter,
int col,
OOP value)
{
GValue gval = { 0 };
g_value_init (&gval, gtk_tree_model_get_column_type (GTK_TREE_MODEL(store), col));
g_value_fill_from_oop (&gval, value);
gtk_tree_store_set_value (store, iter, col, &gval);
g_value_unset (&gval);
}
static gint print_tree_view_list_get_columns_data_nbre_lines ( GtkTreeView *tree_view )
{
GtkTreeModel *model;
GtkTreeIter iter;
GList *list_tmp;
gint nbre_lines = 0;
model = gtk_tree_view_get_model ( tree_view );
if ( !gtk_tree_model_get_iter ( model, &iter, tree_path_to_print ) )
return 0;
list_tmp = gtk_tree_view_get_columns ( tree_view );
while ( list_tmp )
{
GtkTreeViewColumn *col;
const gchar *text;
gint nbre_motifs = 0;
gint col_num_model;
GType col_type_model;
col = ( GtkTreeViewColumn * ) list_tmp -> data;
col_num_model = GPOINTER_TO_INT ( g_object_get_data ( G_OBJECT ( col ), "num_col_model" ) );
col_type_model = gtk_tree_model_get_column_type ( model, col_num_model );
/* get the text */
if ( col_type_model == G_TYPE_STRING )
gtk_tree_model_get ( model, &iter, col_num_model, &text, -1 );
if ( text == NULL || strlen ( text ) == 0 )
{
list_tmp = list_tmp -> next;
continue;
}
if ( g_utf8_strchr ( text, -1, '\n' ) )
{
nbre_motifs = utils_str_get_nbre_motifs ( text, "\n" );
if ( nbre_motifs > nbre_lines )
nbre_lines = nbre_motifs;
}
list_tmp = list_tmp -> next;
}
nbre_lines++;
return nbre_lines;
}
static int
collect_value(VALUE key, VALUE value, ValuesInfo *info)
{
GType g_type;
gint column;
column = NUM2INT(key);
info->g_columns[info->i] = column;
g_type = gtk_tree_model_get_column_type(info->model, column);
g_value_init(&(info->g_values[info->i]), g_type);
rbgobj_rvalue_to_gvalue(value, &(info->g_values[info->i]));
G_CHILD_ADD(info->iter, value);
info->i++;
return ST_CONTINUE;
}
static VALUE
rg_set_value(VALUE self, VALUE iter, VALUE column, VALUE value)
{
GType gtype = gtk_tree_model_get_column_type(RVAL2GTKTREEMODEL(self), NUM2INT(column));
GValue gval = G_VALUE_INIT;
g_value_init(&gval, gtype);
rbgobj_rvalue_to_gvalue(value, &gval);
G_CHILD_ADD(iter, value);
gtk_list_store_set_value(_SELF(self), RVAL2GTKTREEITER(iter), NUM2INT(column), &gval);
g_value_unset(&gval);
return self;
}
static void
array_to_values(VALUE array, VALUE iter, GtkTreeModel *model,
gint *g_columns, GValue *g_values, gint length)
{
gint i;
for (i = 0; i < length; i++) {
GType g_type;
g_columns[i] = i;
g_type = gtk_tree_model_get_column_type(model, i);
g_value_init(&g_values[i], g_type);
rbgobj_rvalue_to_gvalue(RARRAY_PTR(array)[i], &g_values[i]);
G_CHILD_ADD(iter, RARRAY_PTR(array)[i]);
}
}
static VALUE
tstore_set_value(VALUE self, VALUE iter, VALUE column, VALUE value)
{
GType gtype = gtk_tree_model_get_column_type(GTK_TREE_MODEL(RVAL2GOBJ(self)), NUM2INT(column));
GValue gval = {0,};
g_value_init(&gval, gtype);
rbgobj_rvalue_to_gvalue(value, &gval);
G_CHILD_ADD(self, iter);
G_CHILD_ADD(iter, value);
gtk_tree_store_set_value(_SELF(self), RVAL2GTKTREEITER(iter), NUM2INT(column), &gval);
g_value_unset(&gval);
return self;
}
/*
* FUNCTION DEFINITION
*/
static gboolean dialog_search_entry_completion_cb(GtkEntryCompletion *completion,
const gchar *key,
GtkTreeIter *iter,
gpointer data)
{
const av_doc *doc = (const av_doc *)data;
const gchar *real_key = NULL;
gchar *item = NULL;
GtkTreeModel *model = NULL;
gchar *str_normalized = NULL;
gchar *str_case_normalized = NULL;
glong key_len = 0;
gboolean result = FALSE;
AV_DBG("%s: e\n", __func__);
/* Get text in entry */
real_key = gtk_entry_get_text(GTK_ENTRY(gtk_entry_completion_get_entry(completion)));
if (g_utf8_strlen(real_key, -1) <= AV_WIDGET_ENTRY_COMPLETION_KEY_LEN_MIN) return FALSE;
/* Get model in completion */
model = gtk_entry_completion_get_model(completion);
g_return_val_if_fail(gtk_tree_model_get_column_type(model, 0) == G_TYPE_STRING, FALSE);
/* Get item in tree iter */
gtk_tree_model_get(model, iter, 0, &item, -1);
if (item == NULL) return FALSE;
/* Normalize string */
str_normalized = g_utf8_normalize(item, -1, G_NORMALIZE_ALL);
str_case_normalized = g_utf8_casefold(str_normalized, -1);
AV_DBG("%s: key=%s, string=%s\n", __func__, key, str_case_normalized);
/* Match string */
key_len = g_utf8_strlen(key, -1);
if (!strncmp(key, str_case_normalized, key_len)) result = TRUE;
g_free(str_normalized);
g_free(str_case_normalized);
g_free(item);
AV_DBG("%s: x\n", __func__);
return result;
}
/**
@brief copy a liststore or treestore
This is for when reffing is not enough e.g. need independent sorting in
attached views. Pointers to data are simply copied, so if the "source" data will
be cleared before fhe new store, then all such data must be replicated or otherwise
preserved by code elsewhere which understands what that data really is.
Officially, the new store will be unsorted, though in practice it will be the
same as the old store.
@param model treemodel of the store being copied
@param treetype TRUE for treestore, FALSE for liststore
@param newstore store for pointer to new store
@a return
*/
void e2_tree_store_copy (GtkTreeModel *model, gboolean treetype, gpointer *newstore)
{
GtkTreeIter src;
gint i, ncols = gtk_tree_model_get_n_columns (model);
gint colnums[ncols];
GType types[ncols];
GValue values[ncols];
for (i = 0; i < ncols; i++)
{
colnums[i] = i;
types[i] = gtk_tree_model_get_column_type (model, i);
memset (&values[i], 0, sizeof (GValue));
}
if (treetype)
{
GtkTreeStore *newtstore = gtk_tree_store_newv (ncols, types);
if (gtk_tree_model_get_iter_first (model, &src))
_e2_tree_copy_descendants (model, NULL, newtstore, NULL,
ncols, colnums, types, values);
*newstore = newtstore;
}
else
{
GtkListStore *newlstore = gtk_list_store_newv (ncols, types);
if (gtk_tree_model_get_iter_first (model, &src))
{
GtkTreeIter dest;
do
{
for (i = 0; i < ncols; i++)
gtk_tree_model_get_value (model, &src, i, &values[i]);
gtk_list_store_insert_with_valuesv (newlstore, &dest, -1, colnums, values, ncols);
for (i = 0; i < ncols; i++)
g_value_unset (&values[i]);
} while (gtk_tree_model_iter_next (model, &src));
}
*newstore = newlstore;
}
}
/* Process each row for a GtkTreeModel */
static gboolean
output_foreach (GtkTreeModel * model, GtkTreePath * path,
GtkTreeIter * iter, gpointer data)
{
gint columns;
gint j;
GType type;
GString *result = (GString *) data;
columns = gtk_tree_model_get_n_columns (model);
/* Get values from each colum */
for (j = 0; j < columns; j++) {
GValue value = G_VALUE_INIT;
gchar *svalue;
gint ivalue;
type = gtk_tree_model_get_column_type (model, j);
switch (type) {
case G_TYPE_INT:
gtk_tree_model_get_value (model, iter, j, &value);
ivalue = g_value_get_int (&value);
g_value_unset (&value);
g_string_append_printf (result, "%d", ivalue);
break;
case G_TYPE_STRING:
gtk_tree_model_get_value (model, iter, j, &value);
svalue = g_value_dup_string (&value);
g_value_unset (&value);
g_string_append_printf (result, "%s", svalue);
g_free (svalue);
break;
}
if (j == columns - 1) {
g_string_append_printf (result, "\n");
} else {
g_string_append_printf (result, "\t");
}
}
return FALSE;
}
/* Create a deep copy of SRC */
GtkListStore *
clone_list_store (const GtkListStore *src)
{
GtkTreeIter src_iter;
gboolean ok;
gint i;
const gint n_cols = gtk_tree_model_get_n_columns (GTK_TREE_MODEL (src));
GType *types = g_malloc (sizeof (*types) * n_cols);
int row = 0;
GtkListStore *dest;
for (i = 0 ; i < n_cols; ++i )
types[i] = gtk_tree_model_get_column_type (GTK_TREE_MODEL (src), i);
dest = gtk_list_store_newv (n_cols, types);
for (ok = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (src),
&src_iter);
ok;
ok = gtk_tree_model_iter_next (GTK_TREE_MODEL (src), &src_iter))
{
GtkTreeIter dest_iter;
gtk_list_store_append (dest, &dest_iter);
for (i = 0 ; i < n_cols; ++i )
{
GValue val = {0};
gtk_tree_model_get_value (GTK_TREE_MODEL (src), &src_iter, i, &val);
gtk_list_store_set_value (dest, &dest_iter, i, &val);
g_value_unset (&val);
}
row++;
}
g_free (types);
return dest;
}
static VALUE
rg_set_value(VALUE self, VALUE column, VALUE value)
{
GtkTreeIter* iter = _SELF(self);
GtkTreeModel* model = (GtkTreeModel*)iter->user_data3;
VALUE obj = rb_hash_aref(treeiter_set_value_table, INT2NUM(G_TYPE_FROM_INSTANCE(model)));
rbgtkiter_set_value_func func;
GType gtype = gtk_tree_model_get_column_type(model, NUM2INT(column));
GValue gval = G_VALUE_INIT;
if (NIL_P(obj))
rb_raise(rb_eTypeError, "Gtk::TreeModel is invalid.");
Data_Get_Struct(obj, void, func);
g_value_init(&gval, gtype);
rbgobj_rvalue_to_gvalue(value, &gval);
func(model, iter, NUM2INT(column), &gval);
g_value_unset(&gval);
return self;
}
static VALUE
lstore_insert_body(VALUE value)
{
struct lstore_insert_args *args = (struct lstore_insert_args *)value;
GtkTreeModel *model = GTK_TREE_MODEL(args->store);
for (args->i = 0; args->i < args->n; args->i++) {
VALUE ary = rb_ary_to_ary(RARRAY_PTR(args->ary)[args->i]);
args->columns[args->i] = NUM2INT(RARRAY_PTR(ary)[1]);
g_value_init(&args->values[args->i],
gtk_tree_model_get_column_type(model, args->columns[args->i]));
rbgobj_rvalue_to_gvalue(RARRAY_PTR(ary)[0], &args->values[args->i]);
}
gtk_list_store_insert_with_valuesv(args->store,
&args->iter,
args->position,
args->columns,
args->values,
args->n);
return Qnil;
}
/**
@brief try to find tree iter in @a model, at or after @a iter, which contains string @a search
This is a wrapper for the real search function. It performs several checks
The scan traverses @a model checking each iter and any children, depth-first
@param model treemodel to be interrogated
@param column index of the column in @a model to scan
@param search the string to be searched for
@param iter pointer to treeiter for model interrogation (start and match)
@param with_children TRUE if matched iter must have child(ren)
@return TRUE if the string was found
*/
gboolean e2_tree_find_iter_from_str (GtkTreeModel *model, gint column,
const gchar *search, GtkTreeIter *iter, gboolean with_children)
{
if (model == NULL)
return FALSE;
gint num_columns = gtk_tree_model_get_n_columns (model);
if (column > (num_columns - 1))
{
printd (WARN, "bad call of e2_tree_find_iter_from_str");
printd (WARN, "requesting column %d of %d columns", column + 1, num_columns);
return FALSE;
}
if (gtk_tree_model_get_column_type (model, column) != G_TYPE_STRING)
{
printd (WARN, "bad call of e2_tree_find_iter_from_str");
printd (WARN, "column %d is not of type string", column + 1);
return FALSE;
}
if (gtk_tree_model_get_iter_first (model, iter))
return e2_tree_find_iter_from_str_simple (model, column, search,
iter, with_children);
return FALSE;
}
int
_pygtk_tree_model_set_row(GtkTreeModel *model, GtkTreeIter *iter,
PyObject *items)
{
gint n_columns, i;
GtkTreeModel *child;
GtkTreeIter citer;
if (!GTK_IS_LIST_STORE(model) && !GTK_IS_TREE_STORE(model) &&
!GTK_IS_TREE_MODEL_SORT(model) && !GTK_IS_TREE_MODEL_FILTER(model)) {
PyErr_SetString(PyExc_TypeError,
"cannot set cells in this tree model");
return -1;
}
if (GTK_IS_TREE_MODEL_SORT(model)) {
child = gtk_tree_model_sort_get_model(GTK_TREE_MODEL_SORT(model));
gtk_tree_model_sort_convert_iter_to_child_iter(
GTK_TREE_MODEL_SORT(model), &citer, iter);
return _pygtk_tree_model_set_row(child, &citer, items);
}
if (GTK_IS_TREE_MODEL_FILTER(model)) {
child = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
gtk_tree_model_filter_convert_iter_to_child_iter(
GTK_TREE_MODEL_FILTER(model), &citer, iter);
return _pygtk_tree_model_set_row(child, &citer, items);
}
if (!PySequence_Check(items)) {
PyErr_SetString(PyExc_TypeError, "expecting a sequence");
return -1;
}
n_columns = gtk_tree_model_get_n_columns(model);
if (PySequence_Length(items) != n_columns) {
PyErr_SetString(PyExc_ValueError, "row sequence has wrong length");
return -1;
}
for (i = 0; i < n_columns; i++) {
GValue value = { 0, };
PyObject *item;
item = PySequence_GetItem(items, i);
if (!item)
return -1;
g_value_init(&value, gtk_tree_model_get_column_type(model, i));
if (pyg_value_from_pyobject(&value, item)) {
Py_DECREF(item);
PyErr_SetString(PyExc_TypeError,
"value is of wrong type for this column");
return -1;
}
if (GTK_IS_LIST_STORE(model))
gtk_list_store_set_value(GTK_LIST_STORE(model), iter, i, &value);
else if (GTK_IS_TREE_STORE(model))
gtk_tree_store_set_value(GTK_TREE_STORE(model), iter, i, &value);
g_value_unset(&value);
Py_DECREF(item);
}
return 0;
}
static GType
gsslrtma_get_column_type(GtkTreeModel *tree_model, gint index)
{
return gtk_tree_model_get_column_type(GTK_TREE_MODEL(GNC_SX_SLR_TREE_MODEL_ADAPTER(tree_model)->real), index);
}
lua_pushnil(L);
return api->call_byname(L, thismodule, "gtk_tree_model_get_value");
}
/**
* Simplify setting an item in a list store: determine the required GValue
* type, then try to fill the gvalue and set the value with that.
*/
static int l_gtk_list_store_set_value(lua_State *L)
{
OBJECT_ARG(store, GtkListStore, *, 1);
OBJECT_ARG(iter, GtkTreeIter, *, 2);
int column = luaL_checkinteger(L, 3);
GType t = gtk_tree_model_get_column_type((GtkTreeModel*) store, column);
GValue gvalue = {0};
api->lua_to_gvalue_cast(L, 4, &gvalue, t);
gtk_list_store_set_value(store, iter, column, &gvalue);
g_value_unset(&gvalue);
return 0;
}
// avoid the warning about superfluous arguments if given as callback
static int l_gtk_main_quit(lua_State *L)
{
lua_settop(L, 0);
return api->call_byname(L, &modinfo_gtk, "gtk_main_quit");
/**
* draw a line of a model
*
* \param context the GtkPrintContext
* \param line_position the position to insert the titles
* \param
*
* \return the new line_position
* */
static gint print_tree_view_list_draw_row ( GtkPrintContext *context,
GtkTreeView *tree_view,
gint line_position )
{
GtkTreeModel *model;
GtkTreeIter iter;
gint column = 0;
GList *list_tmp;
model = gtk_tree_view_get_model ( tree_view );
if ( !gtk_tree_model_get_iter ( model, &iter, tree_path_to_print ) )
return line_position;
if ( nbre_lines_col_data == 1 )
{
list_tmp = gtk_tree_view_get_columns ( tree_view );
while ( list_tmp )
{
GtkTreeViewColumn *col;
gchar *text;
gint column_position;
gint col_num_model;
GType col_type_model;
col = list_tmp -> data;
col_num_model = GPOINTER_TO_INT ( g_object_get_data ( G_OBJECT ( col ), "num_col_model" ) );
col_type_model = gtk_tree_model_get_column_type ( model, col_num_model );
column_position = columns_position[column];
/* get the text */
if ( col_type_model == G_TYPE_STRING )
gtk_tree_model_get ( model, &iter, col_num_model, &text, -1 );
else if ( col_type_model == G_TYPE_INT )
{
gint number;
gtk_tree_model_get ( model, &iter, col_num_model, &number, -1 );
text = utils_str_itoa ( number );
}
else
text = NULL;
if ( !text )
{
/* draw first the column */
column_position = print_tree_view_list_draw_column ( column_position, line_position );
list_tmp = list_tmp -> next;
column++;
continue;
}
print_tree_view_list_draw_cell ( context, line_position, column_position, column, text );
list_tmp = list_tmp -> next;
column++;
g_free ( text );
}
/* go to the next row */
line_position = line_position + size_row;
}
else
{
gchar **tab;
gchar *str_tmp;
gint i = 0;
for ( i = 0; i < nbre_lines_col_data; i ++ )
{
/* draw the last column */
print_tree_view_list_draw_column ( page_width, line_position );
list_tmp = gtk_tree_view_get_columns ( tree_view );
while ( list_tmp )
{
GtkTreeViewColumn *col;
gchar *text;
gint column_position;
gint col_num_model;
GType col_type_model;
col = ( GtkTreeViewColumn * ) list_tmp -> data;
col_num_model = GPOINTER_TO_INT ( g_object_get_data ( G_OBJECT ( col ), "num_col_model" ) );
col_type_model = gtk_tree_model_get_column_type ( model, col_num_model );
column_position = columns_position[column];
/* get the text */
if ( col_type_model == G_TYPE_STRING )
gtk_tree_model_get ( model, &iter, col_num_model, &text, -1 );
else if ( col_type_model == G_TYPE_INT )
{
gint number;
gtk_tree_model_get ( model, &iter, col_num_model, &number, -1 );
text = utils_str_itoa ( number );
}
else
text = NULL;
if ( text == NULL || strlen ( text ) == 0 )
{
print_tree_view_list_draw_column ( column_position, line_position );
list_tmp = list_tmp -> next;
column++;
continue;
}
str_tmp = gsb_string_uniform_new_line ( text, strlen ( text ) );
if ( str_tmp == NULL )
{
if ( i == 0 )
print_tree_view_list_draw_cell ( context, line_position, column_position, column, text );
else
print_tree_view_list_draw_column ( column_position, line_position );
list_tmp = list_tmp -> next;
column++;
continue;
}
tab = g_strsplit ( str_tmp, "\n", 0 );
if ( tab[i] && strlen ( tab[i] ) )
print_tree_view_list_draw_cell ( context, line_position, column_position, column, tab[i] );
else
print_tree_view_list_draw_column ( column_position, line_position );
list_tmp = list_tmp -> next;
column++;
g_strfreev ( tab );
g_free ( str_tmp );
}
line_position = line_position + size_row + gsb_data_print_config_get_draw_lines ( );
column = 0;
}
}
return line_position;
}
static VALUE
rg_get_column_type(VALUE self, VALUE index)
{
return GTYPE2CLASS(gtk_tree_model_get_column_type(_SELF(self),
NUM2INT(index)));
}
static VALUE
rg_insert(int argc, VALUE *argv, VALUE self)
{
VALUE parent, position, values, ret;
GtkTreeIter iter;
GtkTreeStore* model = _SELF(self);
rb_scan_args(argc, argv, "21", &parent, &position, &values);
if (NIL_P(values)){
gtk_tree_store_insert(model, &iter,
NIL_P(parent) ? NULL : RVAL2GTKTREEITER(parent),
NUM2INT(position));
iter.user_data3 = model;
ret = GTKTREEITER2RVAL(&iter);
G_CHILD_ADD(self, ret);
} else {
#if GTK_CHECK_VERSION(2,10,0)
gint *c_columns;
GValue *c_values;
long size, i;
size = NUM2INT(rb_funcall(values, rb_intern("size"), 0));
c_columns = ALLOCA_N(gint, size);
c_values = ALLOCA_N(GValue, size);
if(TYPE(values)==T_ARRAY) {
for(i=0; i<size; i++) {
GType gtype;
GValue gval = G_VALUE_INIT;
c_columns[i] = i;
gtype = gtk_tree_model_get_column_type(GTK_TREE_MODEL(RVAL2GOBJ(self)),
c_columns[i]);
g_value_init(&gval, gtype);
rbgobj_rvalue_to_gvalue(rb_ary_shift(values), &gval);
c_values[i] = gval;
}
} else if(TYPE(values)==T_HASH) {
VALUE r_columns;
r_columns = rb_funcall(values, rb_intern("keys"), 0);
for(i=0; i<size; i++) {
GType gtype;
GValue gval = G_VALUE_INIT;
c_columns[i] = NUM2INT (rb_ary_entry(r_columns, i));
gtype = gtk_tree_model_get_column_type(GTK_TREE_MODEL(RVAL2GOBJ(self)),
c_columns[i]);
g_value_init(&gval, gtype);
rbgobj_rvalue_to_gvalue(rb_hash_aref(values, INT2NUM(c_columns[i])), &gval);
c_values[i] = gval;
}
} else {
rb_raise(rb_eArgError, "values must be of type Hash or Array");
}
gtk_tree_store_insert_with_valuesv(model, &iter,
NIL_P(parent) ? NULL : RVAL2GTKTREEITER(parent),
NUM2INT(position),
c_columns,
c_values,
size);
iter.user_data3 = model;
ret = GTKTREEITER2RVAL(&iter);
G_CHILD_ADD(self, ret);
for(i=0; i<size; i++) {
G_CHILD_ADD(ret, rbgobj_gvalue_to_rvalue(&(c_values[i])));
g_value_unset(&(c_values[i]));
}
#else
rb_warn("Gtk::TreeStore#insert(parent, position, values) requires GTK+-2.10.0 or later");
gtk_tree_store_insert(model, &iter,
NIL_P(parent) ? NULL : RVAL2GTKTREEITER(parent),
NUM2INT(position));
iter.user_data3 = model;
ret = GTKTREEITER2RVAL(&iter);
G_CHILD_ADD(self, ret);
#endif
}
return ret;
}
/*
* Set a column in the map provider table to a new value and mirror the changes
* in the key file. If value is NULL, restore the default value.
*/
void
ph_config_set_map_provider(GtkTreeIter *iter,
guint row,
gint column,
const GValue *value)
{
gchar *name;
gchar *group;
const gchar *key;
g_return_if_fail(ph_config != NULL);
g_return_if_fail(iter != NULL);
g_return_if_fail(column >= 0 && column < PH_MAP_PROVIDER_COLUMN_COUNT);
if (ph_config->map_providers == NULL)
(void) ph_config_get_map_providers();
g_return_if_fail(ph_config->map_providers != NULL);
gtk_tree_model_get(GTK_TREE_MODEL(ph_config->map_providers), iter,
PH_MAP_PROVIDER_COLUMN_NAME, &name, -1);
group = ph_config_get_map_provider_group(name);
key = ph_config_get_map_provider_key(column);
if (value == NULL && row < G_N_ELEMENTS(ph_config_default_map_providers)) {
/* restore default value for built-in provider */
ph_map_provider_to_list_single(&ph_config_default_map_providers[row],
ph_config->map_providers, iter, column);
(void) g_key_file_remove_key(ph_config->key_file, group, key, NULL);
}
else {
GValue target = { 0 };
GType target_type;
target_type = gtk_tree_model_get_column_type(
GTK_TREE_MODEL(ph_config->map_providers), column);
g_value_init(&target, target_type);
if (value == NULL) {
/* restore default value for another provider */
switch (column) {
case PH_MAP_PROVIDER_COLUMN_URL:
g_value_set_static_string(&target, "");
break;
case PH_MAP_PROVIDER_COLUMN_TILE_SIZE:
g_value_set_uint(&target, 256);
break;
case PH_MAP_PROVIDER_COLUMN_ZOOM_MIN:
g_value_set_uint(&target, 0);
break;
case PH_MAP_PROVIDER_COLUMN_ZOOM_MAX:
g_value_set_uint(&target, 18);
break;
case PH_MAP_PROVIDER_COLUMN_ZOOM_DETAIL:
g_value_set_uint(&target, 14);
break;
default:
g_warn_if_reached();
}
}
else
/* actually set to a new value */
g_value_transform(value, &target);
gtk_list_store_set_value(ph_config->map_providers, iter,
column, &target);
ph_config_set_value(group, key, &target);
g_value_unset(&target);
}
g_free(name);
g_free(group);
}
static int
ephy_node_view_sort_func (GtkTreeModel *model,
GtkTreeIter *a,
GtkTreeIter *b,
EphyNodeView *view)
{
GValue a_value = {0, };
GValue b_value = {0, };
int p_column, column, retval = 0;
GtkSortType sort_type;
g_return_val_if_fail (model != NULL, 0);
g_return_val_if_fail (view != NULL, 0);
p_column = view->priv->priority_column;
column = view->priv->sort_column;
sort_type = view->priv->sort_type;
if (p_column >= 0)
{
gtk_tree_model_get_value (model, a, p_column, &a_value);
gtk_tree_model_get_value (model, b, p_column, &b_value);
if (g_value_get_int (&a_value) < g_value_get_int (&b_value))
{
retval = -1;
}
else if (g_value_get_int (&a_value) == g_value_get_int (&b_value))
{
retval = 0;
}
else
{
retval = 1;
}
g_value_unset (&a_value);
g_value_unset (&b_value);
}
if (retval == 0)
{
GType type;
type = gtk_tree_model_get_column_type (model, column);
gtk_tree_model_get_value (model, a, column, &a_value);
gtk_tree_model_get_value (model, b, column, &b_value);
switch (G_TYPE_FUNDAMENTAL (type))
{
case G_TYPE_STRING:
retval = compare_string_values (&a_value, &b_value);
break;
case G_TYPE_INT:
if (g_value_get_int (&a_value) < g_value_get_int (&b_value))
{
retval = -1;
}
else if (g_value_get_int (&a_value) == g_value_get_int (&b_value))
{
retval = 0;
}
else
{
retval = 1;
}
break;
case G_TYPE_BOOLEAN:
if (g_value_get_boolean (&a_value) < g_value_get_boolean (&b_value))
{
retval = -1;
}
else if (g_value_get_boolean (&a_value) == g_value_get_boolean (&b_value))
{
retval = 0;
}
else
{
retval = 1;
}
break;
default:
g_warning ("Attempting to sort on invalid type %s\n", g_type_name (type));
break;
}
g_value_unset (&a_value);
g_value_unset (&b_value);
}
if (sort_type == GTK_SORT_DESCENDING)
{
if (retval > 0)
{
retval = -1;
}
else if (retval < 0)
{
retval = 1;
}
}
return retval;
}
static gboolean
on_data_view_edited( PgmDataView *view, gint row, gint column, gchar *new_text, gpointer data )
{
PgmTableView *table_view = PGM_TABLE_VIEW( data );
GtkTreePath *path;
GtkTreeIter iter;
GValue value = {0};
GValue tmp_value = {0};
/*gchar *text;*/
gint col;
gchar *column_name;
GString *query_str;
gboolean need_and = FALSE;
PgmQuery *query;
GType column_type;
/*if( new_text[ 0 ] == 0 )
return FALSE;*/
g_value_init( &tmp_value, G_TYPE_STRING );
path = gtk_tree_path_new();
gtk_tree_path_append_index( path, row );
gtk_tree_model_get_iter( table_view->data_store, &iter, path );
gtk_tree_model_get_value( table_view->data_store, &iter, column, &value );
g_value_transform( &value, &tmp_value );
/*text = g_strdup_value_contents( &value );*/
if( g_strcmp0( g_value_get_string( &tmp_value ), new_text ) == 0 )
{
/*g_free( text );*/
return FALSE;
}
column_name = pgm_data_store_get_column_title( PGM_DATA_STORE( table_view->data_store ), column );
column_type = gtk_tree_model_get_column_type( table_view->data_store, column );
query_str = g_string_new( NULL );
if( pgm_table_view_is_string_type( column_type ) && new_text[ 0 ] != 0 )
{
g_string_printf( query_str, "update %s.%s set %s = '%s' where ",
table_view->schema_name,
table_view->table_name,
column_name,
new_text );
}
else
{
g_string_printf( query_str, "update %s.%s set %s = %s where ",
table_view->schema_name,
table_view->table_name,
column_name,
new_text && new_text[0] != 0 ? new_text : "null" );
}
for( col = 0; col < gtk_tree_model_get_n_columns( table_view->data_store ); col++ )
{
GValue tmp_val = {0};
GValue tmp_str_val = {0};
const gchar *tmp_val_str;
/*if( col == column )
continue;*/
if( need_and )
g_string_append( query_str, " and " );
g_value_init( &tmp_str_val, G_TYPE_STRING );
gtk_tree_model_get_value( table_view->data_store, &iter, col, &tmp_val );
/*tmp_val_str = g_strdup_value_contents( &tmp_val );*/
g_value_transform( &tmp_val, &tmp_str_val );
tmp_val_str = g_value_get_string( &tmp_str_val );
column_name = pgm_data_store_get_column_title( PGM_DATA_STORE( table_view->data_store ), col );
g_string_append( query_str, column_name );
column_type = gtk_tree_model_get_column_type( table_view->data_store, col );
if( g_strcmp0( tmp_val_str, "#<!-NULL->#" ) == 0 )
{
g_string_append( query_str, " is null " );
}
else
{
g_string_append( query_str, " = " );
if( pgm_table_view_is_string_type( column_type ) )
g_string_append( query_str, "'" );
g_string_append( query_str, tmp_val_str );
if( pgm_table_view_is_string_type( column_type ) )
g_string_append( query_str, "'" );
}
need_and = TRUE;
/*g_free( tmp_val_str );*/
}
g_debug( "update query = %s", query_str->str );
query = pgm_query_new( PGM_DATA_STORE( table_view->data_store )->query->database );
pgm_query_exec( query, "%s", query_str->str );
g_string_free( query_str, TRUE );
gtk_tree_path_free( path );
/*g_free( text );*/
pgm_data_store_update( PGM_DATA_STORE( table_view->data_store ) );
/*pgm_query_reexec( table_view->query );*/
return TRUE;
}
static gint
game_store_compare (GtkTreeModel *model,
GtkTreeIter *iter_a,
GtkTreeIter *iter_b,
gpointer user_data)
{
GType type;
GValue value_a;
GValue value_b;
gint column;
gint result;
memset (&value_a, 0, sizeof (GValue));
memset (&value_b, 0, sizeof (GValue));
column = GPOINTER_TO_INT (user_data);
type = gtk_tree_model_get_column_type (model, column);
gtk_tree_model_get_value (model, iter_a, column, &value_a);
gtk_tree_model_get_value (model, iter_b, column, &value_b);
if (type == G_TYPE_BOOLEAN)
{
gboolean va, vb;
va = g_value_get_boolean (&value_a);
vb = g_value_get_boolean (&value_b);
result = (va < vb) ? -1 : (va == vb) ? 0 : 1;
}
else if (type == G_TYPE_INT)
{
gint va, vb;
va = g_value_get_int (&value_a);
vb = g_value_get_int (&value_b);
result = (va < vb) ? -1 : (va == vb) ? 0 : 1;
}
else if (type == G_TYPE_STRING)
{
const gchar *va, *vb;
va = g_value_get_string (&value_a);
vb = g_value_get_string (&value_b);
if (va == NULL) va = "";
if (vb == NULL) vb = "";
result = strcmp (va, vb);
}
else if (type == GVA_TYPE_TIME)
{
gdouble diff;
time_t *va, *vb;
va = (time_t *) g_value_get_boxed (&value_a);
vb = (time_t *) g_value_get_boxed (&value_b);
diff = difftime (*va, *vb);
result = (diff < 0.0) ? -1 : (diff == 0.0) ? 0 : 1;
}
else
{
g_assert_not_reached ();
}
g_value_unset (&value_a);
g_value_unset (&value_b);
/* If the values are equal, compare the default sort column
* (being careful not to introduce infinite recursion!). */
if (result != 0 || column == DEFAULT_SORT_COLUMN)
return result;
user_data = GINT_TO_POINTER (DEFAULT_SORT_COLUMN);
return game_store_compare (model, iter_a, iter_b, user_data);
}
/**
* gconf_bridge_bind_string_list_store
* @bridge: A #GConfBridge
* @key: A GConf key to be bound
* @list_store: A #GtkListStore
*
* On calling this function single string column #GtkListStore @list_store
* will be kept synchronized with the GConf string list value pointed to by
* @key. On calling this function @list_store will be populated with the
* strings specified by the value of @key.
*
* Return value: The ID of the new binding.
**/
guint
gconf_bridge_bind_string_list_store (GConfBridge *bridge,
const char *key,
GtkListStore *list_store)
{
GtkTreeModel *tree_model;
gboolean have_one_column, is_string_column;
ListStoreBinding *binding;
GConfValue *val;
g_return_val_if_fail (bridge != NULL, 0);
g_return_val_if_fail (key != NULL, 0);
g_return_val_if_fail (GTK_IS_LIST_STORE (list_store), 0);
/* Check list store suitability */
tree_model = GTK_TREE_MODEL (list_store);
have_one_column = (gtk_tree_model_get_n_columns (tree_model) == 1);
is_string_column = (gtk_tree_model_get_column_type
(tree_model, 0) == G_TYPE_STRING);
if (G_UNLIKELY (!have_one_column || !is_string_column)) {
g_warning ("gconf_bridge_bind_string_list_store: Only "
"GtkListStores with exactly one string column are "
"supported.");
return 0;
}
/* Create new binding. */
binding = g_new (ListStoreBinding, 1);
binding->type = BINDING_LIST_STORE;
binding->id = new_id ();
binding->key = g_strdup (key);
binding->val_changes = NULL;
binding->list_store = list_store;
binding->sync_idle_id = 0;
/* Watch GConf key */
binding->val_notify_id =
gconf_client_notify_add (bridge->client, key,
list_store_binding_pref_changed,
binding, NULL, NULL);
/* Connect to ListStore change notifications */
binding->row_inserted_id =
g_signal_connect_swapped (list_store, "row-inserted",
G_CALLBACK
(list_store_binding_store_changed_cb),
binding);
binding->row_changed_id =
g_signal_connect_swapped (list_store, "row-inserted",
G_CALLBACK
(list_store_binding_store_changed_cb),
binding);
binding->row_deleted_id =
g_signal_connect_swapped (list_store, "row-inserted",
G_CALLBACK
(list_store_binding_store_changed_cb),
binding);
binding->rows_reordered_id =
g_signal_connect_swapped (list_store, "row-inserted",
G_CALLBACK
(list_store_binding_store_changed_cb),
binding);
/* Sync object to value from GConf, if set */
val = gconf_client_get (bridge->client, key, NULL);
if (val) {
list_store_binding_sync_pref_to_store (binding, val);
gconf_value_free (val);
}
/* Handle case where watched object gets destroyed */
g_object_weak_ref (G_OBJECT (list_store),
list_store_binding_store_destroyed, binding);
/* Insert binding */
g_hash_table_insert (bridge->bindings,
GUINT_TO_POINTER (binding->id), binding);
/* Done */
return binding->id;
}
gint
_gtk_tree_data_list_compare_func (GtkTreeModel *model,
GtkTreeIter *a,
GtkTreeIter *b,
gpointer user_data)
{
gint column = GPOINTER_TO_INT (user_data);
GType type = gtk_tree_model_get_column_type (model, column);
GValue a_value = G_VALUE_INIT;
GValue b_value = G_VALUE_INIT;
gint retval;
const gchar *stra, *strb;
gtk_tree_model_get_value (model, a, column, &a_value);
gtk_tree_model_get_value (model, b, column, &b_value);
switch (get_fundamental_type (type))
{
case G_TYPE_BOOLEAN:
if (g_value_get_boolean (&a_value) < g_value_get_boolean (&b_value))
retval = -1;
else if (g_value_get_boolean (&a_value) == g_value_get_boolean (&b_value))
retval = 0;
else
retval = 1;
break;
case G_TYPE_CHAR:
if (g_value_get_schar (&a_value) < g_value_get_schar (&b_value))
retval = -1;
else if (g_value_get_schar (&a_value) == g_value_get_schar (&b_value))
retval = 0;
else
retval = 1;
break;
case G_TYPE_UCHAR:
if (g_value_get_uchar (&a_value) < g_value_get_uchar (&b_value))
retval = -1;
else if (g_value_get_uchar (&a_value) == g_value_get_uchar (&b_value))
retval = 0;
else
retval = 1;
break;
case G_TYPE_INT:
if (g_value_get_int (&a_value) < g_value_get_int (&b_value))
retval = -1;
else if (g_value_get_int (&a_value) == g_value_get_int (&b_value))
retval = 0;
else
retval = 1;
break;
case G_TYPE_UINT:
if (g_value_get_uint (&a_value) < g_value_get_uint (&b_value))
retval = -1;
else if (g_value_get_uint (&a_value) == g_value_get_uint (&b_value))
retval = 0;
else
retval = 1;
break;
case G_TYPE_LONG:
if (g_value_get_long (&a_value) < g_value_get_long (&b_value))
retval = -1;
else if (g_value_get_long (&a_value) == g_value_get_long (&b_value))
retval = 0;
else
retval = 1;
break;
case G_TYPE_ULONG:
if (g_value_get_ulong (&a_value) < g_value_get_ulong (&b_value))
retval = -1;
else if (g_value_get_ulong (&a_value) == g_value_get_ulong (&b_value))
retval = 0;
else
retval = 1;
break;
case G_TYPE_INT64:
if (g_value_get_int64 (&a_value) < g_value_get_int64 (&b_value))
retval = -1;
else if (g_value_get_int64 (&a_value) == g_value_get_int64 (&b_value))
retval = 0;
else
retval = 1;
break;
case G_TYPE_UINT64:
if (g_value_get_uint64 (&a_value) < g_value_get_uint64 (&b_value))
retval = -1;
else if (g_value_get_uint64 (&a_value) == g_value_get_uint64 (&b_value))
retval = 0;
else
retval = 1;
break;
case G_TYPE_ENUM:
/* this is somewhat bogus. */
if (g_value_get_enum (&a_value) < g_value_get_enum (&b_value))
retval = -1;
else if (g_value_get_enum (&a_value) == g_value_get_enum (&b_value))
retval = 0;
else
retval = 1;
break;
case G_TYPE_FLAGS:
/* this is even more bogus. */
if (g_value_get_flags (&a_value) < g_value_get_flags (&b_value))
retval = -1;
else if (g_value_get_flags (&a_value) == g_value_get_flags (&b_value))
retval = 0;
else
retval = 1;
break;
case G_TYPE_FLOAT:
if (g_value_get_float (&a_value) < g_value_get_float (&b_value))
retval = -1;
else if (g_value_get_float (&a_value) == g_value_get_float (&b_value))
retval = 0;
else
retval = 1;
break;
case G_TYPE_DOUBLE:
if (g_value_get_double (&a_value) < g_value_get_double (&b_value))
retval = -1;
else if (g_value_get_double (&a_value) == g_value_get_double (&b_value))
retval = 0;
else
retval = 1;
break;
case G_TYPE_STRING:
stra = g_value_get_string (&a_value);
strb = g_value_get_string (&b_value);
if (stra == NULL) stra = "";
if (strb == NULL) strb = "";
retval = g_utf8_collate (stra, strb);
break;
case G_TYPE_VARIANT:
case G_TYPE_POINTER:
case G_TYPE_BOXED:
case G_TYPE_OBJECT:
default:
g_warning ("Attempting to sort on invalid type %s\n", g_type_name (type));
retval = FALSE;
break;
}
g_value_unset (&a_value);
g_value_unset (&b_value);
return retval;
}
static GtkWidget *
attribute_editor (GObject *object,
GParamSpec *spec,
GtkInspectorPropEditor *editor)
{
gpointer layout;
GtkCellArea *area;
GtkTreeModel *model = NULL;
gint col = -1;
GtkWidget *label;
GtkWidget *button;
GtkWidget *vbox;
GtkWidget *box;
GtkWidget *combo;
gchar *text;
gint i;
gboolean sensitive;
GtkCellRenderer *renderer;
GtkListStore *store;
GtkTreeIter iter;
layout = g_object_get_data (object, "gtk-inspector-cell-layout");
if (GTK_IS_CELL_LAYOUT (layout))
{
area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (layout));
col = gtk_cell_area_attribute_get_column (area,
GTK_CELL_RENDERER (object),
editor->priv->name);
model = gtk_cell_layout_get_model (GTK_CELL_LAYOUT (layout));
}
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
label = gtk_label_new (_("Attribute mapping"));
gtk_widget_set_margin_top (label, 10);
gtk_container_add (GTK_CONTAINER (vbox), label);
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
gtk_container_add (GTK_CONTAINER (box), gtk_label_new (_("Model:")));
text = g_strdup_printf (_("%p (%s)"), model, g_type_name (G_TYPE_FROM_INSTANCE (model)));
gtk_container_add (GTK_CONTAINER (box), gtk_label_new (text));
g_free (text);
button = gtk_button_new_with_label (_("Properties"));
g_object_set_data (G_OBJECT (button), "model", model);
g_signal_connect (button, "clicked", G_CALLBACK (model_properties), editor);
gtk_container_add (GTK_CONTAINER (box), button);
gtk_container_add (GTK_CONTAINER (vbox), box);
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
gtk_container_add (GTK_CONTAINER (box), gtk_label_new (_("Column:")));
store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_BOOLEAN);
combo = gtk_combo_box_new_with_model (GTK_TREE_MODEL (store));
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, FALSE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo), renderer,
"text", 0,
"sensitive", 1,
NULL);
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter, 0, _("None"), 1, TRUE, -1);
for (i = 0; i < gtk_tree_model_get_n_columns (model); i++)
{
text = g_strdup_printf ("%d", i);
sensitive = g_value_type_transformable (gtk_tree_model_get_column_type (model, i),
spec->value_type);
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter, 0, text, 1, sensitive, -1);
g_free (text);
}
gtk_combo_box_set_active (GTK_COMBO_BOX (combo), col + 1);
attribute_mapping_changed (GTK_COMBO_BOX (combo), editor);
g_signal_connect (combo, "changed",
G_CALLBACK (attribute_mapping_changed), editor);
gtk_container_add (GTK_CONTAINER (box), combo);
gtk_container_add (GTK_CONTAINER (vbox), box);
gtk_widget_show_all (vbox);
return vbox;
}
