static void add_item (int is_folder)
{
GtkTreeIter iter;
GtkTreeModel *model;
gftp2_bookmark *new_item;
GNode *new_node;
new_item = gftp2_bookmark_new ();
if (is_folder)
new_item->name = g_strdup ("(New folder)");
else
new_item->name = g_strdup ("(New bookmark)");
new_item->is_folder = is_folder;
new_node = g_node_new (new_item);
g_node_append (bookmark_root, new_node);
gtk_tree_store_append (GTK_TREE_STORE (editor->store), &iter, NULL);
gtk_tree_store_set (GTK_TREE_STORE (editor->store), &iter,
COLUMN_NAME, new_item->name,
COLUMN_ENTRY, new_node, -1);
editor->changed = 1;
gtk_widget_set_sensitive (GTK_WIDGET (editor->save_button), TRUE);
}
static gboolean update_node_name_func(GtkTreeModel *model, GtkTreePath *path,
GtkTreeIter *iter, gpointer data)
{
MimeInfo *partinfo;
gchar *part_name;
gtk_tree_model_get(model, iter, COL_MIME_INFO, &partinfo, -1);
g_return_val_if_fail(partinfo != NULL, FALSE);
part_name = get_part_name(partinfo);
gtk_tree_store_set(GTK_TREE_STORE(model), iter, COL_NAME, part_name,
-1);
return FALSE;
}
static void
on_commit_status_data_arrived (AnjutaCommand *command,
GitStatusPane *self)
{
GtkTreeStore *status_model;
GQueue *output;
status_model = GTK_TREE_STORE (gtk_builder_get_object (self->priv->builder,
"status_model"));
output = git_status_command_get_status_queue (GIT_STATUS_COMMAND (command));
add_status_items (output, status_model, &(self->priv->commit_iter),
STATUS_TYPE_COMMIT);
}
//удалить элемент списка
void del_signal(GtkWidget* b, gpointer data)
{
GtkTreeIter iter;
//список GtkTreeView
GtkTreeView *treeview = (GtkTreeView *)data;
GtkTreeModel *model = gtk_tree_view_get_model (treeview);
//получить выделенную ячейку и удалить её
GtkTreeSelection *selection = gtk_tree_view_get_selection (treeview);
if (gtk_tree_selection_get_selected (selection, NULL, &iter))
{
gtk_tree_store_remove (GTK_TREE_STORE (model), &iter);
}
}
orcaData orcaGtkIter::ex_push_child(orcaVM* vm, int n)/*{{{*/
{
if (n<1) vm->need_param();
GtkTreeIter iter;
gtk_tree_store_append(GTK_TREE_STORE(m_gp->store), &iter, &m_iter);
orcaList* lp = castobj<orcaList>(vm->get_param(0));
if (lp == NULL) {
throw orcaException(vm, "orca.type", "list type is required");
}
set_list_to_store(lp, m_gp->store, &iter, m_type);
return NIL;
}
static void
search_gui_clear_tree(search_t *search)
{
GtkTreeModel *model;
bool stopped;
stopped = search_gui_start_massive_update(search);
model = gtk_tree_view_get_model(GTK_TREE_VIEW(search->tree));
gtk_tree_model_foreach(model, prepare_remove_record, search);
gtk_tree_store_clear(GTK_TREE_STORE(model));
if (stopped)
search_gui_end_massive_update(search);
}
void
on_enc_action_remove_btn_clicked (GtkButton *button, gpointer user_data)
{
GtkTreeModel *model;
GtkTreeSelection *selection;
GtkTreeIter iter;
gpointer type;
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (liferea_dialog_lookup (prefdialog->priv->dialog, "enc_action_view")));
if (gtk_tree_selection_get_selected (selection, &model, &iter)) {
gtk_tree_model_get (model, &iter, FTS_PTR, &type, -1);
gtk_tree_store_remove (GTK_TREE_STORE (model), &iter);
enclosure_mime_type_remove (type);
}
}
static void
ghb_clear_subtitle_list_ui(GtkBuilder *builder)
{
GtkTreeView *tv;
GtkTreeStore *ts;
GtkTreeSelection *tsel;
tv = GTK_TREE_VIEW(GHB_WIDGET(builder, "subtitle_list"));
ts = GTK_TREE_STORE(gtk_tree_view_get_model(tv));
// Clear tree selection so that updates are not triggered
// that cause a recursive attempt to clear the tree selection (crasher)
tsel = gtk_tree_view_get_selection(tv);
gtk_tree_selection_unselect_all(tsel);
gtk_tree_store_clear(ts);
}
void
gftpui_add_file_to_transfer (gftp_transfer * tdata, GList * curfle)
{
char * status;
gftp_file * fle;
GtkTreeIter iter;
fle = curfle->data;
if (fle->transfer_action == GFTP_TRANS_ACTION_SKIP)
status = _("Skipped");
else
status = _("Waiting...");
g_print("%s\n", gftpui_gtk_get_utf8_file_pos (fle));
GtkTreeModel * model = gtk_tree_view_get_model(GTK_TREE_VIEW (dlwdw));
gtk_tree_store_append (GTK_TREE_STORE(model), &iter, tdata->user_data);
gtk_tree_store_set(GTK_TREE_STORE(model), &iter,
0, gftpui_gtk_get_utf8_file_pos (fle),
1, status,
2, tdata,
3, curfle,
-1);
}
static void
edited (GtkCellRendererText *cell,
gchar *path_string,
gchar *new_text,
gpointer data)
{
GtkTreeModel *model = GTK_TREE_MODEL (data);
GtkTreeIter iter;
GtkTreePath *path = gtk_tree_path_new_from_string (path_string);
gtk_tree_model_get_iter (model, &iter, path);
gtk_tree_store_set (GTK_TREE_STORE (model), &iter, STRING_COLUMN, new_text, -1);
gtk_tree_path_free (path);
}
/* Called when a cell has completed being edited */
static void
keyserver_cell_edited (GtkCellRendererText *cell, gchar *path, gchar *text,
GtkTreeModel *model)
{
GtkTreeIter iter;
if (!seahorse_servers_is_valid_uri (text)) {
seahorse_util_show_error (NULL, _("Not a valid Key Server address."),
_("For help contact your system administrator or the administrator of the key server." ));
return;
}
g_warn_if_fail (gtk_tree_model_get_iter_from_string (model, &iter, path));
gtk_tree_store_set (GTK_TREE_STORE (model), &iter, KEYSERVER_COLUMN, text, -1);
}
/*Agrega las familias al cuado de familias */
void add_family_to_list(GtkWidget* widget,Familia* list){
Familia *first = list;
GtkTreeStore *store;
store = GTK_TREE_STORE(gtk_tree_view_get_model (GTK_TREE_VIEW(widget)));
GtkTreeIter iter;
while(list != NULL){
gtk_tree_store_append (store, &iter, NULL);
gtk_tree_store_set (store, &iter,
DATO, list->nomb_Familia,
PUNTERO, list,
-1);
list = list->sig;
}
list = first;
}
static void
ref_count_cleanup (void)
{
GtkTreeIter grandparent1, grandparent2, parent1, parent2;
GtkTreeIter iter_parent1, iter_parent2;
GtkTreeModel *model;
GtkTreeModelRefCount *ref_model;
GtkTreeModel *sort_model;
GtkWidget *tree_view;
model = gtk_tree_model_ref_count_new ();
ref_model = GTK_TREE_MODEL_REF_COUNT (model);
/* + grandparent1
* + grandparent2
* + parent1
* + iter_parent1
* + parent2
* + iter_parent2
* + iter_parent2
*/
gtk_tree_store_append (GTK_TREE_STORE (model), &grandparent1, NULL);
gtk_tree_store_append (GTK_TREE_STORE (model), &grandparent2, NULL);
gtk_tree_store_append (GTK_TREE_STORE (model), &parent1, &grandparent2);
gtk_tree_store_append (GTK_TREE_STORE (model), &iter_parent1, &parent1);
gtk_tree_store_append (GTK_TREE_STORE (model), &parent2, &grandparent2);
gtk_tree_store_append (GTK_TREE_STORE (model), &iter_parent2, &parent2);
gtk_tree_store_append (GTK_TREE_STORE (model), &iter_parent2, &parent2);
sort_model = gtk_tree_model_sort_new_with_model (model);
tree_view = gtk_tree_view_new_with_model (sort_model);
gtk_tree_view_expand_all (GTK_TREE_VIEW (tree_view));
gtk_widget_destroy (tree_view);
assert_node_ref_count (ref_model, &grandparent1, 0);
assert_node_ref_count (ref_model, &grandparent2, 1);
assert_node_ref_count (ref_model, &parent1, 1);
assert_node_ref_count (ref_model, &parent2, 1);
assert_node_ref_count (ref_model, &iter_parent1, 0);
assert_node_ref_count (ref_model, &iter_parent2, 0);
gtk_tree_model_sort_clear_cache (GTK_TREE_MODEL_SORT (sort_model));
assert_entire_model_unreferenced (ref_model);
g_object_unref (sort_model);
g_object_unref (ref_model);
}
void init_texture_list(GtkTreeView* tree) {
GtkTreeStore* store = GTK_TREE_STORE(gtk_tree_view_get_model(tree));
gtk_tree_store_clear(store);
inspect_tex_vec_t textures = inspector->textures;
for (inspect_texture_t* tex = textures->data; !vec_end(textures, tex); tex++) {
char str[64];
memset(str, 0, 64);
snprintf(str, 64, "%u", tex->fake);
GtkTreeIter row;
gtk_tree_store_append(store, &row, NULL);
gtk_tree_store_set(store, &row, 0, str, -1);
}
}
static void
contact_list_store_remove_contact (EmpathyContactListStore *store,
EmpathyContact *contact)
{
EmpathyContactListStorePriv *priv;
GtkTreeModel *model;
GList *iters, *l;
priv = GET_PRIV (store);
iters = contact_list_store_find_contact (store, contact);
if (!iters) {
return;
}
/* Clean up model */
model = GTK_TREE_MODEL (store);
for (l = iters; l; l = l->next) {
GtkTreeIter parent;
/* NOTE: it is only <= 2 here because we have
* separators after the group name, otherwise it
* should be 1.
*/
if (gtk_tree_model_iter_parent (model, &parent, l->data) &&
gtk_tree_model_iter_n_children (model, &parent) <= 2) {
gtk_tree_store_remove (GTK_TREE_STORE (store), &parent);
} else {
gtk_tree_store_remove (GTK_TREE_STORE (store), l->data);
}
}
g_list_foreach (iters, (GFunc) gtk_tree_iter_free, NULL);
g_list_free (iters);
}
static void ctree_populate(GtkWidget *widget)
{
GtkTreeView *view = GTK_TREE_VIEW(widget);
GtkTreeModel *model = gtk_tree_view_get_model(view);
GtkTreeStore *store = GTK_TREE_STORE(model);
gint i, j;
GNode *tree;
uint16_t handle;
// Parse VAT
vat_parse(&tree);
// Retrieve breakpoint
if(ti68k_bkpt_get_pgmentry(0, &handle))
handle = -1;
// and show it
for (i = 0; i < (int)g_node_n_children(tree); i++)
{
GNode *fol_node = g_node_nth_child(tree, i);
VatSymEntry *vse = (VatSymEntry *)fol_node->data;
GtkTreeIter fol_iter;
gtk_tree_store_append(store, &fol_iter, NULL);
gtk_tree_store_set(store, &fol_iter,
COL_NAME, vse->name, COL_HANDLE, vse->handle,
COL_CHECK, FALSE, COL_VISIBLE, FALSE,
-1);
for(j = 0; j < (int)g_node_n_children(fol_node); j++)
{
GNode *var_node = g_node_nth_child(fol_node, j);
VatSymEntry *vse = (VatSymEntry *)var_node->data;
GtkTreeIter var_iter;
gtk_tree_store_append(store, &var_iter, &fol_iter);
gtk_tree_store_set(store, &var_iter,
COL_NAME, vse->name, COL_HANDLE, vse->handle,
COL_CHECK, (vse->handle == handle), COL_VISIBLE, TRUE,
-1);
}
}
gtk_tree_view_expand_all(view);
// Free copy of VAT
vat_free(&tree);
}
/**
* callback called when something change in the entries of the configuration of the reconcile
*
* \param tree_view
*
* \return FALSE
* */
gboolean gsb_reconcile_config_update_line ( GtkWidget *entry,
GtkWidget *tree_view )
{
GtkTreeIter iter;
GtkTreeModel *model;
GtkTreeSelection *selection;
gboolean good;
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view));
good = gtk_tree_selection_get_selected (selection, &model, &iter);
if (good)
{
gint reconcile_number;
gtk_tree_model_get (model, &iter,
RECONCILIATION_RECONCILE_COLUMN, &reconcile_number,
-1 );
if (reconcile_number)
{
/* we are on a reconcile, change the line with the new values */
gchar *init_date, *final_date;
gchar *init_balance, *final_balance;
init_date = gsb_format_gdate (gsb_data_reconcile_get_init_date (reconcile_number));
final_date = gsb_format_gdate (gsb_data_reconcile_get_final_date (reconcile_number));
init_balance = utils_real_get_string (gsb_data_reconcile_get_init_balance (reconcile_number));
final_balance = utils_real_get_string (gsb_data_reconcile_get_final_balance (reconcile_number));
gtk_tree_store_set ( GTK_TREE_STORE (model),
&iter,
RECONCILIATION_NAME_COLUMN, gsb_data_reconcile_get_name (reconcile_number),
RECONCILIATION_INIT_DATE_COLUMN, init_date,
RECONCILIATION_FINAL_DATE_COLUMN, final_date,
RECONCILIATION_INIT_BALANCE_COLUMN, init_balance,
RECONCILIATION_FINAL_BALANCE_COLUMN, final_balance,
-1 );
g_free (init_date);
g_free (final_date);
g_free (init_balance);
g_free (final_balance);
}
}
return FALSE;
}
static void
tree_store_insert_flat (GtkTreeModel *model,
gint items,
gint i)
{
GtkTreeStore *store = GTK_TREE_STORE (model);
GtkTreeIter iter;
gchar *text;
gint n;
text = g_strdup_printf ("row %d", i);
n = g_random_int_range (0, i + 1);
gtk_tree_store_insert (store, &iter, NULL, n);
gtk_tree_store_set (store, &iter, 0, i, 1, text, -1);
g_free (text);
}
static void
history_dialog_add_url_item (HistoryDialog *dialog,
HistoryItem *item,
GtkTreeIter *parent_iter)
{
GtkTreeIter iter;
GtkTreeIter *tmp;
gtk_tree_store_insert (GTK_TREE_STORE (dialog->priv->model),
&iter,
parent_iter,
0);
tmp = gtk_tree_iter_copy (&iter);
history_dialog_update_url_item (dialog, item, tmp);
gtk_tree_iter_free (tmp);
}
void
item_list_view_add_item (ItemListView *ilv, itemPtr item)
{
GtkTreeStore *itemstore;
if (ilv->priv->batch_mode) {
/* either merge to new unattached GtkTreeStore */
item_list_view_add_item_to_tree_store (ilv, ilv->priv->batch_itemstore, item);
} else {
/* or merge to visible item store */
itemstore = GTK_TREE_STORE (gtk_tree_view_get_model (ilv->priv->treeview));
item_list_view_add_item_to_tree_store (ilv, itemstore, item);
}
item_list_view_update_item (ilv, item);
}
static void bar_pane_keywords_hide_unchecked_cb(GtkWidget *menu_widget, gpointer data)
{
PaneKeywordsData *pkd = data;
GtkTreeModel *model;
GtkTreeModel *keyword_tree;
GList *keywords;
model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
keywords = keyword_list_pull(pkd->keyword_view);
keyword_hide_unset_in(GTK_TREE_STORE(keyword_tree), model, keywords);
string_list_free(keywords);
bar_keyword_tree_sync(pkd);
}
static void
attach_process_clear (AttachProcess * ap, gint ClearRequest)
{
GtkTreeModel *model;
// latest ps output
switch (ClearRequest)
{
case CLEAR_UPDATE:
case CLEAR_FINAL:
if (ap->ps_output)
{
g_free (ap->ps_output);
}
case CLEAR_INITIAL:
ap->ps_output = NULL;
}
// helper variables
switch (ClearRequest)
{
case CLEAR_INITIAL:
case CLEAR_UPDATE:
case CLEAR_REVIEW:
ap->pid = -1L;
ap->iter_stack = NULL;
ap->iter_stack_level = -1;
ap->num_spaces_to_skip = -1;
}
// tree model
switch (ClearRequest)
{
case CLEAR_UPDATE:
case CLEAR_REVIEW:
case CLEAR_FINAL:
model = gtk_tree_view_get_model (GTK_TREE_VIEW (ap->treeview));
gtk_tree_store_clear (GTK_TREE_STORE (model));
}
// dialog widget
if (ClearRequest == CLEAR_FINAL)
{
gtk_widget_destroy (ap->dialog);
ap->dialog = NULL;
}
}
/* Put every GtkTreeView node of the subtree headed by 'parent_subtree_iter'
* into a waiting_for GTree.
* It's a recursive function.
*/
static void
do_recurse_subtree_and_invalidate (SymbolDBViewLocals *dbvl,
GtkTreeIter *parent_subtree_iter,
gint parent_id_to_wait_for)
{
gint curr_symbol_id;
const GdkPixbuf *curr_pixbuf;
GtkTreeStore *store;
gchar *curr_symbol_name;
SymbolDBViewLocalsPriv *priv;
g_return_if_fail (dbvl != NULL);
priv = dbvl->priv;
store = GTK_TREE_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (dbvl)));
gtk_tree_model_get (GTK_TREE_MODEL (store), parent_subtree_iter,
COLUMN_SYMBOL_ID, &curr_symbol_id,
COLUMN_PIXBUF, &curr_pixbuf,
COLUMN_NAME, &curr_symbol_name, /* no strdup required */
-1);
/*DEBUG_PRINT ("do_recurse_subtree_and_invalidate (): curr_symbol_id %d,"
"parent_id_to_wait_for %d", curr_symbol_id, parent_id_to_wait_for);*/
while (gtk_tree_model_iter_has_child (GTK_TREE_MODEL (store),
parent_subtree_iter))
{
GtkTreeIter child;
gtk_tree_model_iter_children (GTK_TREE_MODEL (store), &child,
parent_subtree_iter);
/* recurse */
do_recurse_subtree_and_invalidate (dbvl, &child, curr_symbol_id);
}
/* add to waiting for */
add_new_waiting_for (dbvl, parent_id_to_wait_for, curr_symbol_name,
curr_symbol_id, curr_pixbuf);
gtk_tree_store_remove (store, parent_subtree_iter);
g_tree_remove (priv->nodes_displayed, GINT_TO_POINTER (curr_symbol_id));
/* don't forget to free this gchar */
g_free (curr_symbol_name);
}
static void
git_status_pane_set_selected_column_state (GitStatusPane *self,
StatusType type,
gboolean state)
{
GtkTreeModel *status_model;
GtkTreeIter *parent_iter;
gint i;
GtkTreeIter iter;
gchar *path;
AnjutaVcsStatus status;
status_model = GTK_TREE_MODEL (gtk_builder_get_object (self->priv->builder,
"status_model"));
switch (type)
{
case STATUS_TYPE_COMMIT:
parent_iter = &(self->priv->commit_iter);
break;
case STATUS_TYPE_NOT_UPDATED:
parent_iter = &(self->priv->not_updated_iter);
break;
default:
return;
break;
}
i = 0;
while (gtk_tree_model_iter_nth_child (status_model, &iter, parent_iter,
i++))
{
gtk_tree_store_set (GTK_TREE_STORE (status_model), &iter,
COL_SELECTED, state,
-1);
gtk_tree_model_get (status_model, &iter,
COL_PATH, &path,
COL_STATUS, &status,
-1);
git_status_pane_set_path_selection_state (self, path, status, type,
state);
g_free (path);
}
}
/**
* Callback triggered when the "skip" attribute of a line in the tree
* preview is changed (that is, the checkbox associated is changed).
* It marks this line as skipped.
*
* \param cell Not used.
* \param path_str Textual representation of the path of modified
* checkbox.
* \param tree_preview GtkTreeView triggering event.
*/
void skip_line_toggled ( GtkCellRendererToggle * cell, gchar * path_str,
GtkTreeView * tree_preview )
{
GtkTreeIter iter;
gboolean toggle_item;
gint * indices;
GtkTreePath * path = gtk_tree_path_new_from_string (path_str);
GtkTreeModel * tree_model = gtk_tree_view_get_model ( tree_preview );
/* Get toggled iter */
gtk_tree_model_get_iter ( GTK_TREE_MODEL ( tree_model ), &iter, path );
gtk_tree_model_get ( GTK_TREE_MODEL ( tree_model ), &iter, 0, &toggle_item, -1 );
gtk_tree_store_set ( GTK_TREE_STORE ( tree_model ), &iter, 0, !toggle_item, -1);
indices = gtk_tree_path_get_indices ( path );
etat.csv_skipped_lines [ indices[0] ] = !toggle_item;
}
static void
add_to_subtitle_list_ui(signal_user_data_t *ud, GValue *subsettings)
{
GtkTreeView *tv;
GtkTreeIter ti;
GtkTreeModel *tm;
GtkTreeSelection *ts;
tv = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
ts = gtk_tree_view_get_selection(tv);
tm = gtk_tree_view_get_model(tv);
gtk_tree_store_append(GTK_TREE_STORE(tm), &ti, NULL);
subtitle_refresh_list_row_ui(tm, &ti, subsettings);
gtk_tree_selection_select_iter(ts, &ti);
}
static GtkTreeRowReference *
do_add_child_symbol_to_view (SymbolDBViewLocals *dbvl, gint parent_symbol_id,
const GdkPixbuf *pixbuf, const gchar* symbol_name,
gint symbol_id)
{
SymbolDBViewLocalsPriv *priv;
GtkTreePath *path;
GtkTreeStore *store;
GtkTreeIter iter, child_iter;
GtkTreeRowReference *row_ref;
g_return_val_if_fail (dbvl != NULL, NULL);
priv = dbvl->priv;
store = GTK_TREE_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (dbvl)));
if (store == NULL)
return NULL;
/* look up the row ref in the hashtable, then get its associated gtktreeiter */
row_ref = g_tree_lookup (priv->nodes_displayed, GINT_TO_POINTER (parent_symbol_id));
if (sdb_view_locals_get_iter_from_row_ref (dbvl, row_ref, &iter) == FALSE)
{
g_warning ("do_add_symbol_to_view (): something went wrong.");
return NULL;
}
/* append a new child &child_iter, with a parent of &iter */
gtk_tree_store_append (store, &child_iter, &iter);
gtk_tree_store_set (store, &child_iter,
COLUMN_PIXBUF, pixbuf,
COLUMN_NAME, symbol_name,
COLUMN_SYMBOL_ID, symbol_id,
-1);
/* grab the row ref and return it */
path = gtk_tree_model_get_path (gtk_tree_view_get_model (GTK_TREE_VIEW (dbvl)),
&child_iter);
row_ref = gtk_tree_row_reference_new (gtk_tree_view_get_model (GTK_TREE_VIEW (dbvl)),
path);
gtk_tree_path_free (path);
return row_ref;
}
static void
helper_update_model (PrefsLangsXml *gxml,
GtkTreeModel *model,
G_GNUC_UNUSED GtkTreePath *path,
GtkTreeIter *iter)
{
const char *ext, *mime, *conf;
ext = gtk_entry_get_text (gxml->extensions);
mime = gtk_entry_get_text (gxml->mimetypes);
conf = gtk_entry_get_text (gxml->config);
gtk_tree_store_set (GTK_TREE_STORE (model), iter,
COLUMN_MIMETYPES, mime,
COLUMN_EXTENSIONS, ext,
COLUMN_CONFIG, conf, -1);
}
static void bar_pane_keywords_show_all_cb(GtkWidget *menu_widget, gpointer data)
{
PaneKeywordsData *pkd = data;
GtkTreeModel *model;
GtkTreeModel *keyword_tree;
pkd->hide_unchecked = FALSE;
model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
keyword_show_all_in(GTK_TREE_STORE(keyword_tree), model);
if (!pkd->collapse_unchecked) gtk_tree_view_expand_all(GTK_TREE_VIEW(pkd->keyword_treeview));
bar_keyword_tree_sync(pkd);
}
int
clip_GTK_TREESTOREITERISVALID(ClipMachine * ClipMachineMemory)
{
C_object *cstree = _fetch_co_arg(ClipMachineMemory);
C_object *citer = _fetch_cobject(ClipMachineMemory, _clip_spar(ClipMachineMemory, 2));
CHECKARG2(1, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);
CHECKCOBJ(cstree, GTK_IS_TREE_STORE(cstree->object));
CHECKCOBJ(citer, GTK_IS_TREE_ITER(citer->object));
gtk_tree_store_iter_is_valid(GTK_TREE_STORE(cstree->object), GTK_TREE_ITER(citer->object));
return 0;
err:
return 1;
}
