static void
async_get_favicon_cb (GObject *source, GAsyncResult *result, gpointer user_data)
{
GtkTreeIter iter;
GtkTreePath *path;
IconLoadData *data = (IconLoadData *) user_data;
GdkPixbuf *favicon = webkit_favicon_database_get_favicon_pixbuf_finish (webkit_get_favicon_database (),
result, NULL);
if (favicon) {
/* The completion model might have changed its contents */
if (gtk_tree_row_reference_valid (data->row_reference)) {
path = gtk_tree_row_reference_get_path (data->row_reference);
gtk_tree_model_get_iter (GTK_TREE_MODEL (data->model), &iter, path);
gtk_tree_path_free (path);
gtk_list_store_set (data->model, &iter,
EPHY_HOSTS_STORE_COLUMN_FAVICON, favicon, -1);
}
g_object_unref (favicon);
}
g_object_unref (data->model);
gtk_tree_row_reference_free (data->row_reference);
g_slice_free (IconLoadData, data);
}
static void
icon_loaded_cb (GObject *source, GAsyncResult *result, gpointer user_data)
{
GtkTreeIter iter;
GtkTreePath *path;
IconLoadData *data = (IconLoadData *) user_data;
WebKitFaviconDatabase *database = WEBKIT_FAVICON_DATABASE (source);
GdkPixbuf *favicon = NULL;
#ifdef HAVE_WEBKIT2
cairo_surface_t *icon_surface = webkit_favicon_database_get_favicon_finish (database, result, NULL);
if (icon_surface) {
favicon = ephy_pixbuf_get_from_surface_scaled (icon_surface, FAVICON_SIZE, FAVICON_SIZE);
cairo_surface_destroy (icon_surface);
}
#else
favicon = webkit_favicon_database_get_favicon_pixbuf_finish (database, result, NULL);
#endif
if (favicon) {
/* The completion model might have changed its contents */
if (gtk_tree_row_reference_valid (data->row_reference)) {
path = gtk_tree_row_reference_get_path (data->row_reference);
gtk_tree_model_get_iter (GTK_TREE_MODEL (data->model), &iter, path);
gtk_list_store_set (data->model, &iter, EPHY_COMPLETION_FAVICON_COL, favicon, -1);
g_object_unref (favicon);
gtk_tree_path_free (path);
}
}
g_object_unref (data->model);
gtk_tree_row_reference_free (data->row_reference);
g_slice_free (IconLoadData, data);
}
static void
photos_preview_nav_buttons_fade_in_button (PhotosPreviewNavButtons *self, GtkWidget *widget)
{
if (self->model == NULL || !gtk_tree_row_reference_valid (self->current_row))
return;
gtk_widget_show_all (widget);
gtk_revealer_set_reveal_child (GTK_REVEALER (widget), TRUE);
}
/**
@brief set @a iter to match @a ref for @a store
@param store pointer to treestore
@param ref pointer to treerow reference
@param iter pointer to treeiter to be set
@return TRUE if @a iter is valid
*/
gboolean e2_tree_ref_to_iter (GtkTreeStore *store, GtkTreeRowReference *ref,
GtkTreeIter *iter)
{
if (gtk_tree_row_reference_valid (ref))
{
GtkTreePath *path = gtk_tree_row_reference_get_path (ref);
gboolean retval = gtk_tree_model_get_iter (GTK_TREE_MODEL (store),
iter, path);
gtk_tree_path_free (path);
return retval;
}
return FALSE;
}
/** samplecat_list_store_get_sample_by_row_ref returns a pointer to
* the sample struct in the data model or NULL if not found.
* @return needs to be sample_unref();
*/
Sample*
samplecat_list_store_get_sample_by_row_ref(GtkTreeRowReference* ref)
{
GtkTreePath* path;
if (!ref || !gtk_tree_row_reference_valid(ref)) return NULL;
if(!(path = gtk_tree_row_reference_get_path(ref))) return NULL;
Sample* sample = samplecat_list_store_get_sample_by_path(path);
gtk_tree_path_free(path);
return sample;
}
static gboolean on_idle_tree_view_row_activated(FmFolderView* fv)
{
GtkTreePath* path;
if(gtk_tree_row_reference_valid(fv->activated_row_ref))
{
path = gtk_tree_row_reference_get_path(fv->activated_row_ref);
item_clicked(fv, path, FM_FV_ACTIVATED);
}
gtk_tree_row_reference_free(fv->activated_row_ref);
fv->activated_row_ref = NULL;
fv->row_activated_idle = 0;
return FALSE;
}
void
gnac_properties_set_row(GtkTreeRowReference *current)
{
gtk_tree_row_reference_free(current_ref);
current_ref = NULL;
if (!gtk_tree_row_reference_valid(current)) return;
current_ref = gtk_tree_row_reference_copy(current);
gnac_properties_update_arrows();
gnac_file_list_select_row(current_ref);
gnac_properties_update_display(current_ref);
}
static gboolean
source_viewer_traverse (GNode *node,
gpointer user_data)
{
ESourceViewer *viewer;
ESource *source;
GHashTable *source_index;
GtkTreeRowReference *reference = NULL;
GtkTreeView *tree_view;
GtkTreeModel *model;
GtkTreePath *path;
GtkTreeIter iter;
/* Skip the root node. */
if (G_NODE_IS_ROOT (node))
return FALSE;
viewer = E_SOURCE_VIEWER (user_data);
source_index = viewer->source_index;
tree_view = GTK_TREE_VIEW (viewer->tree_view);
model = gtk_tree_view_get_model (tree_view);
if (node->parent != NULL && node->parent->data != NULL)
reference = g_hash_table_lookup (
source_index, node->parent->data);
if (gtk_tree_row_reference_valid (reference)) {
GtkTreeIter parent;
path = gtk_tree_row_reference_get_path (reference);
gtk_tree_model_get_iter (model, &parent, path);
gtk_tree_path_free (path);
gtk_tree_store_append (GTK_TREE_STORE (model), &iter, &parent);
} else
gtk_tree_store_append (GTK_TREE_STORE (model), &iter, NULL);
/* Source index takes ownership. */
source = g_object_ref (node->data);
path = gtk_tree_model_get_path (model, &iter);
reference = gtk_tree_row_reference_new (model, path);
g_hash_table_insert (source_index, source, reference);
gtk_tree_path_free (path);
source_viewer_update_row (viewer, source);
return FALSE;
}
gint rc_gui_list1_get_selected_index()
{
GtkTreePath *list1_path;
gint *indices = NULL;
gint list1_index;
if(!gtk_tree_row_reference_valid(rc_ui->list1_selected_reference))
return -1;
list1_path = gtk_tree_row_reference_get_path(
rc_ui->list1_selected_reference);
indices = gtk_tree_path_get_indices(list1_path);
list1_index = indices[0];
gtk_tree_path_free(list1_path);
return list1_index;
}
static void
cb_delete_clicked (G_GNUC_UNUSED GtkWidget *ignore,
SheetManager *state)
{
GtkTreeSelection *selection = gtk_tree_view_get_selection (state->sheet_list);
GList *selected_rows, *l;
WorkbookSheetState *old_state;
WorkbookControl *wbc = GNM_WBC (state->wbcg);
Workbook *wb = wb_control_get_workbook (wbc);
g_return_if_fail (selection != NULL);
selected_rows = gtk_tree_selection_get_selected_rows (selection, NULL);
for (l = selected_rows; l != NULL; l = l->next)
l->data = gtk_tree_row_reference_new (GTK_TREE_MODEL (state->model),
(GtkTreePath *) l->data);
workbook_signals_block (state);
old_state = workbook_sheet_state_new (wb);
for (l = selected_rows; l != NULL; l = l->next) {
GtkTreeRowReference *ref = l->data;
if (gtk_tree_row_reference_valid (ref)) {
GtkTreePath *path = gtk_tree_row_reference_get_path (ref);
GtkTreeIter sel_iter;
Sheet *sheet;
gtk_tree_model_get_iter (GTK_TREE_MODEL (state->model), &sel_iter, path);
gtk_tree_path_free (path);
gtk_tree_model_get (GTK_TREE_MODEL (state->model), &sel_iter,
SHEET_POINTER, &sheet,
-1);
gtk_list_store_remove (state->model, &sel_iter);
workbook_sheet_delete (sheet);
}
}
cmd_reorganize_sheets (wbc, old_state, NULL);
update_undo (state, wbc);
workbook_signals_unblock (state);
populate_sheet_list (state);
cb_name_edited (NULL, NULL, NULL, state);
g_list_free_full (selected_rows, (GDestroyNotify) gtk_tree_row_reference_free);
}
static void rc_gui_list1_row_selected(GtkTreeView *list, gpointer data)
{
GtkTreeIter iter;
GtkTreePath *path, *path_old;
gint same_flag = 1;
gint index = 0;
if(!gtk_tree_selection_get_selected(rc_ui->list1_selection, NULL, &iter))
return;
if(gtk_tree_row_reference_valid(rc_ui->list1_selected_reference))
{
path_old = gtk_tree_row_reference_get_path(
rc_ui->list1_selected_reference);
path = gtk_tree_model_get_path(rc_ui->list1_tree_model, &iter);
if(path!=NULL)
{
if(path_old!=NULL)
{
same_flag = gtk_tree_path_compare(path_old, path);
gtk_tree_path_free(path_old);
}
gtk_tree_path_free(path);
if(same_flag==0) return;
}
}
if(rc_ui->list1_selected_reference!=NULL)
{
gtk_tree_row_reference_free(rc_ui->list1_selected_reference);
rc_ui->list1_selected_reference = NULL;
}
index = rc_gui_list1_get_index(&iter);
if(index==-1) return;
rc_ui->list2_tree_model = GTK_TREE_MODEL(
rc_plist_get_list_store(index));
gtk_tree_view_set_model(GTK_TREE_VIEW(rc_ui->list2_tree_view),
rc_ui->list2_tree_model);
rc_ui->list2_selection = gtk_tree_view_get_selection(
GTK_TREE_VIEW(rc_ui->list2_tree_view));
path = gtk_tree_model_get_path(rc_ui->list1_tree_model, &iter);
if(path!=NULL)
{
rc_ui->list1_selected_reference = gtk_tree_row_reference_new(
rc_ui->list1_tree_model, path);
gtk_tree_path_free(path);
}
}
static void
source_viewer_update_row (ESourceViewer *viewer,
ESource *source)
{
GHashTable *source_index;
GtkTreeRowReference *reference;
GtkTreeModel *model;
GtkTreePath *path;
GtkTreeIter iter;
const gchar *display_name;
const gchar *source_uid;
gboolean removable;
gboolean writable;
gboolean remote_creatable;
gboolean remote_deletable;
source_index = viewer->source_index;
reference = g_hash_table_lookup (source_index, source);
/* We show all sources, so the reference should be valid. */
g_return_if_fail (gtk_tree_row_reference_valid (reference));
model = gtk_tree_row_reference_get_model (reference);
path = gtk_tree_row_reference_get_path (reference);
gtk_tree_model_get_iter (model, &iter, path);
gtk_tree_path_free (path);
source_uid = e_source_get_uid (source);
display_name = e_source_get_display_name (source);
removable = e_source_get_removable (source);
writable = e_source_get_writable (source);
remote_creatable = e_source_get_remote_creatable (source);
remote_deletable = e_source_get_remote_deletable (source);
gtk_tree_store_set (
GTK_TREE_STORE (model), &iter,
COLUMN_DISPLAY_NAME, display_name,
COLUMN_SOURCE_UID, source_uid,
COLUMN_REMOVABLE, removable,
COLUMN_WRITABLE, writable,
COLUMN_REMOTE_CREATABLE, remote_creatable,
COLUMN_REMOTE_DELETABLE, remote_deletable,
COLUMN_SOURCE, source,
-1);
}
void
gnac_properties_on_forward(GtkWidget *widget,
gpointer data)
{
if (!gtk_tree_row_reference_valid(current_ref)) return;
GtkTreeRowReference *old_ref = gtk_tree_row_reference_copy(current_ref);
if (gnac_file_list_get_next_row(¤t_ref)) {
gnac_file_list_select_row(current_ref);
gnac_properties_update_display(current_ref);
gtk_tree_row_reference_free(old_ref);
} else {
gtk_tree_row_reference_free(current_ref);
current_ref = old_ref;
}
gnac_properties_update_arrows();
}
static void
_find_and_remove (GtkWidget *item,
gpointer user_data)
{
g_return_if_fail (CARRICK_IS_SERVICE_ITEM (item));
g_return_if_fail (item != NULL);
g_return_if_fail (user_data != NULL);
CarrickList *list = CARRICK_LIST (user_data);
CarrickServiceItem *service_item = CARRICK_SERVICE_ITEM (item);
GtkTreeRowReference *row = carrick_service_item_get_row_reference (service_item);
if (gtk_tree_row_reference_valid (row) == FALSE)
{
if (list->priv->active_item == item)
_set_active_item (list, NULL);
gtk_widget_destroy (item);
}
}
static void
photos_preview_nav_buttons_update_visibility (PhotosPreviewNavButtons *self)
{
GtkTreeIter iter;
GtkTreeIter tmp;
GtkTreePath *current_path = NULL;
if (self->model == NULL
|| !gtk_tree_row_reference_valid (self->current_row)
|| !self->visible)
{
self->enable_prev = FALSE;
self->enable_next = FALSE;
goto out;
}
current_path = gtk_tree_row_reference_get_path (self->current_row);
gtk_tree_model_get_iter (self->model, &iter, current_path);
tmp = iter;
self->enable_prev = gtk_tree_model_iter_previous (self->model, &tmp);
tmp = iter;
self->enable_next = gtk_tree_model_iter_next (self->model, &tmp);
out:
if (self->visible_internal && self->enable_next)
photos_preview_nav_buttons_fade_in_button (self, self->next_widget);
else
photos_preview_nav_buttons_fade_out_button (self, self->next_widget);
if (self->visible_internal && self->enable_prev)
photos_preview_nav_buttons_fade_in_button (self, self->prev_widget);
else
photos_preview_nav_buttons_fade_out_button (self, self->prev_widget);
g_simple_action_set_enabled (G_SIMPLE_ACTION (self->load_next), self->enable_next);
g_simple_action_set_enabled (G_SIMPLE_ACTION (self->load_previous), self->enable_prev);
g_clear_pointer (¤t_path, (GDestroyNotify) gtk_tree_path_free);
}
static void
source_viewer_expand_to_source (ESourceViewer *viewer,
ESource *source)
{
GHashTable *source_index;
GtkTreeRowReference *reference;
GtkTreeView *tree_view;
GtkTreePath *path;
source_index = viewer->source_index;
reference = g_hash_table_lookup (source_index, source);
/* We show all sources, so the reference should be valid. */
g_return_if_fail (gtk_tree_row_reference_valid (reference));
/* Expand the tree view to the path containing the ESource. */
tree_view = GTK_TREE_VIEW (viewer->tree_view);
path = gtk_tree_row_reference_get_path (reference);
gtk_tree_view_expand_to_path (tree_view, path);
gtk_tree_path_free (path);
}
static void
attachment_button_select_path (EAttachmentButton *button)
{
EAttachmentView *view;
EAttachment *attachment;
GtkTreeRowReference *reference;
GtkTreePath *path;
attachment = e_attachment_button_get_attachment (button);
g_return_if_fail (E_IS_ATTACHMENT (attachment));
reference = e_attachment_get_reference (attachment);
g_return_if_fail (gtk_tree_row_reference_valid (reference));
view = e_attachment_button_get_view (button);
path = gtk_tree_row_reference_get_path (reference);
e_attachment_view_unselect_all (view);
e_attachment_view_select_path (view, path);
gtk_tree_path_free (path);
}
static void
gnc_style_sheet_options_close_cb(GNCOptionWin * propertybox,
gpointer user_data)
{
ss_info * ssi = user_data;
GtkTreeIter iter;
if (gtk_tree_row_reference_valid (ssi->row_ref))
{
StyleSheetDialog * ss = gnc_style_sheet_dialog;
GtkTreePath *path = gtk_tree_row_reference_get_path (ssi->row_ref);
if (gtk_tree_model_get_iter (GTK_TREE_MODEL(ss->list_store), &iter, path))
gtk_list_store_set (ss->list_store, &iter,
COLUMN_DIALOG, NULL,
-1);
gtk_tree_path_free(path);
}
gtk_tree_row_reference_free (ssi->row_ref);
gnc_options_dialog_destroy(ssi->odialog);
gnc_option_db_destroy(ssi->odb);
scm_gc_unprotect_object(ssi->stylesheet);
g_free(ssi);
}
static void adapter_removed(GtkTreeModel *model, GtkTreePath *path,
gpointer user_data)
{
GtkNotebook *notebook = user_data;
int i, count = gtk_notebook_get_n_pages(notebook);
for (i = 0; i < count; i++) {
GtkWidget *widget;
adapter_data *adapter;
widget = gtk_notebook_get_nth_page(notebook, i);
if (widget == NULL)
continue;
adapter = g_object_get_data(G_OBJECT(widget), "adapter");
if (adapter == NULL)
continue;
if (gtk_tree_row_reference_valid(adapter->reference) == TRUE)
continue;
gtk_tree_row_reference_free(adapter->reference);
adapter->reference = NULL;
gtk_notebook_remove_page(notebook, i);
set_current_page (notebook);
/* When the default adapter changes, the adapter_changed signal will
* take care of setting the right page */
g_signal_handlers_disconnect_by_func(adapter->proxy,
property_changed, adapter);
g_object_unref(adapter->proxy);
g_free(adapter);
}
}
static gboolean
bump_pulse (gpointer user_data)
{
GisNetworkPage *page = user_data;
GisNetworkPagePrivate *priv = page->priv;
GtkTreeIter iter;
GtkTreePath *path;
GtkTreeModel *model;
priv->pulse++;
if (priv->refreshing || !gtk_tree_row_reference_valid (priv->row))
return FALSE;
model = (GtkTreeModel *)priv->ap_list;
path = gtk_tree_row_reference_get_path (priv->row);
gtk_tree_model_get_iter (model, &iter, path);
gtk_tree_path_free (path);
gtk_list_store_set (priv->ap_list, &iter,
PANEL_WIRELESS_COLUMN_PULSE, priv->pulse,
-1);
return TRUE;
}
/*
* key has been pressed while being in watch tree view
*/
static gboolean on_watch_key_pressed_callback(GtkWidget *widget, GdkEvent *event, gpointer user_data)
{
/* handling only Delete button pressing
* that means "delete selected rows" */
int keyval = ((GdkEventKey*)event)->keyval;
if (keyval != GDK_Delete)
return FALSE;
/* get selected rows */
GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(wtree));
GList *rows = gtk_tree_selection_get_selected_rows(selection, &wmodel);
/* empty row path */
GtkTreePath *empty_path = wtree_empty_path();
/* check whether only empty row was selected */
if (1 != gtk_tree_selection_count_selected_rows(selection) ||
gtk_tree_path_compare((GtkTreePath*)rows->data, empty_path))
{
/* path reference to select after deleteing finishes */
GtkTreeRowReference *reference_to_select = NULL;
/* get references to the rows */
GList *references = NULL;
GList *iter = rows;
while (iter)
{
GtkTreePath *path = (GtkTreePath*)iter->data;
/* move up paths to the root elements */
while (gtk_tree_path_get_depth(path) > 1)
gtk_tree_path_up(path);
/* add path reference if it's not an empty row*/
if (gtk_tree_path_compare(path, empty_path))
references = g_list_append(references, gtk_tree_row_reference_new(wmodel, path));
iter = iter->next;
}
/* iterate through references and remove */
iter = references;
while (iter)
{
GtkTreeRowReference *reference = (GtkTreeRowReference*)iter->data;
/* check for valid reference because two or more equal
refernces could be put in the list if several child items
of the same node were selected and the path for the
current reference was already deleted */
if (gtk_tree_row_reference_valid(reference))
{
GtkTreePath *path = gtk_tree_row_reference_get_path(reference);
if (!reference_to_select)
{
/* select upper sibling of the upper
selected row that has unselected upper sibling */
GtkTreePath *sibling = gtk_tree_path_copy(path);
if(gtk_tree_path_prev(sibling))
{
if (!gtk_tree_selection_path_is_selected(selection, sibling))
reference_to_select = gtk_tree_row_reference_new(gtk_tree_view_get_model(GTK_TREE_VIEW(wtree)), sibling);
}
else if (gtk_tree_path_next(sibling), gtk_tree_path_compare(path, sibling))
reference_to_select = gtk_tree_row_reference_new(gtk_tree_view_get_model(GTK_TREE_VIEW(wtree)), sibling);
}
/* get iterator */
GtkTreeIter titer;
gtk_tree_model_get_iter(wmodel, &titer, path);
/* remove from the debug session, if it's active */
if (DBS_STOPPED == debug_state)
{
gchar *internal = NULL;
gtk_tree_model_get (
wmodel,
&titer,
W_INTERNAL, &internal,
-1);
active_module->remove_watch(internal);
g_free(internal);
}
gtk_tree_store_remove(wstore, &titer);
gtk_tree_path_free(path);
}
iter = iter->next;
}
/* if all (with or without empty row) was selected - set empty row
as a path to be selected after deleting */
if (!reference_to_select)
{
GtkTreePath *path = wtree_empty_path();
reference_to_select = gtk_tree_row_reference_new (gtk_tree_view_get_model(GTK_TREE_VIEW(wtree)), path);
gtk_tree_path_free(path);
}
/* set selection */
gtk_tree_selection_unselect_all(selection);
GtkTreePath *path_to_select = gtk_tree_row_reference_get_path(reference_to_select);
gtk_tree_selection_select_path(selection, path_to_select);
gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(widget), path_to_select, NULL, TRUE, 0.5, 0.5);
gtk_tree_path_free(path_to_select);
/* free references list */
g_list_foreach (references, (GFunc)gtk_tree_row_reference_free, NULL);
g_list_free (references);
config_set_debug_changed();
}
gtk_tree_path_free(empty_path);
/* free rows list */
g_list_foreach (rows, (GFunc)gtk_tree_path_free, NULL);
g_list_free (rows);
return FALSE;
}
static void
thunar_uca_provider_activated (ThunarUcaProvider *uca_provider,
GtkAction *action)
{
GtkTreeRowReference *row;
ThunarUcaContext *uca_context;
GtkTreePath *path;
GtkTreeIter iter;
GtkWidget *dialog;
GtkWidget *window;
gboolean succeed;
GSource *source;
GError *error = NULL;
GList *files;
gchar **argv;
gchar *working_directory = NULL;
gchar *filename;
gchar *label;
gchar *uri;
gint argc;
gint pid;
g_return_if_fail (THUNAR_UCA_IS_PROVIDER (uca_provider));
g_return_if_fail (GTK_IS_ACTION (action));
/* check if the row reference is still valid */
row = g_object_get_qdata (G_OBJECT (action), thunar_uca_row_quark);
if (G_UNLIKELY (!gtk_tree_row_reference_valid (row)))
return;
/* determine the iterator for the item */
path = gtk_tree_row_reference_get_path (row);
gtk_tree_model_get_iter (GTK_TREE_MODEL (uca_provider->model), &iter, path);
gtk_tree_path_free (path);
/* determine the files and the window for the action */
uca_context = g_object_get_qdata (G_OBJECT (action), thunar_uca_context_quark);
window = thunar_uca_context_get_window (uca_context);
files = thunar_uca_context_get_files (uca_context);
/* determine the argc/argv for the item */
succeed = thunar_uca_model_parse_argv (uca_provider->model, &iter, files, &argc, &argv, &error);
if (G_LIKELY (succeed))
{
/* determine the working from the first file */
if (G_LIKELY (files != NULL))
{
/* determine the filename of the first selected file */
uri = thunarx_file_info_get_uri (files->data);
filename = g_filename_from_uri (uri, NULL, NULL);
if (G_LIKELY (filename != NULL))
{
/* if this is a folder action, we just use the filename as working directory */
if (g_object_get_qdata (G_OBJECT (action), thunar_uca_folder_quark) != NULL)
{
working_directory = filename;
filename = NULL;
}
else
{
working_directory = g_path_get_dirname (filename);
}
}
g_free (filename);
g_free (uri);
}
/* spawn the command on the window's screen */
succeed = gdk_spawn_on_screen (gtk_widget_get_screen (GTK_WIDGET (window)), working_directory,
argv, NULL, G_SPAWN_DO_NOT_REAP_CHILD | G_SPAWN_SEARCH_PATH,
NULL, NULL, &pid, &error);
/* check if we succeed */
if (G_LIKELY (succeed))
{
/* check if we already have a child watch */
if (G_UNLIKELY (uca_provider->child_watch_id >= 0))
{
/* reset the callback function to g_spawn_close_pid() so the plugin can be
* safely unloaded and the child will still not become a zombie afterwards.
*/
source = g_main_context_find_source_by_id (NULL, uca_provider->child_watch_id);
g_source_set_callback (source, (GSourceFunc) g_spawn_close_pid, NULL, NULL);
}
/* schedule the new child watch */
uca_provider->child_watch_id = g_child_watch_add_full (G_PRIORITY_LOW, pid, thunar_uca_provider_child_watch,
uca_provider, thunar_uca_provider_child_watch_destroy);
/* take over ownership of the working directory as child watch path */
uca_provider->child_watch_path = working_directory;
working_directory = NULL;
}
/* cleanup */
g_free (working_directory);
g_strfreev (argv);
}
/* present error message to the user */
if (G_UNLIKELY (!succeed))
{
g_object_get (G_OBJECT (action), "label", &label, NULL);
dialog = gtk_message_dialog_new ((GtkWindow *) window,
GTK_DIALOG_DESTROY_WITH_PARENT
| GTK_DIALOG_MODAL,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
_("Failed to launch action \"%s\"."), label);
gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), "%s.", error->message);
gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
g_error_free (error);
g_free (label);
}
}
void
gimp_action_view_set_filter (GimpActionView *view,
const gchar *filter)
{
GtkTreeSelection *sel;
GtkTreeModel *filtered_model;
GtkTreeModel *model;
GtkTreeIter iter;
gboolean iter_valid;
GtkTreeRowReference *selected_row = NULL;
g_return_if_fail (GIMP_IS_ACTION_VIEW (view));
filtered_model = gtk_tree_view_get_model (GTK_TREE_VIEW (view));
model = gtk_tree_model_filter_get_model (GTK_TREE_MODEL_FILTER (filtered_model));
if (filter && ! strlen (filter))
filter = NULL;
g_free (view->filter);
view->filter = NULL;
if (filter)
view->filter = g_utf8_casefold (filter, -1);
sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (view));
if (gtk_tree_selection_get_selected (sel, NULL, &iter))
{
GtkTreePath *path = gtk_tree_model_get_path (filtered_model, &iter);
selected_row = gtk_tree_row_reference_new (filtered_model, path);
}
for (iter_valid = gtk_tree_model_get_iter_first (model, &iter);
iter_valid;
iter_valid = gtk_tree_model_iter_next (model, &iter))
{
GtkTreeIter child_iter;
gboolean child_valid;
gint n_children = 0;
for (child_valid = gtk_tree_model_iter_children (model, &child_iter,
&iter);
child_valid;
child_valid = gtk_tree_model_iter_next (model, &child_iter))
{
gboolean visible = TRUE;
if (view->filter)
{
gchar *label;
gchar *name;
gtk_tree_model_get (model, &child_iter,
GIMP_ACTION_VIEW_COLUMN_LABEL_CASEFOLD, &label,
GIMP_ACTION_VIEW_COLUMN_NAME, &name,
-1);
visible = label && name && (strstr (label, view->filter) != NULL ||
strstr (name, view->filter) != NULL);
g_free (label);
g_free (name);
}
gtk_tree_store_set (GTK_TREE_STORE (model), &child_iter,
GIMP_ACTION_VIEW_COLUMN_VISIBLE, visible,
-1);
if (visible)
n_children++;
}
gtk_tree_store_set (GTK_TREE_STORE (model), &iter,
GIMP_ACTION_VIEW_COLUMN_VISIBLE, n_children > 0,
-1);
}
if (view->filter)
gtk_tree_view_expand_all (GTK_TREE_VIEW (view));
else
gtk_tree_view_collapse_all (GTK_TREE_VIEW (view));
gtk_tree_view_columns_autosize (GTK_TREE_VIEW (view));
if (selected_row)
{
if (gtk_tree_row_reference_valid (selected_row))
{
GtkTreePath *path = gtk_tree_row_reference_get_path (selected_row);
gimp_action_view_select_path (view, path);
gtk_tree_path_free (path);
}
gtk_tree_row_reference_free (selected_row);
}
}
static void
thunar_uca_provider_activated (ThunarUcaProvider *uca_provider,
GtkAction *action)
{
GtkTreeRowReference *row;
ThunarUcaContext *uca_context;
GtkTreePath *path;
GtkTreeIter iter;
GtkWidget *dialog;
GtkWidget *window;
gboolean succeed;
GError *error = NULL;
GList *files;
gchar **argv;
gchar *working_directory = NULL;
gchar *filename;
gchar *label;
gchar *uri;
gint argc;
gchar *icon_name = NULL;
gboolean startup_notify;
GClosure *child_watch;
g_return_if_fail (THUNAR_UCA_IS_PROVIDER (uca_provider));
g_return_if_fail (GTK_IS_ACTION (action));
/* check if the row reference is still valid */
row = g_object_get_qdata (G_OBJECT (action), thunar_uca_row_quark);
if (G_UNLIKELY (!gtk_tree_row_reference_valid (row)))
return;
/* determine the iterator for the item */
path = gtk_tree_row_reference_get_path (row);
gtk_tree_model_get_iter (GTK_TREE_MODEL (uca_provider->model), &iter, path);
gtk_tree_path_free (path);
/* determine the files and the window for the action */
uca_context = g_object_get_qdata (G_OBJECT (action), thunar_uca_context_quark);
window = thunar_uca_context_get_window (uca_context);
files = thunar_uca_context_get_files (uca_context);
/* determine the argc/argv for the item */
succeed = thunar_uca_model_parse_argv (uca_provider->model, &iter, files, &argc, &argv, &error);
if (G_LIKELY (succeed))
{
/* get the icon name and whether startup notification is active */
gtk_tree_model_get (GTK_TREE_MODEL (uca_provider->model), &iter,
THUNAR_UCA_MODEL_COLUMN_ICON, &icon_name,
THUNAR_UCA_MODEL_COLUMN_STARTUP_NOTIFY, &startup_notify,
-1);
/* determine the working from the first file */
if (G_LIKELY (files != NULL))
{
/* determine the filename of the first selected file */
uri = thunarx_file_info_get_uri (files->data);
filename = g_filename_from_uri (uri, NULL, NULL);
if (G_LIKELY (filename != NULL))
{
/* if this is a folder action, we just use the filename as working directory */
if (g_object_get_qdata (G_OBJECT (action), thunar_uca_folder_quark) != NULL)
{
working_directory = filename;
filename = NULL;
}
else
{
working_directory = g_path_get_dirname (filename);
}
}
g_free (filename);
g_free (uri);
}
/* build closre for child watch */
child_watch = g_cclosure_new_swap (G_CALLBACK (thunar_uca_provider_child_watch),
uca_provider, thunar_uca_provider_child_watch_destroy);
g_closure_ref (child_watch);
g_closure_sink (child_watch);
/* spawn the command on the window's screen */
succeed = xfce_spawn_on_screen_with_child_watch (gtk_widget_get_screen (GTK_WIDGET (window)),
working_directory, argv, NULL,
G_SPAWN_SEARCH_PATH,
startup_notify,
gtk_get_current_event_time (),
icon_name,
child_watch,
&error);
/* check if we succeed */
if (G_LIKELY (succeed))
{
/* release existing child watch */
thunar_uca_provider_child_watch_destroy (uca_provider, NULL);
/* set new closure */
uca_provider->child_watch = child_watch;
/* take over ownership of the working directory as child watch path */
uca_provider->child_watch_path = working_directory;
working_directory = NULL;
}
else
{
/* spawn failed, release watch */
g_closure_unref (child_watch);
}
/* cleanup */
g_free (working_directory);
g_strfreev (argv);
g_free (icon_name);
}
/* present error message to the user */
if (G_UNLIKELY (!succeed))
{
g_object_get (G_OBJECT (action), "label", &label, NULL);
dialog = gtk_message_dialog_new ((GtkWindow *) window,
GTK_DIALOG_DESTROY_WITH_PARENT
| GTK_DIALOG_MODAL,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
_("Failed to launch action \"%s\"."), label);
gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), "%s.", error->message);
gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
g_error_free (error);
g_free (label);
}
}
static void
repopulate (void)
{
NautilusBookmark *selected;
GtkListStore *store;
GtkTreePath *path;
GtkTreeRowReference *reference;
guint index;
g_assert (GTK_IS_TREE_VIEW (bookmark_list_widget));
g_assert (NAUTILUS_IS_BOOKMARK_LIST (bookmarks));
store = GTK_LIST_STORE (bookmark_list_store);
selected = get_selected_bookmark ();
g_signal_handler_block (bookmark_selection,
selection_changed_id);
g_signal_handler_block (bookmark_list_store,
row_deleted_signal_id);
g_signal_handler_block (bookmark_list_widget,
row_activated_signal_id);
g_signal_handler_block (bookmark_list_widget,
key_pressed_signal_id);
g_signal_handler_block (bookmark_list_widget,
button_pressed_signal_id);
gtk_list_store_clear (store);
g_signal_handler_unblock (bookmark_list_widget,
row_activated_signal_id);
g_signal_handler_unblock (bookmark_list_widget,
key_pressed_signal_id);
g_signal_handler_unblock (bookmark_list_widget,
button_pressed_signal_id);
g_signal_handler_unblock (bookmark_list_store,
row_deleted_signal_id);
g_signal_handler_unblock (bookmark_selection,
selection_changed_id);
/* Fill the list in with the bookmark names. */
g_signal_handler_block (store, row_changed_signal_id);
reference = NULL;
for (index = 0; index < nautilus_bookmark_list_length (bookmarks); ++index) {
NautilusBookmark *bookmark;
const char *bookmark_name;
GIcon *bookmark_icon;
GtkTreeIter iter;
bookmark = nautilus_bookmark_list_item_at (bookmarks, index);
bookmark_name = nautilus_bookmark_get_name (bookmark);
bookmark_icon = nautilus_bookmark_get_icon (bookmark);
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter,
BOOKMARK_LIST_COLUMN_ICON, bookmark_icon,
BOOKMARK_LIST_COLUMN_NAME, bookmark_name,
BOOKMARK_LIST_COLUMN_BOOKMARK, bookmark,
BOOKMARK_LIST_COLUMN_STYLE, PANGO_STYLE_NORMAL,
-1);
if (bookmark == selected) {
/* save old selection */
GtkTreePath *path;
path = gtk_tree_model_get_path (GTK_TREE_MODEL (store), &iter);
reference = gtk_tree_row_reference_new (GTK_TREE_MODEL (store), path);
gtk_tree_path_free (path);
}
g_object_unref (bookmark_icon);
}
g_signal_handler_unblock (store, row_changed_signal_id);
if (reference != NULL) {
/* restore old selection */
/* bookmarks_set_empty() will call the selection change handler,
* so we block it here in case of selection change.
*/
g_signal_handler_block (bookmark_selection, selection_changed_id);
g_assert (index != 0);
g_assert (gtk_tree_row_reference_valid (reference));
path = gtk_tree_row_reference_get_path (reference);
gtk_tree_selection_select_path (bookmark_selection, path);
gtk_tree_row_reference_free (reference);
gtk_tree_path_free (path);
g_signal_handler_unblock (bookmark_selection, selection_changed_id);
}
bookmarks_set_empty (index == 0);
}
static void
source_viewer_build_model (ESourceViewer *viewer)
{
GQueue queue = G_QUEUE_INIT;
GHashTable *source_index;
GtkTreeView *tree_view;
GtkTreeModel *model;
GtkTreePath *sel_path;
ESource *sel_source;
GNode *root;
tree_view = GTK_TREE_VIEW (viewer->tree_view);
source_index = viewer->source_index;
sel_path = e_source_viewer_dup_selected_path (viewer);
sel_source = e_source_viewer_ref_selected_source (viewer);
/* Save expanded sources to restore later. */
gtk_tree_view_map_expanded_rows (
tree_view, (GtkTreeViewMappingFunc)
source_viewer_save_expanded, &queue);
model = gtk_tree_view_get_model (tree_view);
gtk_tree_store_clear (GTK_TREE_STORE (model));
g_hash_table_remove_all (source_index);
root = e_source_viewer_build_display_tree (viewer);
g_node_traverse (
root, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
(GNodeTraverseFunc) source_viewer_traverse, viewer);
e_source_registry_free_display_tree (root);
/* Restore previously expanded sources. */
while (!g_queue_is_empty (&queue)) {
GtkTreeRowReference *reference;
ESource *source;
source = g_queue_pop_head (&queue);
reference = g_hash_table_lookup (source_index, source);
if (gtk_tree_row_reference_valid (reference)) {
GtkTreePath *path;
path = gtk_tree_row_reference_get_path (reference);
gtk_tree_view_expand_to_path (tree_view, path);
gtk_tree_path_free (path);
}
g_object_unref (source);
}
/* Restore the selection. */
if (sel_source != NULL && sel_path != NULL) {
if (!e_source_viewer_set_selected_source (viewer, sel_source))
e_source_viewer_set_selected_path (viewer, sel_path);
}
if (sel_path != NULL)
gtk_tree_path_free (sel_path);
if (sel_source != NULL)
g_object_unref (sel_source);
}
static VALUE
treerowref_valid(VALUE self)
{
return CBOOL2RVAL(gtk_tree_row_reference_valid(_SELF(self)));
}