/** * Callback called when toggle the check button to sort by method of payment * * \param cell * \param path_str * \param tree_view * * \return FALSE */ gboolean gsb_reconcile_sort_config_payment_toggled ( GtkCellRendererToggle *cell, gchar *path_str, GtkWidget *tree_view ) { GtkTreePath * treepath; GtkTreeIter iter; gboolean toggle; gint account_number; GtkTreeModel *model; model = gtk_tree_view_get_model (GTK_TREE_VIEW (tree_view)); treepath = gtk_tree_path_new_from_string ( path_str ); gtk_tree_model_get_iter ( GTK_TREE_MODEL (model), &iter, treepath ); gtk_tree_model_get (GTK_TREE_MODEL(model), &iter, RECONCILIATION_SORT_SORT_COLUMN, &toggle, RECONCILIATION_SORT_ACCOUNT_COLUMN, &account_number, -1); toggle ^= 1; /* set new value */ gtk_tree_store_set (GTK_TREE_STORE (model), &iter, RECONCILIATION_SORT_SORT_COLUMN, toggle, -1); /* Set to 1 (sort by types) if toggle is selected */ gsb_data_account_set_reconcile_sort_type ( account_number, toggle ); if (toggle) gtk_tree_view_expand_row ( GTK_TREE_VIEW(tree_view), treepath, FALSE ); else gtk_tree_view_collapse_row ( GTK_TREE_VIEW(tree_view), treepath ); gtk_tree_path_free ( treepath ); gsb_file_set_modified ( TRUE ); return FALSE; }
void row_activated_cb (GtkTreeView *tree_view, GtkTreePath *path, GtkTreeViewColumn *column) { GtkTreeIter iter; PangoStyle style; GDoDemoFunc func; GtkWidget *window; GtkTreeModel *model; model = gtk_tree_view_get_model (tree_view); gtk_tree_model_get_iter (model, &iter, path); gtk_tree_model_get (GTK_TREE_MODEL (model), &iter, FUNC_COLUMN, &func, STYLE_COLUMN, &style, -1); if (func) { gtk_tree_store_set (GTK_TREE_STORE (model), &iter, STYLE_COLUMN, (style == PANGO_STYLE_ITALIC ? PANGO_STYLE_NORMAL : PANGO_STYLE_ITALIC), -1); window = (func) (gtk_widget_get_toplevel (GTK_WIDGET (tree_view))); if (window != NULL) { CallbackData *cbdata; cbdata = g_new (CallbackData, 1); cbdata->model = model; cbdata->path = gtk_tree_path_copy (path); g_signal_connect (window, "destroy", G_CALLBACK (window_closed_cb), cbdata); } } }
/* this function will load the bookmarks * from bfwin->session->bmarks and parse * them into treestore bfwin->bookmarkstore * * this function should ALSO check all dcouments that are * opened (bfwin->documentlist) if they have bookmarks !! */ void bmark_reload(Tbfwin * bfwin) { GList *tmplist = g_list_first(bfwin->session->bmarks); DEBUG_MSG("bmark_reload for bfwin %p\n",bfwin); if (bfwin->bmark_files != NULL) g_hash_table_destroy(bfwin->bmark_files); bfwin->bmark_files = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL); while (tmplist) { gchar **items = (gchar **) tmplist->data; if (items && count_array(items) == 6) { gchar *ptr; Tbmark *b; b = g_new0(Tbmark, 1); b->name = g_strdup(items[0]); b->description = g_strdup(items[1]); b->filepath = g_strdup(items[2]); b->offset = atoi(items[3]); b->text = g_strdup(items[4]); b->len = atoi(items[5]); b->strarr = items; bmark_get_iter_at_tree_position(bfwin, b); if (b->name && strlen(b->name)>0) { ptr = g_strconcat(b->name, " - ", b->text, NULL); } else { ptr = g_strdup(b->text); } gtk_tree_store_set(bfwin->bookmarkstore, &(b->iter), NAME_COLUMN, ptr, PTR_COLUMN, b, -1); g_free(ptr); } tmplist = g_list_next(tmplist); } tmplist = g_list_first(bfwin->documentlist); while (tmplist) { DEBUG_MSG("bmark_reload, calling bmark_set_for_doc for doc=%p\n",tmplist->data); bmark_set_for_doc(DOCUMENT(tmplist->data)); bmark_check_length(bfwin, DOCUMENT(tmplist->data)); tmplist = g_list_next(tmplist); } }
static chan * chanview_add_real (chanview *cv, char *name, void *family, void *userdata, gboolean allow_closure, int tag, GdkPixbuf *icon, chan *ch, chan *avoid) { GtkTreeIter parent_iter; GtkTreeIter iter; gboolean has_parent = FALSE; if (chanview_find_parent (cv, family, &parent_iter, avoid)) { chanview_insert_sorted (cv, &iter, &parent_iter, userdata); has_parent = TRUE; } else { gtk_tree_store_append (cv->store, &iter, NULL); } if (!ch) { ch = g_new0 (chan, 1); ch->userdata = userdata; ch->family = family; ch->cv = cv; ch->allow_closure = allow_closure; ch->tag = tag; ch->icon = icon; } memcpy (&(ch->iter), &iter, sizeof (iter)); gtk_tree_store_set (cv->store, &iter, COL_NAME, name, COL_CHAN, ch, COL_PIXBUF, icon, -1); cv->size++; if (!has_parent) ch->impl = cv->func_add (cv, ch, name, NULL); else ch->impl = cv->func_add (cv, ch, name, &parent_iter); return ch; }
void search_preferences_init(void) { GConfClient *client; GSList *list; GtkTreeModel *model; GtkTreeIter iter; sr = create_search_replace_instance(NULL); search_preferences_add_treeview(BASIC); client = gconf_client_get_default(); gconf_client_add_dir(client, SEARCH_PREF_PATH, GCONF_CLIENT_PRELOAD_NONE, NULL); list_pref = gconf_client_get_list(client,gconf_concat_dir_and_key(SEARCH_PREF_PATH, "list_pref"), GCONF_VALUE_STRING, NULL); for (list = list_pref; list != NULL; list = g_slist_next(list)) search_preferences_add_treeview(list->data); default_pref = gconf_client_get_string(client,gconf_concat_dir_and_key(SEARCH_PREF_PATH, "search_pref_default"), NULL); model = search_preferences_get_model(); gtk_tree_model_foreach (model, on_search_preferences_setting_inactive, NULL); if (default_pref && (*default_pref != '\0') && g_ascii_strcasecmp (default_pref, BASIC)) search_preferences_read_setting(gconf_concat_dir_and_key(SEARCH_PREF_PATH, default_pref)); else { gtk_tree_model_get_iter_first(model, &iter); gtk_tree_store_set (GTK_TREE_STORE (model), &iter, PREF_ACTIVE_COLUMN, TRUE, -1); search_preferences_setting_by_default(); } search_preferences_activate_default(default_pref); g_free(default_pref); }
static void sensor_config_dialog_offset_changed(GtkSpinButton *spinbutton, SensorConfigDialog *config_dialog) { GtkTreeModel *model; GtkTreePath *path; GtkTreeIter iter; gdouble value; value = gtk_spin_button_get_value(spinbutton); gtk_tree_selection_get_selected(config_dialog->sensors_applet->selection, &model, &iter); path = gtk_tree_model_get_path(GTK_TREE_MODEL(config_dialog->sensors_applet->sensors), &iter); gtk_tree_store_set(config_dialog->sensors_applet->sensors, &iter, OFFSET_COLUMN, value, -1); sensors_applet_update_sensor(config_dialog->sensors_applet, path); gtk_tree_path_free(path); }
static void netlist_disable_all_cb (GtkToggleButton * button, gpointer data) { GtkTreeIter iter; gboolean active = gtk_toggle_button_get_active (button); LibraryMenuType *menu; /* Get each net iter and change the NET_ENABLED_COLUMN to a "*" or "" | to flag it as disabled or enabled based on toggle button state. */ if (gtk_tree_model_get_iter_first (net_model, &iter)) do { gtk_tree_store_set (GTK_TREE_STORE (net_model), &iter, NET_ENABLED_COLUMN, active ? "*" : "", -1); /* set/clear the flag which says the net is enabled or disabled */ gtk_tree_model_get (net_model, &iter, NET_LIBRARY_COLUMN, &menu, -1); menu->flag = active ? 0 : 1; } while (gtk_tree_model_iter_next (net_model, &iter)); }
static void gglk_radio_toggled(GtkCellRendererToggle *cell, gchar *path_str, gpointer user_data) { GtkTreeModel *model = GTK_TREE_MODEL(user_data); GtkTreePath *path = gtk_tree_path_new_from_string (path_str); GtkTreeIter iter; gint *column; column = g_object_get_data (G_OBJECT (cell), "column"); /* get toggled iter */ gtk_tree_model_get_iter (model, &iter, path); /* toggle the item on */ gtk_tree_store_set (GTK_TREE_STORE (model), &iter, column, TRUE, -1); /* clean up */ gtk_tree_path_free (path); }
static void tree_config_update_priorities(void) { GtkTreeModel *model; GtkTreeIter iter; int x=1; model = GTK_TREE_MODEL(tree_config_get_store()); if (gtk_tree_model_get_iter_first(model, &iter) == FALSE) { //fprintf(stderr, "Warning: tree_config_update_priorities cannot find iter. Config tree is empty.\n"); return; } do { gtk_tree_store_set( GTK_TREE_STORE(model), &iter, COL_PRIORITY, x++, -1); } while (gtk_tree_model_iter_next(model, &iter) != FALSE); }
/*! \fn gboolean CDesktopAppChooser::m_AddAppsMenuTopLevelNode(GMenuTreeDirectory *appsDir) \brief To create top-level(Directory) nodes. \param[in] appsDir. \return TRUE or FALSE */ gboolean CDesktopAppChooser::m_AddAppsMenuTopLevelNode(GMenuTreeDirectory *appsDir) { GdkPixbuf *pixbuf = NULL; /* To get PixelBuffer of the Directory icon. */ pixbuf = m_LoadIcon(gmenu_tree_directory_get_icon(appsDir), IMG_SIZE, TRUE ); /* To set the columns' content. */ gtk_tree_store_append(m_TreeStore, &m_TopLevelNodeIter, NULL); gtk_tree_store_set(m_TreeStore, &m_TopLevelNodeIter, COLUMN_ICON, pixbuf, COLUMN_TEXT, gmenu_tree_directory_get_name(appsDir), COLUMN_NODEDATA, NULL, -1); /* pixbuf has a referece count of "1" now, as the tree store has added its own reference. So to decrease the reference count of pixbuf. */ g_object_unref(pixbuf); return true; }
void tree_item___::store_add__(callback_item___* si, GdkPixbuf *pixbuf, int posi) { GtkTreeIter iter2; GtkTreePath *path; if(!up_.empty()) { path = gtk_tree_path_new_from_string (up_.c_str()); gtk_tree_model_get_iter(model__(), &iter2, path); gtk_tree_path_free (path); } GtkTreeIter iter; gtk_tree_store_append (store_, &iter, up_.empty() ? NULL : &iter2); gtk_tree_store_set(store_, &iter, ID_COLUMN, si->id_, PIXBUF_COLUMN, pixbuf, TITLE_COLUMN, si->title_.c_str(), -1); path = gtk_tree_model_get_path (model__(), &iter); last_ = gtk_tree_path_to_string (path); gtk_tree_path_free (path); }
void add_text_combo_item_to_cbox(GtkTreeStore *list, GtkTreeIter *iter, GtkTreeIter *parent, int column_id, int enum_id, const char *title, enum TOGGLE_TYPE type, int active) { GtkTreeIter locl_iter; if (iter == NULL) { iter = &locl_iter; } gtk_tree_store_append(list, iter, parent); gtk_tree_store_set(list, iter, OBJECT_COLUMN_TYPE_STRING, title, OBJECT_COLUMN_TYPE_PIXBUF, NULL, OBJECT_COLUMN_TYPE_INT, column_id, OBJECT_COLUMN_TYPE_TOGGLE_VISIBLE, type != TOGGLE_NONE, OBJECT_COLUMN_TYPE_TOGGLE_IS_RADIO, type == TOGGLE_RADIO, OBJECT_COLUMN_TYPE_TOGGLE, active, OBJECT_COLUMN_TYPE_PIXBUF_VISIBLE, FALSE, OBJECT_COLUMN_TYPE_ENUM, enum_id, -1); }
void TreeDict::load_model(gchar **buffer, GtkTreeIter *parent, guint32 count) { GtkTreeIter iter; gchar *p1; guint32 offset, size, subentry_count; for (guint32 i=0; i< count; i++) { p1 = *buffer + strlen(*buffer) +1; offset = g_ntohl(get_uint32(p1)); p1 += sizeof(guint32); size = g_ntohl(get_uint32(p1)); p1 += sizeof(guint32); subentry_count = g_ntohl(get_uint32(p1)); p1 += sizeof(guint32); gtk_tree_store_append(model, &iter, parent); gtk_tree_store_set(model, &iter, 0, *buffer, 1, offset, 2, size, -1); *buffer = p1; if (subentry_count) load_model(buffer, &iter, subentry_count); } }
static GtkTreeModel *create_model_for_photo(gchar *prefix_path) { GtkTreeStore *store = NULL; GtkTreeIter iter; GDir *dir = NULL; gchar path[1024] = {0}; GError *err = NULL; store = gtk_tree_store_new(BM_NUM_COL, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING); if(! prefix_path) prefix_path = PHOTO_PATH; dir = g_dir_open(prefix_path, 0, &err); if(dir) { const gchar *name = NULL; while(name = g_dir_read_name(dir)) { //DEBUG("path name = %s\n", name); snprintf(path, 1024, "%s/%s", prefix_path, name); if(g_file_test(path, G_FILE_TEST_IS_DIR)) { gchar file[1024] = {0}, logo[1024] = {0}; if(scan_photo_path(path, file, logo, NULL)) { GdkPixbuf *pixbuf = NULL; GError *err = NULL; DD("load pixbuf %s\n", logo); pixbuf = gdk_pixbuf_new_from_file_at_scale(logo, MEDIAUI_TREE_MODEL_ICON_SIZE, MEDIAUI_TREE_MODEL_ICON_SIZE, TRUE, &err); if(pixbuf) { gtk_tree_store_append(store, &iter, NULL); gtk_tree_store_set(store, &iter, BM_PIXBUF_COL, pixbuf, BM_TITLE_COL, name, BM_URL_COL, logo, -1); g_object_unref(pixbuf); } }/**g_file_test*/ } } /**while(read_dir_name)*/ g_dir_close(dir); } return GTK_TREE_MODEL(store); }
void make_tree_view(void) { GtkTreeIter iter; GtkCellRenderer * pixbuf_renderer, * text_renderer; GtkTreeViewColumn * icon_column, * name_column; tree_store = gtk_tree_store_new(N_COLUMNS, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING); gtk_tree_store_append(tree_store, &iter, NULL); gtk_tree_store_set(tree_store, &iter, NAME_COLUMN, "MODS", -1); tree = GTK_TREE_VIEW(gtk_tree_view_new_with_model( GTK_TREE_MODEL(tree_store))); g_object_set(tree, "headers-visible", FALSE, NULL); g_signal_connect(tree, "cursor-changed", G_CALLBACK(tree_view_selection_changed), NULL); pixbuf_renderer = gtk_cell_renderer_pixbuf_new(); text_renderer = gtk_cell_renderer_text_new(); icon_column = gtk_tree_view_column_new_with_attributes ("Icon", pixbuf_renderer, "pixbuf", ICON_COLUMN, NULL); gtk_tree_view_column_set_sizing(icon_column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); name_column = gtk_tree_view_column_new_with_attributes ("Name", text_renderer, "text", NAME_COLUMN, NULL); gtk_tree_view_column_set_sizing(name_column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_append_column(tree, icon_column); gtk_tree_view_append_column(tree, name_column); }
void world_tree_app_state_changed(graph_view_handle view, uint64_t id, const char * app_name, bool running, bool terminal, const char * level) { GtkTreeIter view_iter; GtkTreeIter app_iter; const char * view_name; GtkTreePath * path; char * app_name_with_status; if (!find_app(view, id, &view_iter, &app_iter)) { log_error("removed app not found"); return; } path = gtk_tree_model_get_path(GTK_TREE_MODEL(g_treestore), &view_iter); gtk_tree_model_get(GTK_TREE_MODEL(g_treestore), &view_iter, COL_NAME, &view_name, -1); log_info("changing app state '%s':'%s'", view_name, app_name); app_name_with_status = get_app_name_string(app_name, running, terminal, level); if (app_name_with_status == NULL) { goto free_path; } gtk_tree_view_expand_row(GTK_TREE_VIEW(g_world_tree_widget), path, false); gtk_tree_store_set( g_treestore, &app_iter, COL_NAME, app_name_with_status, COL_RUNNING, running, COL_TERMINAL, terminal, COL_LEVEL, level, -1); free(app_name_with_status); free_path: gtk_tree_path_free(path); }
static void build_combo_box (GtkComboBox *box) { ChamplainMapSourceFactory *factory; GSList *sources, *iter; GtkTreeStore *store; GtkTreeIter parent; GtkCellRenderer *cell; store = gtk_tree_store_new (N_COLS, G_TYPE_STRING, /* id */ G_TYPE_STRING, /* name */ -1); factory = champlain_map_source_factory_dup_default (); sources = champlain_map_source_factory_get_registered (factory); iter = sources; while (iter != NULL) { ChamplainMapSourceDesc *desc = CHAMPLAIN_MAP_SOURCE_DESC (iter->data); const gchar *id = champlain_map_source_desc_get_id (desc); const gchar *name = champlain_map_source_desc_get_name (desc); gtk_tree_store_append (store, &parent, NULL); gtk_tree_store_set (store, &parent, COL_ID, id, COL_NAME, name, -1); iter = g_slist_next (iter); } g_slist_free (sources); g_object_unref (factory); gtk_combo_box_set_model (box, GTK_TREE_MODEL (store)); cell = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (box), cell, FALSE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (box), cell, "text", COL_NAME, NULL); }
void add_mark_combo_item_to_cbox(GtkTreeStore *list, GtkTreeIter *iter, GtkTreeIter *parent, int column_id, struct objlist *obj, const char *field, int id) { int j, type; GtkTreeIter locl_iter; if (iter == NULL) { iter = &locl_iter; } type = -1; getobj(obj, field, id, 0, NULL, &type); for (j = 0; j < MARK_TYPE_NUM; j++) { GdkPixbuf *pixbuf; #if GTK_CHECK_VERSION(3, 0, 0) pixbuf = gdk_pixbuf_get_from_surface(NgraphApp.markpix[j], 0, 0, MARK_PIX_SIZE, MARK_PIX_SIZE); #else pixbuf = gdk_pixbuf_get_from_drawable(NULL, NgraphApp.markpix[j], NULL, 0, 0, 0, 0, -1, -1); #endif if (pixbuf) { char buf[64]; gtk_tree_store_append(list, iter, parent); snprintf(buf, sizeof(buf), "%02d ", j); gtk_tree_store_set(list, iter, OBJECT_COLUMN_TYPE_STRING, buf, OBJECT_COLUMN_TYPE_PIXBUF, pixbuf, OBJECT_COLUMN_TYPE_INT, column_id, OBJECT_COLUMN_TYPE_TOGGLE_VISIBLE, TRUE, OBJECT_COLUMN_TYPE_TOGGLE_IS_RADIO, TRUE, OBJECT_COLUMN_TYPE_TOGGLE, j == type, OBJECT_COLUMN_TYPE_ENUM, j, -1); g_object_unref(pixbuf); } } }
//funcion que aƱade un coche a la lista y guarda en fichero static void add_car(GtkButton *widget, gpointer data) { GObject **widgs; struct coche *c; GtkWidget *entry_ptr_marca; GtkWidget *entry_ptr_matricula; GtkTreeStore *store; GtkTreeIter iter; const gchar *matricula, *marca; widgs = (GObject **)data; entry_ptr_marca = (GtkWidget *)widgs[1]; entry_ptr_matricula = (GtkWidget *)widgs[2]; store = (GtkTreeStore *)widgs[3]; marca = gtk_entry_get_text((GtkEntry *)entry_ptr_marca); matricula = gtk_entry_get_text((GtkEntry *)entry_ptr_matricula); c = curso_coche_alloc(); if (c == NULL) return; curso_coche_attr_set_u32(c, CURSO_COCHE_ATTR_ID, id++); curso_coche_attr_set_str(c, CURSO_COCHE_ATTR_MATRICULA, matricula); curso_coche_attr_set_str(c, CURSO_COCHE_ATTR_MARCA, marca); curso_concesionario_attr_set_coche(con, CURSO_CONCESIONARIO_ATTR_COCHE, c); gtk_tree_store_append (store, &iter, NULL); gtk_tree_store_set (store, &iter, 0, FALSE, 1, id - 1, 2, marca, 3, matricula, -1); write_concesionario_to_file(path, con); gtk_widget_destroy((GtkWidget *) widgs[0]); }
static void add_child (GtkTreeStore *store, GimpHelpDomain *domain, GimpHelpLocale *locale, GtkTreeIter *parent, GimpHelpItem *item, gint depth) { GtkTreeIter iter; GList *list; gchar *uri; gtk_tree_store_append (store, &iter, parent); gtk_tree_store_set (store, &iter, 0, item, 1, item->title, -1); uri = g_strconcat (domain->help_uri, "/", locale->locale_id, "/", item->ref, NULL); g_hash_table_insert (uri_hash_table, uri, gtk_tree_iter_copy (&iter)); if (depth + 1 == GIMP_HELP_BROWSER_INDEX_MAX_DEPTH) return; item->children = g_list_sort (item->children, help_item_compare); for (list = item->children; list; list = g_list_next (list)) { GimpHelpItem *item = list->data; add_child (store, domain, locale, &iter, item, depth + 1); } }
G_MODULE_EXPORT void on_edit_activate2(GtkMenuItem *menuitem, gpointer user_data) { INFO *info; EDITOR *editor = (EDITOR *)user_data; GtkWidget *tree = GTK_WIDGET(editor->treeview); gint test; GS_DIALOG *d; info = _get_info(tree); d = gui_new_dialog(); #ifdef HAVE_GTK_310 d->stock_icon = "dialog-question"; #else d->stock_icon = GTK_STOCK_DIALOG_QUESTION; #endif d->title = _("Prayer List/Journal Item"); d->label_top = _("New name"); d->label1 = _("Name: "); d->text1 = g_strdup(info->local_name); d->ok = TRUE; d->cancel = TRUE; test = gui_gs_dialog(d); if (test == GS_OK) { main_treekey_set_local_name(info->book, d->text1, info->offset); gtk_tree_store_set(GTK_TREE_STORE(info->model), &info->iter, COL_CAPTION, (gchar *)d->text1, -1); } g_free(info->book); g_free(info->local_name); g_free(info->offset); g_free(info); g_free(d->text1); g_free(d); }
void UzblTreeTab::UpdateTablist() { int i = 0; for(GList* l = uzblinstances; l != NULL; l = g_list_next(l)) { GtkTreeIter iter; char str[1024]; memset(str, 0, 1024); //UzblInstance* uz = (UzblInstance*)g_list_nth(uzblinstances, i)->data; UzblInstance* uz = (UzblInstance*)l->data; //uz->SetNum(i); GtkTreeRowReference* r = uz->GetRowRef(); GtkTreePath* p = gtk_tree_row_reference_get_path(r); gtk_tree_model_get_iter(GTK_TREE_MODEL(tabmodel), &iter, p); sprintf(str, "%d: %s", i++, uz->GetTitle()); gtk_tree_store_set(GTK_TREE_STORE(tabmodel), &iter, 0, str, -1); } }
static void item_list_view_add_item_to_tree_store (ItemListView *ilv, GtkTreeStore *itemstore, itemPtr item) { gint state = 0; nodePtr node; GtkTreeIter *iter; GtkTreeIter old_iter; gboolean exists; if (item->flagStatus) state += 2; if (!item->readStatus) state += 1; node = node_from_id (item->nodeId); if(!node) return; /* comment items do cause this... maybe filtering them earlier would be a good idea... */ exists = item_list_view_id_to_iter (ilv, item->id, &old_iter); iter = &old_iter; if (!exists) { iter = g_new0 (GtkTreeIter, 1); gtk_tree_store_prepend (itemstore, iter, NULL); g_hash_table_insert (ilv->priv->item_id_to_iter, GUINT_TO_POINTER (item->id), (gpointer)iter); } gtk_tree_store_set (itemstore, iter, IS_TIME, (guint64)item->time, IS_NR, item->id, IS_PARENT, node, IS_FAVICON, node->icon, IS_ENCICON, item->hasEnclosure?icon_get (ICON_ENCLOSURE):NULL, IS_ENCLOSURE, item->hasEnclosure, IS_SOURCE, node, IS_STATE, state, -1); }
static void tree_config_clear_current(void) { GtkTreeModel *model; GtkTreeIter iter; model = GTK_TREE_MODEL(tree_config_get_store()); if (gtk_tree_model_get_iter_first(model, &iter) == FALSE) { //fprintf(stderr, "Warning: cannot find iter. Config tree is empty.\n"); return; } while (1) { gtk_tree_store_set( GTK_TREE_STORE(model), &iter, COL_CURRENT, " ", -1); if (gtk_tree_model_iter_next(model, &iter) == FALSE) break; } }
//funcion para rellenar la lista con los coches del concesionario void append_coches(GtkTreeStore *store, struct concesionario *con) { GtkTreeIter iter; struct coche *c; int i; int numcoches = curso_concesionario_attr_get_u32(con, CURSO_CONCESIONARIO_ATTR_NUM_COCHES); for (i = 0; i < numcoches; i++) { c = curso_concesionario_attr_get_coche(con, CURSO_CONCESIONARIO_ATTR_COCHE, i); gtk_tree_store_append (store, &iter, NULL); gtk_tree_store_set (store, &iter, 0, FALSE, 1, c->id, 2, c->marca, 3, c->matricula, -1); } id = c->id + 1; }
void vol_store_voladj(GtkTreeStore * store, GtkTreeIter * iter, float voladj) { if (!gtk_tree_store_iter_is_valid(store, iter)) { return; } if (store == music_store) { /* music store */ track_data_t * data; gtk_tree_model_get(GTK_TREE_MODEL(music_store), iter, MS_COL_DATA, &data, -1); data->volume = voladj; music_store_mark_changed(iter); } else { /* playlist */ playlist_data_t * data; char str[32]; voladj2str(voladj, str); gtk_tree_model_get(GTK_TREE_MODEL(store), iter, PL_COL_DATA, &data, -1); data->voladj = voladj; gtk_tree_store_set(store, iter, PL_COL_VADJ, str, -1); } }
void country_table_populate_combobox(GtkComboBox *country_combobox) { int i = 0; GtkTreeStore * new_store = NULL; GtkTreeIter iter; GtkCellRenderer *renderer = NULL; country_table_populate(); new_store = gtk_tree_store_new(2, G_TYPE_STRING, G_TYPE_STRING); for (i=0; i<NUMBER_OF_COUNTRIES; i++) { gtk_tree_store_append (new_store, &iter, NULL); gtk_tree_store_set (new_store, &iter, 0, country_table[i].name, 1, country_table[i].code, -1); } gtk_combo_box_set_model (GTK_COMBO_BOX(country_combobox), GTK_TREE_MODEL (new_store)); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (country_combobox), renderer, FALSE); gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (country_combobox), renderer, "text", 0); }
/** * cryptui_key_store_set_selected_key: * @ckstore: a libcryptui key store * @view: a GtkTreeView * @selkey: a libcryptui key * * Marks the given key as selected */ void cryptui_key_store_set_selected_key (CryptUIKeyStore *ckstore, GtkTreeView *view, const gchar *selkey) { GtkTreeModel* model = GTK_TREE_MODEL (ckstore->priv->store); GtkTreeSelection *sel; GtkTreeIter iter, sel_iter; const gchar *key; gboolean have; g_return_if_fail (CRYPTUI_IS_KEY_STORE (ckstore)); g_return_if_fail (GTK_IS_TREE_VIEW (view)); sel = gtk_tree_view_get_selection (view); /* Go through all rows and select deselect as necessary */ if (gtk_tree_model_get_iter_first (model, &iter)) { do { /* Is this row in our selection? */ gtk_tree_model_get (model, &iter, CRYPTUI_KEY_STORE_KEY, &key, -1); have = (key && strcmp (selkey, key) == 0) ? TRUE : FALSE; if (ckstore->priv->use_checks) { /* Using checks so change data store */ gtk_tree_store_set (ckstore->priv->store, &iter, CRYPTUI_KEY_STORE_CHECK, have, -1); } else { key_store_get_view_iter (ckstore, &iter, &sel_iter); /* Using normal selection */ if (have) gtk_tree_selection_select_iter (sel, &sel_iter); else gtk_tree_selection_unselect_iter (sel, &sel_iter); } } while (gtk_tree_model_iter_next (model, &iter)); } }
static gboolean contact_list_store_update_list_mode_foreach (GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, EmpathyContactListStore *store) { EmpathyContactListStorePriv *priv; gboolean show_avatar = FALSE; priv = GET_PRIV (store); if (priv->show_avatars && !priv->is_compact) { show_avatar = TRUE; } gtk_tree_store_set (GTK_TREE_STORE (store), iter, EMPATHY_CONTACT_LIST_STORE_COL_PIXBUF_AVATAR_VISIBLE, show_avatar, EMPATHY_CONTACT_LIST_STORE_COL_STATUS_VISIBLE, !priv->is_compact, -1); return FALSE; }
static void gui_list_tree_toggled_callback (GtkCellRendererToggle *cell, gchar *path_str, gpointer data, bool list)/*{{{*/ { signal_t* p = (signal_t*)data; orcaObject* fun = p->fun; GtkTreeModel *model = p->tree; orcaGtk *owner = p->owner; GtkTreeIter iter; GtkTreePath *path = gtk_tree_path_new_from_string (path_str); gboolean fixed; /* get toggled iter */ gtk_tree_model_get_iter (model, &iter, path); gtk_tree_model_get (model, &iter, 0, &fixed, -1); /* do something with the value */ fixed ^= 1; /* set new value */ if (list) gtk_list_store_set (GTK_LIST_STORE (model), &iter, 0, fixed, -1); else gtk_tree_store_set (GTK_TREE_STORE (model), &iter, 0, fixed, -1); /* clean up */ gtk_tree_path_free (path); orcaGtkIter* ip = new orcaGtkIter(); ip->m_gp = owner; ip->m_iter = iter; ip->m_type = list ? GUI_LIST : GUI_TREE; orcaVM* vm = get_current_vm(); vm->m_stack->push((orcaObject*)fun); vm->push_param(fixed?true:false); vm->push_param(ip); vm->call(2); vm->m_stack->pop(); }