gboolean getNode(GtkTreeModel *model,GtkTreePath *path,GtkTreeIter *iter,gpointer data) { char* name=NULL; char* thispath=NULL; bool retval=false; thispath=gtk_tree_path_to_string(path); if(node!=NULL && thispath!=NULL) { if((strlen(thispath)<strlen(node)) || (strcmp(thispath,node)==0)) { debugFree(&thispath); return(false); } } gtk_tree_model_get(model,iter,COLUMN_FILENAME,&name,-1); if(name!=NULL) { if(strcmp(name,(char*)data)==0) { debugFree(&node); node=gtk_tree_path_to_string(path); gtk_tree_view_expand_row((GtkTreeView*)treeview,path,false); retval=true; } debugFree(&name); } debugFree(&thispath); return(retval); }
void tabu_playlist_remove_selection (TabuPlaylist *playlist) { GtkTreeModel *store; GtkTreeIter iter; GtkTreePath *path; GList *selected; GList *references = NULL; GtkTreeSelection *selection; selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (TABU_PLAYLIST (playlist)->tree_view)); selected = gtk_tree_selection_get_selected_rows ( selection, &store ); while (selected != NULL) { references = g_list_append ( references, gtk_tree_row_reference_new (store, selected->data)); selected = g_list_next ( selected ); } references = g_list_first (references); while (references != NULL) { path = gtk_tree_row_reference_get_path (references->data); if (tabu_backend_is_playing()) { GtkTreePath *song_path = gtk_tree_row_reference_get_path (TABU_PLAYLIST (playlist)->reference); if (!strcmp(gtk_tree_path_to_string(path),gtk_tree_path_to_string(song_path))) { tabu_backend_stop(); TABU_PLAYLIST(playlist)->reference = NULL; } } /* ok, now remove the song from the playlist */ if (gtk_tree_model_get_iter (GTK_TREE_MODEL (store), &iter, path)) { gtk_list_store_remove (GTK_LIST_STORE (store), &iter ); } gtk_tree_path_free (path); references = g_list_next ( references ); } g_list_foreach (references, (GFunc)gtk_tree_row_reference_free, NULL); g_list_free (references); g_list_foreach (selected, (GFunc) gtk_tree_path_free, NULL); g_list_free (selected); }
static void tree_selection_changed_cb (GtkTreeSelection *selection, gpointer data) { StatisticViewerData *statistic_viewer_data = (StatisticViewerData*)data; GtkTreeIter iter; GtkTreeModel *model = GTK_TREE_MODEL(statistic_viewer_data->store_m); gchar *event; GtkTextBuffer* buf; gchar * str; GtkTreePath * path; GtkTextIter text_iter; LttvAttribute * stats; if (gtk_tree_selection_get_selected (selection, &model, &iter)) { gtk_tree_model_get (model, &iter, NAME_COLUMN, &event, -1); path = gtk_tree_model_get_path(GTK_TREE_MODEL(model),&iter); str = gtk_tree_path_to_string (path); stats = (LttvAttribute*)g_hash_table_lookup (statistic_viewer_data->statistic_hash,str); g_free(str); buf = gtk_text_view_get_buffer((GtkTextView*)statistic_viewer_data->text_v); gtk_text_buffer_set_text(buf,"Statistic for '", -1); gtk_text_buffer_get_end_iter(buf, &text_iter); gtk_text_buffer_insert(buf, &text_iter, event, strlen(event)); gtk_text_buffer_get_end_iter(buf, &text_iter); gtk_text_buffer_insert(buf, &text_iter, "' :\n\n",5); show_statistic(statistic_viewer_data, stats, buf); g_free (event); } }
void SludgeProjectManager::on_remove_file_clicked() { GList * selectedRows; GtkTreeIter iter; GtkTreePath *path; GtkTreeModel *model; gchar *indexStr; int index; if (! askAQuestion("Remove files?", "Do you want to remove the selected files from the project? (They will not be deleted from the disk.)")) { return; } selectedRows = gtk_tree_selection_get_selected_rows(filesSelection, &model); for (int j = g_list_length(selectedRows) - 1; j >= 0; j--) { path = gtk_tree_model_sort_convert_path_to_child_path( GTK_TREE_MODEL_SORT(model), (GtkTreePath *)g_list_nth(selectedRows, j)->data); indexStr = gtk_tree_path_to_string(path); index = atoi(indexStr); g_free(indexStr); removeFileFromList(index, fileList, &fileListNum); setFileChanged(); gtk_tree_model_get_iter(GTK_TREE_MODEL(filesListStore), &iter, path); gtk_list_store_remove(filesListStore, &iter); } g_list_foreach(selectedRows, (GFunc) gtk_tree_path_free, NULL); g_list_free(selectedRows); }
static void _lib_keywords_drag_data_get_callback(GtkWidget *w, GdkDragContext *dctx, GtkSelectionData *data, guint info, guint time, gpointer user_data) { dt_lib_module_t *self = (dt_lib_module_t *)user_data; dt_lib_keywords_t *d = (dt_lib_keywords_t*)self->data; /* get iter of item to drag to ssetup drag data */ GtkTreeIter iter; GtkTreeModel *model = NULL; GtkTreeSelection *s = gtk_tree_view_get_selection(d->view); if (gtk_tree_selection_get_selected(s,&model,&iter)) { /* get tree path as string out of iter into selection data */ GtkTreePath *path = NULL; path = gtk_tree_model_get_path(model,&iter); gchar *sp = gtk_tree_path_to_string(path); gtk_selection_data_set(data,data->target, 8, (const guchar *)sp, strlen(sp)); } }
/***************************************************************************************** * Add a FileInfo to the parent node to the proper position. * tree_path is the tree path of the parent node. * ****************************************************************************************/ GList *fm_dir_tree_model_insert_file_info (FmDirTreeModel *dir_tree_model, GList *parent_node, GtkTreePath *tree_path, FmFileInfo *file_info) { FmDirTreeItem *parent_item = (FmDirTreeItem*) parent_node->data; FmDirTreeItem *dir_tree_item = fm_dir_tree_item_new (dir_tree_model, parent_node, file_info); // Don't show hidden files... if (!dir_tree_model->show_hidden && file_info->path->name[0] == '.') { parent_item->hidden_children = g_list_prepend (parent_item->hidden_children, dir_tree_item); return parent_item->hidden_children; } // Don't show links... if (!dir_tree_model->show_symlinks && fm_file_info_is_symlink (file_info)) { parent_item->hidden_children = g_list_prepend (parent_item->hidden_children, dir_tree_item); return parent_item->hidden_children; } GList *item_list = fm_dir_tree_model_insert_sorted (dir_tree_model, parent_node, tree_path, dir_tree_item); char *tmp_path = gtk_tree_path_to_string (tree_path); TREEVIEW_DEBUG ("TREEVIEW_DEBUG: fm_dir_tree_model_insert_file_info: file = %s\t index = %d\n\n", fm_file_info_get_name (file_info), file_info->sorting_index); g_free (tmp_path); return item_list; }
/****************************************************************************** * gtk_ListStoreInsert(list, position, ncol, val, ....) -->path_string ******************************************************************************/ int clip_GTK_LISTSTOREINSERT(ClipMachine * cm) { C_object *cslist = _fetch_co_arg(cm); gint position = _clip_parni(cm, 2); GtkTreeIter iter; GtkTreePath *path; gchar *path_string; CHECKARG2(1, MAP_t, NUMERIC_t); CHECKCOBJ(cslist, GTK_IS_LIST_STORE(cslist->object)); CHECKARG(2, NUMERIC_t); gtk_list_store_insert(GTK_LIST_STORE(cslist->object), &iter, position); __list_store_set(cm, &iter, 3); path = gtk_tree_model_get_path(GTK_TREE_MODEL(GTK_LIST_STORE(cslist->object)), &iter); path_string = gtk_tree_path_to_string(path); _clip_retc(cm, path_string); g_free(path_string); return 0; err: return 1; }
/* * Convert a model/owner pair into a gtk_tree_model_path. This * routine should only be called from the file * gnc-tree-view-owner.c. */ GtkTreePath * gnc_tree_model_owner_get_path_from_owner (GncTreeModelOwner *model, GncOwner *owner) { GtkTreeIter tree_iter; GtkTreePath *tree_path; ENTER("model %p, owner %p", model, owner); gnc_leave_return_val_if_fail (GNC_IS_TREE_MODEL_OWNER (model), NULL); gnc_leave_return_val_if_fail (owner != NULL, NULL); if (!gnc_tree_model_owner_get_iter_from_owner (model, owner, &tree_iter)) { LEAVE("no iter"); return NULL; } tree_path = gtk_tree_model_get_path (GTK_TREE_MODEL(model), &tree_iter); if (tree_path) { gchar *path_string = gtk_tree_path_to_string(tree_path); LEAVE("path (2) %s", path_string); g_free(path_string); } else { LEAVE("no path"); } return tree_path; }
int clip_GTK_LISTSTOREAPPEND(ClipMachine * cm) { C_object *cslist = _fetch_co_arg(cm); GtkTreeIter iter; GtkTreePath *path; gchar *path_string; CHECKCOBJ(cslist, GTK_IS_LIST_STORE(cslist->object)); gtk_list_store_append(GTK_LIST_STORE(cslist->object), &iter); __list_store_set(cm, &iter, 2); path = gtk_tree_model_get_path(GTK_TREE_MODEL(GTK_LIST_STORE(cslist->object)), &iter); path_string = gtk_tree_path_to_string(path); _clip_retc(cm, path_string); g_free(path_string); return 0; err: return 1; }
/* Given a drop path retrieved by gtk_tree_view_get_dest_row_at_pos, this function * determines whether dropping a bookmark item at the specified path is allow. * If dropping is not allowed, this function tries to choose an alternative position * for the bookmark item and modified the tree path @tp passed into this function. */ static gboolean get_bookmark_drag_dest(FmPlacesView* view, GtkTreePath** tp, GtkTreeViewDropPosition* pos) { gboolean ret = TRUE; if(*tp) { /* if the drop site is below the separator (in the bookmark area) */ if(fm_places_model_path_is_bookmark(FM_PLACES_MODEL(model), *tp)) { /* we cannot drop into a item */ if(*pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE || *pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER) ret = FALSE; else ret = TRUE; } else /* the drop site is above the separator (in the places area containing volumes) */ { const GtkTreePath* sep = fm_places_model_get_separator_path(FM_PLACES_MODEL(model)); /* set drop site at the first bookmark item */ gtk_tree_path_get_indices(*tp)[0] = gtk_tree_path_get_indices(sep)[0] + 1; *pos = GTK_TREE_VIEW_DROP_BEFORE; ret = TRUE; } } else { /* drop at end of the bookmarks list instead */ *tp = gtk_tree_path_new_from_indices(gtk_tree_model_iter_n_children(GTK_TREE_MODEL(model), NULL) - 1, -1); *pos = GTK_TREE_VIEW_DROP_AFTER; ret = TRUE; } g_debug("path: %s", gtk_tree_path_to_string(*tp)); return ret; }
/** * trace_view_get_selected_row - return the selected row * @treeview: The tree view * * Returns the selected row number (or -1 if none is selected) */ gint trace_view_get_selected_row(GtkWidget *treeview) { GtkTreeView *tree = GTK_TREE_VIEW(treeview); GtkTreeSelection *selection; GtkTreeModel *model; GtkTreePath *path; gchar *spath; GList *glist; gint row; model = gtk_tree_view_get_model(tree); if (!model) return -1; selection = gtk_tree_view_get_selection(tree); glist = gtk_tree_selection_get_selected_rows(selection, &model); if (!glist) return -1; /* Only one row may be selected */ path = glist->data; spath = gtk_tree_path_to_string(path); row = atoi(spath); g_free(spath); gtk_tree_path_free(path); g_list_free(glist); return row; }
void print_tree_selection(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data) { gint columns = gtk_tree_model_get_n_columns(model); // Print the path of the selection g_printf("\t%s", gtk_tree_path_to_string(path)); // Print all the text columns for (gint i = 0; i < columns; ++i) { GValue value = {0}; GValue str_value = {0}; gtk_tree_model_get_value(model, iter, i, &value); g_value_init(&str_value, G_TYPE_STRING); if (g_value_type_transformable(G_VALUE_TYPE(&value), G_TYPE_STRING)) { g_value_transform(&value, &str_value); g_printf("\t%s", g_value_get_string(&str_value)); } g_value_unset(&value); } }
void saa_tree_view_row_activated(SaaTreeView * tv, GtkTreePath * path, GtkTreeViewColumn * column, gpointer user_data) { gchar * spath = gtk_tree_path_to_string(path); gchar ** splited = g_strsplit(spath, ":", -1); int ind1, ind2; g_return_if_fail(splited[1]); ind1 = atoi(splited[0]); ind2 = atoi(splited[1]); g_free(spath); g_strfreev(splited); //g_debug("row_activated %d %d", ind1, ind2); switch(ind1) { case 0: g_signal_emit (G_OBJECT (tv), tree_view_signals[VERTEX_SELECTED_SIGNAL], 0, tv->visuel->solide->lesSommets[ind2]); break; case 1: g_signal_emit (G_OBJECT (tv), tree_view_signals[EDGE_SELECTED_SIGNAL], 0, tv->visuel->solide->lesAretes[ind2]); break; case 2: g_signal_emit (G_OBJECT (tv), tree_view_signals[WING_SELECTED_SIGNAL], 0, tv->visuel->solide->lesAiles[ind2]); break; } }
static void ListView_activate(GtkTreeView* treeView, GtkTreePath* path, GtkTreeViewColumn* column, ListView* self) { char* pathname = gtk_tree_path_to_string(path); unsigned selection = decimal(pathname); g_free(pathname); self->state.selection = selection; if(self->onActivate) self->onActivate(); }
static void open_dir(GtkTreeView *tree_view, GtkTreePath *path, GtkTreeViewColumn *column, gpointer user_data) { GtkTreeIter iter; GtkTreeModel *model; char *dir, *url; model = gtk_tree_view_get_model(tree_view); if (!gtk_tree_model_get_iter(model, &iter, path)) { char *p; p = gtk_tree_path_to_string(path); g_warning("Cannot get iter for path '%s'\n", p); g_free(p); return; } gtk_tree_model_get(model, &iter, DISK_DIR, &dir, -1); url = g_strdup_printf("file://%s", dir); GError* error = 0; if (!g_app_info_launch_default_for_uri(url, NULL, &error)) { g_warning("Cannot open '%s' : %s\n", url, error->message); g_error_free(error); } g_free(url); g_free(dir); }
gboolean GN_tree_view_get_selected(int ARI, ei_x_buff *XBUF, char *B, int *I){ GtkTreeView *tv; GtkTreeSelection *selection; GtkTreeModel *model; gchar* path; if ( ! gn_check_arity(XBUF, 1, ARI) ) return FALSE; if ( ! gn_get_arg_object(XBUF, B, I, GTK_TYPE_TREE_VIEW, (GObject**)&tv) ) return FALSE; model = gtk_tree_view_get_model(tv); selection = gtk_tree_view_get_selection(tv); GList* list = gtk_tree_selection_get_selected_rows(selection, &model); gn_wrap_reply("ok", XBUF); while ( list ) { path = gtk_tree_path_to_string( (GtkTreePath*) list->data); g_assert( ! ei_x_encode_list_header(XBUF, 1) ); g_assert( ! ei_x_encode_string(XBUF, path) ); g_free(path); list = list->next; } g_list_free(list); g_assert( ! ei_x_encode_empty_list(XBUF)); return TRUE; }
gboolean replay_message_tree_set_recv_event(ReplayMessageTree *self, GtkTreeIter *iter, GtkTreePath *recv_list_path) { ReplayMessageTreePrivate *priv; ReplayMessageTreeEntry *entry; g_return_val_if_fail(REPLAY_IS_MESSAGE_TREE(self), FALSE); priv = self->priv; g_return_val_if_fail(priv->stamp == iter->stamp, FALSE); entry = (ReplayMessageTreeEntry *)(iter->user_data); if (recv_list_path && (entry->recv_iter_set = gtk_tree_model_get_iter(GTK_TREE_MODEL(priv->event_store), &(entry->recv_list_iter), recv_list_path))) { gchar *path_string = gtk_tree_path_to_string(recv_list_path); g_hash_table_insert(priv->path_table, path_string, entry); } return entry->recv_iter_set; }
static VALUE rg_to_str(VALUE self) { gchar* s = gtk_tree_path_to_string(_SELF(self)); VALUE result = CSTR2RVAL(s); g_free(s); return result; }
/*# @method to_string GtkTreePath @brief Generates a string representation of the path. @return a string This string is a ':' separated list of numbers. For example, "4:10:0:3" would be an acceptable return value for this string. */ FALCON_FUNC TreePath::to_string( VMARG ) { NO_ARGS MYSELF; gchar* s = gtk_tree_path_to_string( self->getTreePath() ); vm->retval( UTF8String( s ) ); g_free( s ); }
void collapseRow(GtkTreeView* treeview,GtkTreeIter* iter,GtkTreePath* path,gpointer user_data) { char* pathstring=gtk_tree_path_to_string(path); if(strcmp(pathstring,"0")==0) flag=false; debugFree(&pathstring); }
gboolean table_check_func (GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer user_data) { gchar *description, *icon, *params; gchar *tree_path_str; gboolean has_child; gint depth; gtk_tree_model_get (model, iter, COL_DESCRIPTION, &description, COL_ICONNAME, &icon, COL_PARAMS, ¶ms, -1); tree_path_str = gtk_tree_path_to_string(path); has_child = gtk_tree_model_iter_has_child (model, iter); depth = gtk_tree_path_get_depth (path) - 1; gv.app_errno = 0; strcpy (gv.app_errno_str, ""); if (depth + 1 >= MAX_RECURSION) { g_print ("maximum menu recursion reached! -> %d\n", MAX_RECURSION); return TRUE; } if (depth > 0) { if (has_child) { /* some checks for submenus */ if (!strcmp (params, "")) { gv.app_errno = AE_EMPTY_SUBMENU; strncpy (gv.app_errno_str, tree_path_str, APP_ERRNO_STR_LEN); return TRUE; } } else { /* some checks for entries */ } } else { /* check for root node */ } g_free(tree_path_str); g_free(description); g_free(icon); g_free(params); return FALSE; }
static void row_changed (GtkTreeModel *tree_model, GtkTreePath *path, GtkTreeIter *iter, gpointer user_data) { _terminal_debug_print (TERMINAL_DEBUG_ACCELS, "ROW-CHANGED [%s]\n", gtk_tree_path_to_string (path) /* leak */); }
static void log_operation_for_path (GtkTreePath *path, const char *operation_name) { char *path_string; path_string = path ? gtk_tree_path_to_string (path) : g_strdup (""); g_printerr ("%10s %s\n", operation_name, path_string); g_free (path_string); }
static void test_position (GtkTreeView *tree_view, GtkTreePath *path, gboolean use_align, gdouble row_align) { gint pos; gchar *path_str; GdkRectangle rect; GtkTreeModel *model; gint row_start; /* Get the location of the path we scrolled to */ gtk_tree_view_get_background_area (GTK_TREE_VIEW (tree_view), path, NULL, &rect); row_start = get_row_start_for_index (GTK_TREE_VIEW (tree_view), gtk_tree_path_get_indices (path)[0]); /* Ugh */ pos = get_pos_from_path (GTK_TREE_VIEW (tree_view), path, rect.height, gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (tree_view))); /* This is only tested for during test_single() */ model = gtk_tree_view_get_model (GTK_TREE_VIEW (tree_view)); if (gtk_tree_model_iter_n_children (model, NULL) == 1) { GtkAllocation allocation; GtkTreePath *tmppath; /* Test nothing is dangling at the bottom; read * description for test_single() for more information. */ /* FIXME: hardcoded width */ gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation); if (gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (tree_view), 0, allocation.height - 30, &tmppath, NULL, NULL, NULL)) { g_assert_not_reached (); gtk_tree_path_free (tmppath); } } path_str = gtk_tree_path_to_string (path); if (use_align) { assert_position_with_align (tree_view, pos, rect.y, row_start, rect.height, row_align); } else { assert_position_without_align (tree_view, row_start, rect.height); } g_free (path_str); }
/****************************************************************************** * gtk_TreeStoreInsertAfter(tree, parent_path_string/NULL, sibling_path_string/NULL, ncol, val, ....)-->path_string ******************************************************************************/ int clip_GTK_TREESTOREINSERTAFTER(ClipMachine * ClipMachineMemory) { C_object *cstree = _fetch_co_arg(ClipMachineMemory); gchar *parent = _clip_parc(ClipMachineMemory, 2); gchar *sibling = _clip_parc(ClipMachineMemory, 3); GtkTreeIter iter; GtkTreeIter parentiter; GtkTreeIter siblingiter; GtkTreePath *path; gchar *path_string; CHECKARG2(1, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType); CHECKCOBJ(cstree, GTK_IS_TREE_STORE(cstree->object)); CHECKOPT(2, CHARACTER_type_of_ClipVarType); CHECKOPT(3, CHARACTER_type_of_ClipVarType); if (parent) gtk_tree_model_get_iter(GTK_TREE_MODEL(GTK_TREE_STORE(cstree->object)), &parentiter, gtk_tree_path_new_from_string(parent)); if (sibling) gtk_tree_model_get_iter(GTK_TREE_MODEL(GTK_TREE_STORE(cstree->object)), &siblingiter, gtk_tree_path_new_from_string(sibling)); gtk_tree_store_insert_after(GTK_TREE_STORE(cstree->object), &iter, (parent ? &parentiter : NULL), (sibling ? &siblingiter : NULL)); __tree_store_set(ClipMachineMemory, &iter, 4); path = gtk_tree_model_get_path(GTK_TREE_MODEL(GTK_TREE_STORE(cstree->object)), &iter); path_string = gtk_tree_path_to_string(path); _clip_retc(ClipMachineMemory, path_string); g_free(path_string); return 0; err: return 1; }
/** * called when we begin a drag, * find what cell was under the cursor and change it * * \param tree_view * \param drag_context * \param null * * \return FALSE * */ gboolean gsb_form_config_drag_begin ( GtkWidget *tree_view, GdkDragContext *drag_context, gpointer null ) { gint x, y; GtkTreePath *path; GtkTreeViewColumn *tree_column; GdkWindow *drawable; GdkRectangle rectangle; GdkPixbuf *pixbuf_cursor; /* get the cell coord */ gdk_window_get_pointer ( gtk_tree_view_get_bin_window ( GTK_TREE_VIEW ( tree_view )), &x, &y, FALSE ); gtk_tree_view_get_path_at_pos ( GTK_TREE_VIEW ( tree_view ), x, y, &path, &tree_column, NULL, NULL ); if ( !path || !tree_column ) return FALSE; start_drag_column = g_list_index ( gtk_tree_view_get_columns ( GTK_TREE_VIEW ( tree_view )), tree_column ); start_drag_row = utils_str_atoi ( gtk_tree_path_to_string ( path )); /* draw the new cursor */ drawable = gtk_tree_view_get_bin_window (GTK_TREE_VIEW ( tree_view )); gtk_tree_view_get_cell_area ( GTK_TREE_VIEW ( tree_view ), path, tree_column, &rectangle ); pixbuf_cursor = gdk_pixbuf_get_from_drawable ( NULL, GDK_DRAWABLE (drawable), gdk_colormap_get_system (), rectangle.x, rectangle.y, 0, 0, rectangle.width, rectangle.height ); gtk_drag_source_set_icon_pixbuf ( tree_view, pixbuf_cursor ); g_object_unref (pixbuf_cursor); return FALSE; }
static char* set_row_data (GtkTreeStore *store, char *path, char *parent, const char *attribute, const char *value) { GtkTreeIter iter; gchar *utf_attribute = NULL; gchar *utf_value = NULL; gboolean iter_valid = FALSE; if (!attribute) return NULL; if (path != NULL) { iter_valid = gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (store), &iter, path); } if (!iter_valid) { GtkTreePath *tree_path; GtkTreeIter parent_iter; gboolean parent_valid = FALSE; if (parent != NULL) { parent_valid = gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (store), &parent_iter, parent); } gtk_tree_store_append (store, &iter, parent_valid ? &parent_iter : NULL); if (path == NULL) { tree_path = gtk_tree_model_get_path (GTK_TREE_MODEL (store), &iter); if (tree_path != NULL) { path = gtk_tree_path_to_string (tree_path); gtk_tree_path_free (tree_path); } } } utf_attribute = eog_util_make_valid_utf8 (attribute); gtk_tree_store_set (store, &iter, MODEL_COLUMN_ATTRIBUTE, utf_attribute, -1); g_free (utf_attribute); if (value != NULL) { utf_value = eog_util_make_valid_utf8 (value); gtk_tree_store_set (store, &iter, MODEL_COLUMN_VALUE, utf_value, -1); g_free (utf_value); } return path; }
static void item_deleted_cb (GtkTreeModel *tree_model, GtkTreePath *path, PhidiasItemsGeo *item) { gchar *str; ClutterActor *marker; str = gtk_tree_path_to_string (path); marker = g_hash_table_lookup (item->priv->markers, str); if (marker != NULL) { champlain_marker_layer_remove_marker (item->priv->current_layer, CHAMPLAIN_MARKER (marker)); g_hash_table_remove (item->priv->markers, str); } g_free (str); }
/* Get currently selected row */ static int nc_cur_row ( void ) { GtkTreeModel * m = gtk_tree_view_get_model( view ); GList * l = gtk_tree_selection_get_selected_rows( _sel, &m ); char * b; int ret; if( !l ) return -1; b = gtk_tree_path_to_string(l->data); if( !b ) return -1; ret = atoi( b ); g_free( b ); g_list_free( l ); return ret; }
void NedMidiRecordConfigDialog::OnClose(GtkDialog *dialog, gint result, gpointer data) { NedMidiRecordConfigDialog *midi_record_dialog = (NedMidiRecordConfigDialog *) data; int i; GtkTreeSelection* selection; GList *selected_rows; switch (result) { case GTK_RESPONSE_ACCEPT: midi_record_dialog->m_state = TRUE; break; default: midi_record_dialog->m_state = FALSE; gtk_widget_destroy (GTK_WIDGET(dialog)); return; break; } midi_record_dialog->m_num = (int) gtk_spin_button_get_value(GTK_SPIN_BUTTON(midi_record_dialog->m_numerator)); switch (gtk_combo_box_get_active(GTK_COMBO_BOX(midi_record_dialog->m_denominator))) { case 0: midi_record_dialog->m_denom = 2; break; case 1: midi_record_dialog->m_denom = 4; break; case 2: midi_record_dialog->m_denom = 8; break; default: midi_record_dialog->m_denom = 16; break; } selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(midi_record_dialog->m_instrument_list)); selected_rows = gtk_tree_selection_get_selected_rows (selection, NULL); if ( g_list_length(selected_rows) > 0) { GtkTreePath *path = (GtkTreePath *) g_list_first(selected_rows)->data; char *tp = gtk_tree_path_to_string(path); if (sscanf(tp, "%d", &(midi_record_dialog->m_pgm)) != 1) { NedResource::Abort("NedMidiRecordConfigDialog::OnClose: error reading tree path(1)"); } } else { midi_record_dialog->m_pgm = 0; } midi_record_dialog->m_triplet = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(midi_record_dialog->m_with_triplet_button)); midi_record_dialog->m_f_piano = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(midi_record_dialog->m_force_piano_button)); midi_record_dialog->m_dnt_split = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(midi_record_dialog->m_dont_split_button)); midi_record_dialog->m_tempo_inverse = (int) (100000.0 * gtk_range_get_value(GTK_RANGE(midi_record_dialog->m_tempo_scale)) / 60.0); midi_record_dialog->m_metro_volume = (int) gtk_range_get_value(GTK_RANGE(midi_record_dialog->m_metro_volume_scale)); midi_record_dialog->m_keysig = 0; for (i = 0; i < 13; i++) { if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (midi_record_dialog->m_sig_radio_buttons[i]))) { midi_record_dialog->m_keysig = i - 6; } } gtk_widget_destroy (GTK_WIDGET(dialog)); }