static void iopen_enter(editor_t *editor) {
GtkTreePath *path;
gtk_tree_view_get_cursor(GTK_TREE_VIEW(results_tree), &path, NULL);
if (path == NULL) {
path = gtk_tree_path_new_first();
}
iopen_open(GTK_TREE_VIEW(results_tree), path);
gtk_tree_path_free(path);
}
static VALUE
rg_cursor(VALUE self)
{
GtkTreePath* path;
GtkTreeViewColumn* focus_column;
gtk_tree_view_get_cursor(_SELF(self), &path, &focus_column);
return rb_ary_new3(2, path ? GTKTREEPATH2RVAL(path) : Qnil,
GOBJ2RVAL(focus_column));
}
/* User click: update choice (full) or goes down (single) */
gboolean
on_treeview2_button_press_event(GtkWidget * widget,
GdkEventButton * event, gpointer user_data)
{
GtkTreeView *view = GTK_TREE_VIEW(widget);
GtkTreePath *path;
GtkTreeViewColumn *column;
GtkTreeIter iter;
struct menu *menu;
gint col;
#if GTK_CHECK_VERSION(2,1,4) // bug in ctree with earlier version of GTK
gint tx = (gint) event->x;
gint ty = (gint) event->y;
gint cx, cy;
gtk_tree_view_get_path_at_pos(view, tx, ty, &path, &column, &cx,
&cy);
#else
gtk_tree_view_get_cursor(view, &path, &column);
#endif
if (path == NULL)
return FALSE;
if (!gtk_tree_model_get_iter(model2, &iter, path))
return FALSE;
gtk_tree_model_get(model2, &iter, COL_MENU, &menu, -1);
col = column2index(column);
if (event->type == GDK_2BUTTON_PRESS) {
enum prop_type ptype;
ptype = menu->prompt ? menu->prompt->type : P_UNKNOWN;
if (ptype == P_MENU && view_mode != FULL_VIEW && col == COL_OPTION) {
// goes down into menu
current = menu;
display_tree_part();
gtk_widget_set_sensitive(back_btn, TRUE);
} else if ((col == COL_OPTION)) {
toggle_sym_value(menu);
gtk_tree_view_expand_row(view, path, TRUE);
}
} else {
if (col == COL_VALUE) {
toggle_sym_value(menu);
gtk_tree_view_expand_row(view, path, TRUE);
} else if (col == COL_NO || col == COL_MOD
|| col == COL_YES) {
change_sym_value(menu, col);
gtk_tree_view_expand_row(view, path, TRUE);
}
}
return FALSE;
}
gboolean vdtree_press_key_cb(GtkWidget *widget, GdkEventKey *event, gpointer data)
{
ViewDir *vd = data;
GtkTreePath *tpath;
GtkTreeIter iter;
FileData *fd = NULL;
gtk_tree_view_get_cursor(GTK_TREE_VIEW(vd->view), &tpath, NULL);
if (tpath)
{
GtkTreeModel *store;
NodeData *nd;
store = gtk_tree_view_get_model(GTK_TREE_VIEW(widget));
gtk_tree_model_get_iter(store, &iter, tpath);
gtk_tree_model_get(store, &iter, DIR_COLUMN_POINTER, &nd, -1);
gtk_tree_path_free(tpath);
fd = (nd) ? nd->fd : NULL;
}
switch (event->keyval)
{
case GDK_KEY_Menu:
vd->click_fd = fd;
vd_color_set(vd, vd->click_fd, TRUE);
vd->popup = vd_pop_menu(vd, vd->click_fd);
gtk_menu_popup(GTK_MENU(vd->popup), NULL, NULL, vd_menu_position_cb, vd, 0, GDK_CURRENT_TIME);
return TRUE;
break;
case GDK_KEY_plus:
case GDK_KEY_Right:
case GDK_KEY_KP_Add:
if (fd)
{
vdtree_populate_path_by_iter(vd, &iter, FALSE, vd->dir_fd);
if (islink(fd->path))
{
vdtree_icon_set_by_iter(vd, &iter, vd->pf->link);
}
else
{
vdtree_icon_set_by_iter(vd, &iter, vd->pf->open);
}
}
break;
}
return FALSE;
}
/****************************************************************
Removal of the item requested
*****************************************************************/
static void queue_remove(struct worklist_data *ptr)
{
GtkTreePath *path;
GtkTreeViewColumn *col;
gtk_tree_view_get_cursor(GTK_TREE_VIEW(ptr->dst_view), &path, &col);
if (path) {
dst_row_callback(GTK_TREE_VIEW(ptr->dst_view), path, col, ptr);
gtk_tree_path_free(path);
}
}
gboolean rc_gui_list1_get_cursor(GtkTreeIter *iter)
{
GtkTreePath *path;
gboolean flag;
gtk_tree_view_get_cursor(GTK_TREE_VIEW(rc_ui->list1_tree_view), &path,
NULL);
flag = gtk_tree_model_get_iter(GTK_TREE_MODEL(rc_ui->list1_tree_model),
iter, path);
gtk_tree_path_free(path);
return flag;
}
/** Handler for the "cursor-changed" signal that forces the cursor to stay on
* the first column.
*
* This will disallow the selection of option descriptions during multiselect.
*
* @param view the tree view
* @param fe cdebconf frontend
*/
static void handle_cursor_changed(GtkTreeView * view,
struct frontend * fe)
{
GtkTreePath * path;
gtk_tree_view_get_cursor(view, &path, NULL);
g_signal_handlers_block_by_func(view, handle_cursor_changed, fe);
gtk_tree_view_set_cursor(view, path, gtk_tree_view_get_column(view, 0),
FALSE /* no editing */);
g_signal_handlers_unblock_by_func(view, handle_cursor_changed, fe);
}
/**
* autoar_gtk_chooser_advanced_get:
* @advanced: a #GtkGrid returned by autoar_gtk_chooser_advanced_new()
* @format: the place to store the #AutoarFormat selected by the user
* @filter: the place to store the #AutoarFilter selected by the user
*
* Gets the selected archive format of the widget created by
* autoar_gtk_chooser_advanced_new().
*
* Returns: %TRUE if @format and @filter are set. %FALSE if there is no
* selected item on @advanced, so @format and @filter are not modified.
**/
gboolean
autoar_gtk_chooser_advanced_get (GtkWidget *advanced,
int *format,
int *filter)
{
GtkGrid *grid;
GtkTreeIter format_iter, filter_iter;
GtkTreeView *format_view, *filter_view;
GtkTreePath *format_path, *filter_path;
GtkTreeModel *format_model, *filter_model;
grid = GTK_GRID (advanced);
format_view = GTK_TREE_VIEW (gtk_grid_get_child_at (grid, 0, 0));
filter_view = GTK_TREE_VIEW (gtk_grid_get_child_at (grid, 1, 0));
gtk_tree_view_get_cursor (format_view, &format_path, NULL);
gtk_tree_view_get_cursor (filter_view, &filter_path, NULL);
if (format_path == NULL || filter_path == NULL) {
gtk_tree_path_free (format_path);
gtk_tree_path_free (filter_path);
return FALSE;
}
format_model = gtk_tree_view_get_model (format_view);
filter_model = gtk_tree_view_get_model (filter_view);
if (!gtk_tree_model_get_iter (format_model, &format_iter, format_path) ||
!gtk_tree_model_get_iter (filter_model, &filter_iter, filter_path)) {
gtk_tree_path_free (format_path);
gtk_tree_path_free (filter_path);
return FALSE;
}
gtk_tree_path_free (format_path);
gtk_tree_path_free (filter_path);
gtk_tree_model_get (format_model, &format_iter,
ADVANCED_FORMAT_COL_FORMAT, format, -1);
gtk_tree_model_get (filter_model, &filter_iter,
ADVANCED_FILTER_COL_FILTER, filter, -1);
return TRUE;
}
static void
tree_view_activate_focused_row (GtkTreeView *view)
{
GtkTreePath *path;
GtkTreeViewColumn *column;
gtk_tree_view_get_cursor (view, &path, &column);
if (path) {
gtk_tree_view_row_activated (view, path, column);
gtk_tree_path_free (path);
}
}
void FormAccount_CursorChanged(GtkTreeView* treeview, gpointer user_data)
{
GtkTreePath* treepath;
FormAccount* fa = (FormAccount*) user_data;
GtkTreeModel* model;
GtkTreeIter iter;
gchar* OperationID;
gchar* DateStr;
guint DateYear;
guint DateMonth;
guint DateDay;
gchar* DateStr1;
gchar* DateStr2;
gchar* Description;
gdouble Money;
guint Category;
gchar Buf[50];
model = gtk_tree_view_get_model(treeview);
gtk_tree_view_get_cursor(GTK_TREE_VIEW(fa->ListViewAccount), &treepath, NULL);
gtk_tree_model_get_iter(model, &iter, treepath);
gtk_tree_model_get(model, &iter,
COL_ID_OPERATION_ID, &OperationID,
COL_ID_DATE, &DateStr,
COL_ID_DESCRIPTION, &Description,
COL_ID_MONEY, &Money,
COL_ID_CATEGORY_ID, &Category, -1);
if (DateStr != NULL && DateStrToDMY(DateStr, &DateYear, &DateMonth, &DateDay) != -1)
{
fa->CalendarDateOnSelectEnabled = FALSE;
gtk_calendar_select_day(GTK_CALENDAR(fa->CalendarDate), 0);
gtk_calendar_select_month(GTK_CALENDAR(fa->CalendarDate), DateMonth-1, DateYear);
gtk_calendar_select_day(GTK_CALENDAR(fa->CalendarDate), DateDay);
fa->CalendarDateOnSelectEnabled = TRUE;
}
gtk_entry_set_text(GTK_ENTRY(fa->EntryDescription), Description != NULL ? Description : "");
sprintf(Buf, "%.2f", Money);
gtk_entry_set_text(GTK_ENTRY(fa->EntryMoney), Buf);
gtk_tree_path_free(treepath);
if (OperationID != NULL) g_free(OperationID);
if (DateStr != NULL) g_free(DateStr);
if (Description != NULL) g_free(Description);
}
static void on_cursor_changed (GtkTreeView* view, UgtkSettingDialog* sdialog)
{
GtkTreePath* path;
int nth;
gtk_tree_view_get_cursor (view, &path, NULL);
if (path == NULL)
return;
nth = *gtk_tree_path_get_indices (path);
gtk_tree_path_free (path);
gtk_notebook_set_current_page (sdialog->notebook, nth);
}
static void gui_calls_select_callback()
{
debug("gui_calls_select_callback\n");
GtkTreePath *path;
gtk_tree_view_get_cursor(GTK_TREE_VIEW(g_calls_manager.dials_view),&path,NULL);
GtkTreeIter iter;
GValue value={0};
gtk_tree_model_get_iter(GTK_TREE_MODEL(g_calls_manager.dials_store),&iter,path);
gtk_tree_path_free(path);
gtk_tree_model_get_value(GTK_TREE_MODEL(g_calls_manager.dials_store),&iter,0,&value);
const gchar *status=g_value_get_string(&value);
if(!g_strcmp0(status,"active")){
gtk_widget_hide(g_calls_manager.activate_button);
gtk_widget_hide(g_calls_manager.answer_waiting_button);
gtk_widget_hide(g_calls_manager.answer_button);
gtk_widget_show(g_calls_manager.hangup_button);
}else if(!g_strcmp0(status,"held")){
gtk_widget_show(g_calls_manager.activate_button);
gtk_widget_hide(g_calls_manager.answer_waiting_button);
gtk_widget_hide(g_calls_manager.answer_button);
gtk_widget_show(g_calls_manager.hangup_button);
}else if(!g_strcmp0(status,"dialing")){
gtk_widget_hide(g_calls_manager.activate_button);
gtk_widget_hide(g_calls_manager.answer_waiting_button);
gtk_widget_hide(g_calls_manager.answer_button);
gtk_widget_show(g_calls_manager.hangup_button);
}else if(!g_strcmp0(status,"alerting")){
gtk_widget_hide(g_calls_manager.activate_button);
gtk_widget_hide(g_calls_manager.answer_waiting_button);
gtk_widget_hide(g_calls_manager.answer_button);
gtk_widget_show(g_calls_manager.hangup_button);
}else if(!g_strcmp0(status,"incoming")){
gtk_widget_hide(g_calls_manager.activate_button);
gtk_widget_hide(g_calls_manager.answer_waiting_button);
gtk_widget_show(g_calls_manager.answer_button);
gtk_widget_show(g_calls_manager.hangup_button);
}else if(!g_strcmp0(status,"waiting")){
gtk_widget_hide(g_calls_manager.activate_button);
gtk_widget_show(g_calls_manager.answer_waiting_button);
gtk_widget_hide(g_calls_manager.answer_button);
gtk_widget_show(g_calls_manager.hangup_button);
}else{
gtk_widget_hide(g_calls_manager.activate_button);
gtk_widget_hide(g_calls_manager.answer_waiting_button);
gtk_widget_hide(g_calls_manager.answer_button);
gtk_widget_show(g_calls_manager.hangup_button);
}
g_value_unset(&value);
}
static void
on_panel_hide (GtkWidget *widget,
gpointer dummy)
{
GtkTreeView *view = GTK_TREE_VIEW (plugin_data.view);
if (plugin_data.last_path) {
gtk_tree_path_free (plugin_data.last_path);
plugin_data.last_path = NULL;
}
gtk_tree_view_get_cursor (view, &plugin_data.last_path, NULL);
gtk_list_store_clear (plugin_data.store);
}
static void
maybe_check_cursor_position (GtkTreeView *treeview,
gint x,
gint y,
gint width,
gint height,
ThemeMatchData *match_data)
{
GtkTreePath *cursor_path;
GdkRectangle cursor_rect;
GdkRectangle paint_rect;
gtk_tree_view_get_cursor (treeview, &cursor_path, NULL);
if (!cursor_path)
return;
/* we only really care about the vertical position here */
gtk_tree_view_get_background_area (treeview, cursor_path, NULL, &cursor_rect);
gtk_tree_path_free (cursor_path);
paint_rect.y = y;
paint_rect.height = height;
paint_rect.x = cursor_rect.x = x;
paint_rect.width = cursor_rect.width = width;
if (!gdk_rectangle_intersect (&paint_rect, &cursor_rect, &paint_rect))
return;
/* We're painting the cursor row background, so distinguish between focused
* and non-focused treeview so that we can paint the passive focus ring when
* non-focused. (gtk_paint_focus is used to paint the focus ring when focused.)
* Knowing that treeview always uses GTK_SHADOW_NONE, it should be (more or
* less) safe to (ab)use it for passive focus.
*
* Passive focus:
* function = FLAT_BOX
* state = SELECTED / NORMAL
* shadow = OUT
*
* Selection / normal row:
* function = FLAT_BOX
* state = SELECTED / NORMAL
* shadow = NONE
*/
if (!gtk_widget_has_focus (GTK_WIDGET (treeview)))
match_data->shadow = GTK_SHADOW_OUT;
}
void
uim_cand_win_gtk_real_layout_sub_window(UIMCandWinGtk *cwin)
{
#if GTK_CHECK_VERSION(2, 90, 0)
gint x, y, w, h, sw, sh, x2, y2, w2, h2;
#else
gint x, y, w, h, d, sw, sh, x2, y2, w2, h2, d2;
#endif
GdkRectangle rect;
GtkTreePath *path;
GtkTreeViewColumn *focus_column;
if (!cwin->sub_window.window)
return;
gtk_tree_view_get_cursor(GTK_TREE_VIEW(cwin->view), &path, &focus_column);
gtk_tree_view_get_cell_area(GTK_TREE_VIEW(cwin->view), path, NULL, &rect);
gtk_tree_path_free(path);
#if GTK_CHECK_VERSION(2, 90, 0)
gdk_window_get_geometry(gtk_widget_get_window(GTK_WIDGET(cwin)),
&x, &y, &w, &h);
#else
gdk_window_get_geometry(gtk_widget_get_window(GTK_WIDGET(cwin)),
&x, &y, &w, &h, &d);
#endif
gdk_window_get_origin(gtk_widget_get_window(GTK_WIDGET(cwin)), &x, &y);
sw = gdk_screen_get_width (gdk_screen_get_default ());
sh = gdk_screen_get_height (gdk_screen_get_default ());
#if GTK_CHECK_VERSION(2, 90, 0)
gdk_window_get_geometry(gtk_widget_get_window(cwin->sub_window.window),
&x2, &y2, &w2, &h2);
#else
gdk_window_get_geometry(gtk_widget_get_window(cwin->sub_window.window),
&x2, &y2, &w2, &h2, &d2);
#endif
if (x + w + w2 > sw)
x = x - w2;
else
x = x + w;
if ((y + rect.y + h2) > sh)
y = sh - h2;
else
y = y + rect.y;
gtk_window_move(GTK_WINDOW(cwin->sub_window.window), x, y);
}
static void
tasks_category_remove_cb (GtkWidget *widget, GUI *appGUI)
{
GtkTreePath *path;
GtkTreeIter iter;
gtk_tree_view_get_cursor (GTK_TREE_VIEW (appGUI->opt->tasks_category_treeview), &path, NULL);
if (path != NULL) {
gtk_tree_model_get_iter (GTK_TREE_MODEL (appGUI->opt->tasks_category_store), &iter, path);
gtk_list_store_remove (appGUI->opt->tasks_category_store, &iter);
gtk_tree_path_free (path);
refresh_tasks (appGUI);
}
}
static void gui_calls_hangup_callback()
{
GtkTreePath *path;
gtk_tree_view_get_cursor(GTK_TREE_VIEW(g_calls_manager.dials_view),&path,NULL);
GtkTreeIter iter;
GValue value={0};
gtk_tree_model_get_iter(GTK_TREE_MODEL(g_calls_manager.dials_store),&iter,path);
gtk_tree_path_free(path);
gtk_tree_model_get_value(GTK_TREE_MODEL(g_calls_manager.dials_store),&iter,2,&value);
SphoneCall *call=g_value_get_object(&value);
sphone_call_hangup(call);
g_value_unset(&value);
}
static gboolean tree_keypress(GtkTreeView *t, GdkEventKey *event, GtkWidget *entry)
{
if(event->keyval == GDK_Return) {
submit();
gtk_dialog_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
}
if(event->keyval == GDK_Up) {
GtkTreePath *current;
gtk_tree_view_get_cursor(t, ¤t, NULL);
if(gtk_tree_path_compare(current,first) == 0) {
gtk_widget_grab_focus(entry);
}
}
return FALSE;
}
static void
on_cursor_changed(GtkTreeView *tv, gpointer unused_udata)
{
GtkTreePath *path = NULL;
(void) unused_udata;
g_assert(tv != NULL);
gtk_tree_view_get_cursor(tv, &path, NULL);
if (path) {
update_tooltip(tv, path);
gtk_tree_path_free(path);
path = NULL;
}
}
static void _lib_modulelist_row_changed_callback(GtkTreeView *treeview, gpointer user_data)
{
dt_iop_module_t *module;
GtkTreeIter iter;
GtkTreeModel *model;
GtkTreePath *path;
gtk_tree_view_get_cursor(treeview, &path, NULL);
model = gtk_tree_view_get_model(treeview);
gtk_tree_model_get_iter(model, &iter, path);
gtk_tree_path_free(path);
gtk_tree_model_get(model, &iter, COL_MODULE, &module, -1);
dt_iop_gui_set_state(module,(module->state+1)%dt_iop_state_LAST);
}
gboolean
search_gui_has_selected_item(search_t *search)
{
GtkTreePath *path = NULL;
gboolean ret = FALSE;
g_return_val_if_fail(search, FALSE);
gtk_tree_view_get_cursor(GTK_TREE_VIEW(search->tree), &path, NULL);
if (path) {
ret = TRUE;
gtk_tree_path_free(path);
}
return ret;
}
static void
move_up (int val)
{
int i;
GtkTreePath *path;
GtkTreePath *tree_path;
GtkTreeIter iter1;
GtkTreeIter iter2;
GtkTreeModel *model;
model = gtk_tree_view_get_model (GTK_TREE_VIEW (main_gui.displayed_list));
gtk_tree_view_get_cursor (GTK_TREE_VIEW (main_gui.displayed_list), &path, NULL);
if (!gtk_tree_model_get_iter (GTK_TREE_MODEL (model), &iter1, path))
return;
for (i = 0; i < val; i++) {
if (!gtk_tree_path_prev (path)) {
if (!gtk_tree_path_up (path)) {
break;
} else {
if (!gtk_tree_model_get_iter (GTK_TREE_MODEL (model), &iter1, path))
break;
}
} else {
if (gtk_tree_view_row_expanded (GTK_TREE_VIEW (main_gui.displayed_list), path)) {
gtk_tree_path_down (path);
gtk_tree_model_get_iter (GTK_TREE_MODEL (model), &iter2, path);
iter1 = iter2;
while (gtk_tree_model_iter_next (GTK_TREE_MODEL (model), &iter2)) {
iter1 = iter2;
}
} else {
if (!gtk_tree_model_get_iter (GTK_TREE_MODEL (model), &iter1, path))
break;
}
}
}
tree_path = gtk_tree_model_get_path (GTK_TREE_MODEL (model), &iter1);
gtk_tree_view_set_cursor (GTK_TREE_VIEW (main_gui.displayed_list), tree_path, NULL, FALSE);
gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (main_gui.displayed_list), tree_path, NULL, TRUE, 0.5, 0);
gtk_tree_path_free (tree_path);
gtk_widget_grab_focus (main_gui.displayed_list);
}
gboolean vdtree_set_fd(ViewDir *vd, FileData *dir_fd)
{
FileData *fd;
GtkTreeIter iter;
if (!dir_fd) return FALSE;
if (vd->dir_fd == dir_fd) return TRUE;
file_data_unref(vd->dir_fd);
vd->dir_fd = file_data_ref(dir_fd);;
fd = vdtree_populate_path(vd, vd->dir_fd, TRUE, FALSE);
if (!fd) return FALSE;
if (vd_find_row(vd, fd, &iter))
{
GtkTreeModel *store;
GtkTreePath *tpath, *old_tpath;
GtkTreeSelection *selection;
store = gtk_tree_view_get_model(GTK_TREE_VIEW(vd->view));
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(vd->view));
/* hack, such that selection is only allowed to be changed from here */
selection_is_ok = TRUE;
gtk_tree_selection_select_iter(selection, &iter);
selection_is_ok = FALSE;
gtk_tree_view_get_cursor(GTK_TREE_VIEW(vd->view), &old_tpath, NULL);
tpath = gtk_tree_model_get_path(store, &iter);
if (!old_tpath || gtk_tree_path_compare(tpath, old_tpath) != 0)
{
/* setting the cursor scrolls the view; do not do that unless it is necessary */
gtk_tree_view_set_cursor(GTK_TREE_VIEW(vd->view), tpath, NULL, FALSE);
/* gtk_tree_view_set_cursor scrolls the window itself, but it sometimes
does not work (switch from dir_list to dir_tree) */
tree_view_row_make_visible(GTK_TREE_VIEW(vd->view), &iter, TRUE);
}
gtk_tree_path_free(tpath);
gtk_tree_path_free(old_tpath);
}
return TRUE;
}
static void on_notebook_page_changed(GtkNotebook *notebook, gpointer page,
guint n, GtkTreeView *view)
{
GtkTreePath *tp;
/* g_debug("changed pref page: %u", n); */
gtk_tree_view_get_cursor(view, &tp, NULL);
if (tp == NULL || gtk_tree_path_get_indices(tp)[0] != (int)n)
{
if (tp)
gtk_tree_path_free(tp);
tp = gtk_tree_path_new_from_indices(n, -1);
gtk_tree_view_set_cursor(view, tp, NULL, FALSE);
}
gtk_tree_path_free(tp);
}
SteadyflowCoreIDownloadFile* steadyflow_file_list_controller_get_selected_file (SteadyflowFileListController* self) {
SteadyflowCoreIDownloadFile* result = NULL;
gint _tmp0_ = 0;
GtkTreePath* path = NULL;
GtkTreeIter iter = {0};
GtkTreeView* _tmp1_;
GtkTreePath* _tmp2_ = NULL;
GtkTreePath* _tmp3_;
GtkListStore* _tmp4_;
GtkTreePath* _tmp5_;
GtkTreeIter _tmp6_ = {0};
gboolean _tmp7_ = FALSE;
g_return_val_if_fail (self != NULL, NULL);
_tmp0_ = steadyflow_file_list_controller_get_selection_count (self);
if (_tmp0_ != 1) {
result = NULL;
return result;
}
_tmp1_ = self->priv->tree;
gtk_tree_view_get_cursor (_tmp1_, &_tmp2_, NULL);
_gtk_tree_path_free0 (path);
path = _tmp2_;
_tmp3_ = path;
if (_tmp3_ == NULL) {
result = NULL;
_gtk_tree_path_free0 (path);
return result;
}
_tmp4_ = self->priv->model;
_tmp5_ = path;
_tmp7_ = gtk_tree_model_get_iter ((GtkTreeModel*) _tmp4_, &_tmp6_, _tmp5_);
iter = _tmp6_;
if (_tmp7_) {
GtkTreeIter _tmp8_;
SteadyflowCoreIDownloadFile* _tmp9_ = NULL;
_tmp8_ = iter;
_tmp9_ = steadyflow_file_list_controller_file_from_iter (self, &_tmp8_);
result = _tmp9_;
_gtk_tree_path_free0 (path);
return result;
} else {
result = NULL;
_gtk_tree_path_free0 (path);
return result;
}
_gtk_tree_path_free0 (path);
}
void library_view_play(GtkToolButton *btn, library_view_t* view)
{
//library_view_t* view = (library_view_t*) g_object_get_data(lview, "library_view_t");
playlist_player_t* player = backtobasics_player(view->btb);
if (!playlist_player_is_playing(player)) {
GtkTreeView* tview = view->tview;
GtkTreePath* path = NULL;
GtkTreeViewColumn* col = NULL;
gtk_tree_view_get_cursor(tview, &path, &col);
int index = 0;
if (path != NULL) {
int *i = gtk_tree_path_get_indices(path);
index = i[0];
}
library_view_play_at(view, index);
}
}
static void gui_calls_double_click_callback()
{
debug("gui_calls_select_callback\n");
GtkTreePath *path;
gtk_tree_view_get_cursor(GTK_TREE_VIEW(g_calls_manager.dials_view),&path,NULL);
GtkTreeIter iter;
GValue value={0};
gtk_tree_model_get_iter(GTK_TREE_MODEL(g_calls_manager.dials_store),&iter,path);
gtk_tree_path_free(path);
gtk_tree_model_get_value(GTK_TREE_MODEL(g_calls_manager.dials_store),&iter,GUI_CALLS_COLUMN_DIAL,&value);
const gchar *dial=g_value_get_string(&value);
gui_contact_open_by_dial(dial);
g_value_unset(&value);
}
static void gui_contact_book_double_click_callback(GtkTreeView *view, gpointer func_data)
{
GtkTreePath *path;
gtk_tree_view_get_cursor(view,&path,NULL);
debug("gui_contact_book_double_click_callback\n");
if(path){
GtkTreeModel *model=gtk_tree_view_get_model (view);
GtkTreeIter iter;
GValue value={0};
gtk_tree_model_get_iter(GTK_TREE_MODEL(model),&iter,path);
gtk_tree_path_free(path);
gtk_tree_model_get_value(model,&iter,SPHONE_STORE_TREE_MODEL_COLUMN_DIAL,&value);
const gchar *dial=g_value_get_string(&value);
gui_contact_open_by_dial(dial);
g_value_unset(&value);
}
}
void
on_trkproperties_edit_in_place_activate
(GtkMenuItem *menuitem,
gpointer user_data)
{
GtkTreeView *treeview = GTK_TREE_VIEW (lookup_widget (trackproperties, "metalist"));
GtkTreePath *path;
gtk_tree_view_get_cursor (treeview, &path, NULL);
if (!path) {
return;
}
GtkTreeViewColumn *col = gtk_tree_view_get_column (treeview, 1);
gtk_tree_view_set_cursor (treeview, path, col, TRUE); // set cursor onto new field
gtk_tree_path_free(path);
}
static void button_map(GtkWidget *widget, struct search_param *search)
{
GtkTreePath *path;
GtkTreeViewColumn *focus_column;
struct pcoord *c=NULL;
GtkTreeIter iter;
gtk_tree_view_get_cursor(GTK_TREE_VIEW(search->treeview), &path, &focus_column);
if(!path)
return;
if(!gtk_tree_model_get_iter(search->liststore2, &iter, path))
return;
gtk_tree_model_get (GTK_TREE_MODEL (search->liststore2), &iter, COL_COUNT, &c, -1);
if (c) {
navit_set_center(search->nav, c);
}
}
