static int read_listbox_content (GtkWidget *listbox, int (*should_stop)())
{
GtkTreeModel *model;
GtkTreeIter iter;
gchar *line;
gchar *tmpstr[3];
int i, err = 0;
model = gtk_tree_view_get_model(GTK_TREE_VIEW(listbox));
gtk_tree_model_get_iter_first(model, &iter);
err = speak_line("Contents of list box.\n");
while (!err) {
tmpstr[0] = tmpstr[1] = tmpstr[2] = NULL;
if (!GTK_IS_TREE_MODEL(model)) break;
gtk_tree_model_get(model, &iter,
0, &tmpstr[0],
1, &tmpstr[1],
2, &tmpstr[2],
-1);
line = g_strdup_printf("%s. %s. %s.\n",
((tmpstr[0] != NULL && *tmpstr[0] != '\0')?
tmpstr[0] : "empty column"),
((tmpstr[1] != NULL && *tmpstr[1] != '\0')?
tmpstr[1] : "empty column"),
((tmpstr[2] != NULL && *tmpstr[2] != '\0')?
tmpstr[2] : "empty column"));
err = speak_line(line);
for (i=0; i<3; i++) {
g_free(tmpstr[i]);
}
g_free(line);
if (!GTK_IS_TREE_MODEL(model) ||
!gtk_tree_model_iter_next(model, &iter) ||
should_stop()) {
break;
}
}
#ifdef G_OS_WIN32
speak_line(NULL);
#endif
return err;
}
int
clip_GTK_COMBOBOXENTRYNEWWITHMODEL(ClipMachine * ClipMachineMemory)
{
ClipVar *cv = _clip_spar(ClipMachineMemory, 1);
C_object *cmodel = _fetch_cobject(ClipMachineMemory, _clip_spar(ClipMachineMemory, 2));
gint text_column = _clip_parni(ClipMachineMemory, 3);
GtkWidget *wid = NULL;
C_widget *cwid;
CHECKOPT(1, MAP_type_of_ClipVarType);
CHECKCOBJ(cmodel, GTK_IS_TREE_MODEL(cmodel->object));
CHECKARG(3, NUMERIC_type_of_ClipVarType);
text_column--;
wid = gtk_combo_box_entry_new_with_model(GTK_TREE_MODEL(cmodel->object), text_column);
if (!wid)
goto err;
cwid = _register_widget(ClipMachineMemory, wid, cv);
_clip_mclone(ClipMachineMemory, RETPTR(ClipMachineMemory), &cwid->obj);
return 0;
err:
return 1;
}
/**
* gimp_int_store_lookup_by_value:
* @model: a #GimpIntStore
* @value: an integer value to lookup in the @model
* @iter: return location for the iter of the given @value
*
* Iterate over the @model looking for @value.
*
* Return value: %TRUE if the value has been located and @iter is
* valid, %FALSE otherwise.
*
* Since: 2.2
**/
gboolean
gimp_int_store_lookup_by_value (GtkTreeModel *model,
gint value,
GtkTreeIter *iter)
{
gboolean iter_valid;
g_return_val_if_fail (GTK_IS_TREE_MODEL (model), FALSE);
g_return_val_if_fail (iter != NULL, FALSE);
for (iter_valid = gtk_tree_model_get_iter_first (model, iter);
iter_valid;
iter_valid = gtk_tree_model_iter_next (model, iter))
{
gint this;
gtk_tree_model_get (model, iter,
GIMP_INT_STORE_VALUE, &this,
-1);
if (this == value)
break;
}
return iter_valid;
}
/**
* gtk_cell_view_set_model:
* @cell_view: a #GtkCellView
* @model: (allow-none): a #GtkTreeModel
*
* Sets the model for @cell_view. If @cell_view already has a model
* set, it will remove it before setting the new model. If @model is
* %NULL, then it will unset the old model.
*
* Since: 2.6
*/
void
gtk_cell_view_set_model (GtkCellView *cell_view,
GtkTreeModel *model)
{
g_return_if_fail (GTK_IS_CELL_VIEW (cell_view));
g_return_if_fail (model == NULL || GTK_IS_TREE_MODEL (model));
if (cell_view->priv->model)
{
g_signal_handler_disconnect (cell_view->priv->model,
cell_view->priv->row_changed_id);
cell_view->priv->row_changed_id = 0;
if (cell_view->priv->displayed_row)
gtk_tree_row_reference_free (cell_view->priv->displayed_row);
cell_view->priv->displayed_row = NULL;
g_object_unref (cell_view->priv->model);
}
cell_view->priv->model = model;
if (cell_view->priv->model)
{
g_object_ref (cell_view->priv->model);
cell_view->priv->row_changed_id =
g_signal_connect (cell_view->priv->model, "row-changed",
G_CALLBACK (row_changed_cb), cell_view);
}
}
static void
on_global_vars_text_changed (GtkCellRendererText *cell,
gchar *path_string,
gchar *new_text,
gpointer user_data)
{
GtkTreeModel *global_vars_model = NULL;
SnippetsDB *snippets_db = NULL;
GtkTreePath *path = NULL;
GtkTreeIter iter;
gchar *name = NULL;
/* Assertions */
g_return_if_fail (ANJUTA_IS_SNIPPETS_DB (user_data));
snippets_db = ANJUTA_SNIPPETS_DB (user_data);
global_vars_model = snippets_db_get_global_vars_model (snippets_db);
g_return_if_fail (GTK_IS_TREE_MODEL (global_vars_model));
/* Get the iter */
path = gtk_tree_path_new_from_string (path_string);
gtk_tree_model_get_iter (global_vars_model, &iter, path);
/* Get the current type and change it */
gtk_tree_model_get (global_vars_model, &iter,
GLOBAL_VARS_MODEL_COL_NAME, &name,
-1);
snippets_db_set_global_variable_value (snippets_db,
name,
new_text);
g_free (name);
/* Save the global variables */
snippets_db_save_global_vars (snippets_db);
}
gboolean
t_tree_model_find (GtkTreeModel *model, int col, GValue *value, GtkTreeIter *iter, TCompareFunc cmp)
{
gboolean has_next;
GValue iter_value = {0,};
gboolean equal_vals;
GError *error = NULL;
g_return_val_if_fail (GTK_IS_TREE_MODEL (model), FALSE);
g_return_val_if_fail (iter, FALSE);
g_return_val_if_fail (cmp, FALSE);
has_next = gtk_tree_model_get_iter_first (model, iter);
for (; has_next; has_next = gtk_tree_model_iter_next (model, iter)) {
gtk_tree_model_get_value (model, iter, col, &iter_value);
equal_vals = !cmp (&iter_value, value, &error);
g_value_unset (&iter_value);
if (error) {
g_error_free (error);
error = NULL;
} else if (equal_vals) {
/* no error occurred and values are equal */
return TRUE;
}
}
return FALSE;
}
void
time_bar_set_model (TimeBar * self,
GtkTreeModel* model)
{
g_return_if_fail (IS_TIME_BAR (self));
g_return_if_fail (!model || GTK_IS_TREE_MODEL (model));
g_return_if_fail (!model || (gtk_tree_model_get_flags (model) & GTK_TREE_MODEL_LIST_ONLY) != 0);
if (self->_private->model == model) {
return;
}
if (self->_private->model) {
g_object_unref (self->_private->model);
self->_private->model = NULL;
}
if (model) {
self->_private->model = g_object_ref (model);
}
display_set_model (DISPLAY (self->_private->display),
self->_private->model);
g_object_notify (G_OBJECT (self), "model");
}
void
snippet_vars_store_unload (SnippetVarsStore *vars_store)
{
SnippetVarsStorePrivate *priv = NULL;
GtkTreeModel *global_vars_model = NULL;
/* Assertions */
g_return_if_fail (ANJUTA_IS_SNIPPET_VARS_STORE (vars_store));
priv = ANJUTA_SNIPPET_VARS_STORE_GET_PRIVATE (vars_store);
/* If we don't have a snippet or a snippets-db we just return */
if (!ANJUTA_IS_SNIPPETS_DB (priv->snippets_db))
return;
global_vars_model = snippets_db_get_global_vars_model (priv->snippets_db);
g_return_if_fail (GTK_IS_TREE_MODEL (global_vars_model));
/* Disconnect the handlers */
g_signal_handler_disconnect (global_vars_model, priv->row_inserted_handler_id);
g_signal_handler_disconnect (global_vars_model, priv->row_changed_handler_id);
g_signal_handler_disconnect (global_vars_model, priv->row_deleted_handler_id);
priv->snippets_db = NULL;
priv->snippet = NULL;
/* This will clear the GtkListStore */
reload_vars_store (vars_store);
}
Glib::RefPtr<NatnTreeMdl> NatnTreeMdl::create(MProvider* aNatnProv)
{
NatnTreeMdl* nmdl = new NatnTreeMdl(aNatnProv);
Gtk::TreeModel* mdl = reinterpret_cast<Gtk::TreeModel*> (nmdl);
GtkTreeModel* treemdl = mdl->gobj();
bool ist = GTK_IS_TREE_MODEL(treemdl);
return Glib::RefPtr<NatnTreeMdl>(nmdl);
}
Glib::RefPtr<HierTreeMdl> HierTreeMdl::create(MEnv* aDesEnv)
{
HierTreeMdl* nmdl = new HierTreeMdl(aDesEnv);
Gtk::TreeModel* mdl = reinterpret_cast<Gtk::TreeModel*> (nmdl);
GtkTreeModel* treemdl = mdl->gobj();
bool ist = GTK_IS_TREE_MODEL(treemdl);
return Glib::RefPtr<HierTreeMdl>(nmdl);
}
static void
gctt_refresh_menu (GncCombott *combott, GtkTreeModel *model)
{
g_return_if_fail (GNC_IS_COMBOTT (combott));
g_return_if_fail (model == NULL || GTK_IS_TREE_MODEL (model));
gctt_rebuild_menu(combott, model);
}
gboolean
glade_gtk_treeview_depends (GladeWidgetAdaptor * adaptor,
GladeWidget * widget, GladeWidget * another)
{
if (GTK_IS_TREE_MODEL (glade_widget_get_object (another)))
return TRUE;
return GWA_GET_CLASS (GTK_TYPE_CONTAINER)->depends (adaptor, widget, another);
}
static void
gctt_refresh_menu (GncCombott *combott, GtkTreeModel *model)
{
GncCombottPrivate *priv;
g_return_if_fail (GNC_IS_COMBOTT (combott));
g_return_if_fail (model == NULL || GTK_IS_TREE_MODEL (model));
priv = GNC_COMBOTT_GET_PRIVATE (combott);
gctt_rebuild_menu(combott, model);
}
gchar *
empathy_contact_list_store_get_parent_group (GtkTreeModel *model,
GtkTreePath *path,
gboolean *path_is_group)
{
GtkTreeIter parent_iter, iter;
gchar *name = NULL;
gboolean is_group;
g_return_val_if_fail (GTK_IS_TREE_MODEL (model), NULL);
if (path_is_group) {
*path_is_group = FALSE;
}
if (!gtk_tree_model_get_iter (model, &iter, path)) {
return NULL;
}
gtk_tree_model_get (model, &iter,
EMPATHY_CONTACT_LIST_STORE_COL_IS_GROUP, &is_group,
EMPATHY_CONTACT_LIST_STORE_COL_NAME, &name,
-1);
if (!is_group) {
g_free (name);
name = NULL;
if (!gtk_tree_model_iter_parent (model, &parent_iter, &iter)) {
return NULL;
}
iter = parent_iter;
gtk_tree_model_get (model, &iter,
EMPATHY_CONTACT_LIST_STORE_COL_IS_GROUP, &is_group,
EMPATHY_CONTACT_LIST_STORE_COL_NAME, &name,
-1);
if (!is_group) {
g_free (name);
return NULL;
}
}
if (path_is_group) {
*path_is_group = TRUE;
}
return name;
}
gboolean
empathy_contact_list_store_row_separator_func (GtkTreeModel *model,
GtkTreeIter *iter,
gpointer data)
{
gboolean is_separator = FALSE;
g_return_val_if_fail (GTK_IS_TREE_MODEL (model), FALSE);
gtk_tree_model_get (model, iter,
EMPATHY_CONTACT_LIST_STORE_COL_IS_SEPARATOR, &is_separator,
-1);
return is_separator;
}
static void
add_global_variables (SnippetVarsStore *vars_store)
{
SnippetVarsStorePrivate *priv = NULL;
GtkTreeIter iter, iter_to_add;
gchar *cur_var_name = NULL;
GtkTreeModel *global_vars_model = NULL;
gchar *instant_value = NULL;
/* Assertions */
g_return_if_fail (ANJUTA_IS_SNIPPET_VARS_STORE (vars_store));
priv = ANJUTA_SNIPPET_VARS_STORE_GET_PRIVATE (vars_store);
global_vars_model = snippets_db_get_global_vars_model (priv->snippets_db);
g_return_if_fail (GTK_IS_TREE_MODEL (global_vars_model));
if (gtk_tree_model_get_iter_first (global_vars_model, &iter))
{
do
{
gtk_tree_model_get (global_vars_model, &iter,
GLOBAL_VARS_MODEL_COL_NAME, &cur_var_name,
-1);
/* If the snippet holds this global variable, it was already added to the
store.*/
if (snippet_has_variable (priv->snippet, cur_var_name))
{
g_free (cur_var_name);
continue;
}
instant_value = snippets_db_get_global_variable (priv->snippets_db, cur_var_name);
gtk_list_store_append (GTK_LIST_STORE (vars_store), &iter_to_add);
gtk_list_store_set (GTK_LIST_STORE (vars_store), &iter_to_add,
VARS_STORE_COL_NAME, cur_var_name,
VARS_STORE_COL_TYPE, SNIPPET_VAR_TYPE_GLOBAL,
VARS_STORE_COL_DEFAULT_VALUE, g_strdup (""),
VARS_STORE_COL_INSTANT_VALUE, instant_value,
VARS_STORE_COL_IN_SNIPPET, FALSE,
VARS_STORE_COL_UNDEFINED, FALSE,
-1);
g_free (cur_var_name);
g_free (instant_value);
} while (gtk_tree_model_iter_next (global_vars_model, &iter));
}
}
int
clip_GTK_COMBOBOXSETMODEL(ClipMachine * ClipMachineMemory)
{
C_widget *ccmb = _fetch_cw_arg(ClipMachineMemory);
C_object *cmodel = _fetch_cobject(ClipMachineMemory, _clip_spar(ClipMachineMemory, 2));
CHECKCWID(ccmb, GTK_IS_COMBO_BOX);
CHECKCOBJ(cmodel, GTK_IS_TREE_MODEL(cmodel->object));
gtk_combo_box_set_model(GTK_COMBO_BOX(ccmb->widget), GTK_TREE_MODEL(cmodel->object));
return 0;
err:
return 1;
}
int
clip_GTK_ENTRYCOMPLETIONSETMODEL(ClipMachine * ClipMachineMemory)
{
C_object *ccompletion = _fetch_co_arg(ClipMachineMemory);
C_object *cmodell = _fetch_cobject(ClipMachineMemory, _clip_spar(ClipMachineMemory, 2));
CHECKCOBJ(ccompletion, GTK_IS_ENTRY_COMPLETION(ccompletion->object));
CHECKCOBJ(cmodell, GTK_IS_TREE_MODEL(cmodell->object));
gtk_entry_completion_set_model(GTK_ENTRY_COMPLETION(ccompletion->object), GTK_TREE_MODEL(cmodell->object));
return 0;
err:
return 1;
}
static gboolean
totem_open_location_match (GtkEntryCompletion *completion, const gchar *key, GtkTreeIter *iter, gpointer user_data)
{
/* Substring-match key against URI */
char *uri, *match;
g_return_val_if_fail (GTK_IS_TREE_MODEL (user_data), FALSE);
g_return_val_if_fail (iter != NULL, FALSE);
g_return_val_if_fail (key != NULL, FALSE);
gtk_tree_model_get (user_data, iter, 0, &uri, -1);
g_return_val_if_fail (uri != NULL, FALSE);
match = strstr (uri, key);
g_free (uri);
return (match != NULL);
}
/**
* 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);
}
/* Get the model from a GtkTreeView and convert its content in
a GString. The columns are separated by '\t' and rows by '\n'.
The string returned must be freed.
*/
GString *
util_tree_model_to_string (GtkTreeView *treeview)
{
GtkTreeModel *model;
GString *result;
result = g_string_new ("");
model = gtk_tree_view_get_model (treeview);
if (!GTK_IS_TREE_MODEL (model)) {
return result;
}
gtk_tree_model_foreach (model, output_foreach,
(gpointer) result);
return result;
}
/**
* gtk_tree_set_row_drag_data:
* @selection_data: some #GtkSelectionData
* @tree_model: a #GtkTreeModel
* @path: a row in @tree_model
*
* Sets selection data of target type %GTK_TREE_MODEL_ROW. Normally used
* in a drag_data_get handler.
*
* Returns: %TRUE if the #GtkSelectionData had the proper target type to allow us to set a tree row
**/
gboolean
gtk_tree_set_row_drag_data (GtkSelectionData *selection_data,
GtkTreeModel *tree_model,
GtkTreePath *path)
{
TreeRowData *trd;
gchar *path_str;
gint len;
gint struct_size;
g_return_val_if_fail (selection_data != NULL, FALSE);
g_return_val_if_fail (GTK_IS_TREE_MODEL (tree_model), FALSE);
g_return_val_if_fail (path != NULL, FALSE);
if (gtk_selection_data_get_target (selection_data) != gdk_atom_intern_static_string ("GTK_TREE_MODEL_ROW"))
return FALSE;
path_str = gtk_tree_path_to_string (path);
len = strlen (path_str);
/* the old allocate-end-of-struct-to-hold-string trick */
struct_size = sizeof (TreeRowData) + len + 1 -
(sizeof (TreeRowData) - G_STRUCT_OFFSET (TreeRowData, path));
trd = g_malloc (struct_size);
strcpy (trd->path, path_str);
g_free (path_str);
trd->model = tree_model;
gtk_selection_data_set (selection_data,
gdk_atom_intern_static_string ("GTK_TREE_MODEL_ROW"),
8, /* bytes */
(void*)trd,
struct_size);
g_free (trd);
return TRUE;
}
/*! \brief Returns the name to use for the given page in the model.
* \par Function Description
* This function determines the text to be used to identify a
* specific page from the model of pages with unsaved changes.
*
* If <B>piter</B> is NULL, the name for the first page of the model
* is returned. Otherwise, it returns the name for the page defined
* by the pointed iterator.
*
* The returned value must be freed by caller.
*
* \param [in] model The tree model.
* \param [in] piter A pointer on a GtkTreeIter of model or NULL.
* \returns The name for the page.
*/
static gchar*
get_page_name (GtkTreeModel *model, GtkTreeIter *piter)
{
GtkTreeIter iter;
PAGE *page;
g_return_val_if_fail (GTK_IS_TREE_MODEL (model), NULL);
if (piter == NULL) {
gtk_tree_model_get_iter_first (model, &iter);
} else {
iter = *piter;
}
gtk_tree_model_get (model, &iter,
COLUMN_PAGE, &page,
-1);
g_assert (page != NULL);
return g_path_get_basename (s_page_get_filename (page));
}
int
clip_GTK_COMBOBOXNEWWITHMODEL(ClipMachine * cm)
{
ClipVar * cv = _clip_spar(cm, 1);
C_object *cmodel = _fetch_cobject(cm, _clip_spar(cm, 2));
GtkWidget *wid = NULL;
C_widget *cwid;
CHECKOPT(1,MAP_t);
CHECKCOBJ(cmodel, GTK_IS_TREE_MODEL(cmodel->object));
wid = gtk_combo_box_new_with_model(GTK_TREE_MODEL(cmodel->object));
if (!wid) goto err;
cwid = _register_widget(cm, wid, cv);
_clip_mclone(cm,RETPTR(cm),&cwid->obj);
return 0;
err:
return 1;
}
gboolean
empathy_contact_list_store_search_equal_func (GtkTreeModel *model,
gint column,
const gchar *key,
GtkTreeIter *iter,
gpointer search_data)
{
gchar *name, *name_folded;
gchar *key_folded;
gboolean ret;
g_return_val_if_fail (GTK_IS_TREE_MODEL (model), FALSE);
if (!key) {
return TRUE;
}
gtk_tree_model_get (model, iter,
EMPATHY_CONTACT_LIST_STORE_COL_NAME, &name,
-1);
if (!name) {
return TRUE;
}
name_folded = g_utf8_casefold (name, -1);
key_folded = g_utf8_casefold (key, -1);
if (name_folded && key_folded &&
strstr (name_folded, key_folded)) {
ret = FALSE;
} else {
ret = TRUE;
}
g_free (name);
g_free (name_folded);
g_free (key_folded);
return ret;
}
void
gtk_cell_view_set_model (GtkCellView *cell_view,
GtkTreeModel *model)
{
g_return_if_fail (GTK_IS_CELL_VIEW (cell_view));
g_return_if_fail (GTK_IS_TREE_MODEL (model));
if (cell_view->priv->model)
{
if (cell_view->priv->displayed_row)
gtk_tree_row_reference_free (cell_view->priv->displayed_row);
cell_view->priv->displayed_row = NULL;
g_object_unref (G_OBJECT (cell_view->priv->model));
cell_view->priv->model = NULL;
}
cell_view->priv->model = model;
if (cell_view->priv->model)
g_object_ref (G_OBJECT (cell_view->priv->model));
}
/**
* gtk_cell_view_set_displayed_row:
* @cell_view: a #GtkCellView
* @path: (allow-none): a #GtkTreePath or %NULL to unset.
*
* Sets the row of the model that is currently displayed
* by the #GtkCellView. If the path is unset, then the
* contents of the cellview "stick" at their last value;
* this is not normally a desired result, but may be
* a needed intermediate state if say, the model for
* the #GtkCellView becomes temporarily empty.
*
* Since: 2.6
**/
void
gtk_cell_view_set_displayed_row (GtkCellView *cell_view,
GtkTreePath *path)
{
g_return_if_fail (GTK_IS_CELL_VIEW (cell_view));
g_return_if_fail (GTK_IS_TREE_MODEL (cell_view->priv->model));
if (cell_view->priv->displayed_row)
gtk_tree_row_reference_free (cell_view->priv->displayed_row);
if (path)
{
cell_view->priv->displayed_row =
gtk_tree_row_reference_new (cell_view->priv->model, path);
}
else
cell_view->priv->displayed_row = NULL;
/* force resize and redraw */
gtk_widget_queue_resize (GTK_WIDGET (cell_view));
gtk_widget_queue_draw (GTK_WIDGET (cell_view));
}
static void
thunar_uca_chooser_exchange (ThunarUcaChooser *uca_chooser,
GtkTreeSelection *selection,
GtkTreeModel *model,
GtkTreeIter *iter_a,
GtkTreeIter *iter_b)
{
g_return_if_fail (THUNAR_UCA_IS_CHOOSER (uca_chooser));
g_return_if_fail (GTK_IS_TREE_SELECTION (selection));
g_return_if_fail (GTK_IS_TREE_MODEL (model));
g_return_if_fail (iter_a != NULL);
g_return_if_fail (iter_b != NULL);
/* perform the move */
thunar_uca_model_exchange (THUNAR_UCA_MODEL (model), iter_a, iter_b);
/* tell the chooser that the selection may have changed */
thunar_uca_chooser_selection_changed (uca_chooser, selection);
/* sync the model to persistent storage */
thunar_uca_chooser_save (uca_chooser, THUNAR_UCA_MODEL (model));
}
void gx_selector_set_model(GxSelector *selector, GtkTreeModel *model)
{
g_return_if_fail(GX_IS_SELECTOR(selector));
g_return_if_fail(model == NULL || GTK_IS_TREE_MODEL (model));
GxSelectorPrivate *priv = selector->priv;
if (model == selector->model)
return;
gx_selector_unset_model(selector);
int n = 0;
if (model != NULL) {
selector->model = model;
g_object_ref (selector->model);
n = gtk_tree_model_iter_n_children(model, NULL) - 1;
if (n < 0) {
n = 0;
}
}
gtk_adjustment_configure(gtk_range_get_adjustment(GTK_RANGE(selector)), 0.0, 0.0, n, 1.0, 1.0, 0.0);
priv->req_ok = FALSE;
gtk_widget_queue_resize(GTK_WIDGET(selector));
g_object_notify(G_OBJECT(selector), "model");
}
/* Helper function to set language values */
static void
populate_language (GObject *object)
{
GtkListStore *lang_model = mdm_lang_get_model ();
GtkTreeIter iter;
char *name, *untranslated, *lang_display_name, *locale_name;
gboolean valid;
valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (lang_model),
&iter);
while (valid)
{
gtk_tree_model_get (GTK_TREE_MODEL (lang_model), &iter,
TRANSLATED_NAME_COLUMN, &name,
UNTRANSLATED_NAME_COLUMN, &untranslated,
LOCALE_COLUMN, &locale_name, -1);
if (untranslated)
lang_display_name = g_strdup_printf ("%s (%s)", name, untranslated);
else
lang_display_name = g_strdup (name);
if (GTK_IS_COMBO_BOX (object))
gtk_combo_box_append_text (GTK_COMBO_BOX (object), lang_display_name);
else if (GTK_IS_TREE_MODEL (object))
{
GtkTreeIter loopiter;
GtkTreeModel *tm = GTK_TREE_MODEL (object);
gtk_list_store_append (GTK_LIST_STORE (tm), &loopiter);
gtk_list_store_set (GTK_LIST_STORE (tm), &loopiter,
GREETER_LIST_TEXT, lang_display_name,
GREETER_LIST_ID, locale_name,
-1);
}
valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (lang_model), &iter);
}
}
