static void
on_recent_file_query_result (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
ShellDocSystemRecentQueryData *data = user_data;
ShellDocSystem *self = data->self;
GError *error = NULL;
GFileInfo *fileinfo;
fileinfo = g_file_query_info_finish (G_FILE (source), result, &error);
if (fileinfo)
g_object_unref (fileinfo);
/* This is a strict error check; we don't want to cause recent files to
* vanish for anything potentially transient.
*/
if (error != NULL && error->domain == G_IO_ERROR && error->code == G_IO_ERROR_NOT_FOUND)
{
self->priv->infos_by_timestamp = g_slist_remove (self->priv->infos_by_timestamp, data->info);
g_hash_table_remove (self->priv->infos_by_uri, gtk_recent_info_get_uri (data->info));
g_hash_table_insert (self->priv->deleted_infos, gtk_recent_info_ref (data->info), NULL);
if (self->priv->idle_emit_deleted_id == 0)
self->priv->idle_emit_deleted_id = g_timeout_add (0, shell_doc_system_idle_emit_deleted, self);
}
g_clear_error (&error);
gtk_recent_info_unref (data->info);
g_free (data);
}
static void
recent_manager_lookup_item (void)
{
GtkRecentManager *manager;
GtkRecentInfo *info;
GError *error;
manager = gtk_recent_manager_get_default ();
error = NULL;
info = gtk_recent_manager_lookup_item (manager,
"file:///tmp/testrecentdoesnotexist.txt",
&error);
g_assert (info == NULL);
g_assert (error != NULL);
g_assert (error->domain == GTK_RECENT_MANAGER_ERROR);
g_assert (error->code == GTK_RECENT_MANAGER_ERROR_NOT_FOUND);
g_error_free (error);
error = NULL;
info = gtk_recent_manager_lookup_item (manager, uri2, &error);
g_assert (info != NULL);
g_assert (error == NULL);
g_assert (gtk_recent_info_has_application (info, "testrecentchooser"));
gtk_recent_info_unref (info);
}
void
gl_ui_cmd_file_open_recent (GtkRecentChooser *chooser,
glWindow *window)
{
GtkRecentInfo *item;
gchar *utf8_filename;
gl_debug (DEBUG_COMMANDS, "START");
g_return_if_fail (chooser && GTK_IS_RECENT_CHOOSER(chooser));
g_return_if_fail (window && GL_IS_WINDOW(window));
item = gtk_recent_chooser_get_current_item (chooser);
if (!item)
return;
utf8_filename = gl_recent_get_utf8_filename (item);
gl_debug (DEBUG_COMMANDS, "Selected %s\n", utf8_filename);
gl_file_open_recent (utf8_filename, window);
gtk_recent_info_unref (item);
gl_debug (DEBUG_COMMANDS, "END");
}
static void
item_activated_cb (GtkRecentChooser *chooser,
gpointer data)
{
GtkRecentInfo *info;
GString *text;
gchar *label_text;
info = gtk_recent_chooser_get_current_item (chooser);
if (!info)
{
g_warning ("Unable to retrieve the current item, aborting...");
return;
}
text = g_string_new ("Selected recent item:\n");
g_string_append_printf (text, " URI: %s\n",
gtk_recent_info_get_uri (info));
g_string_append_printf (text, " MIME Type: %s\n",
gtk_recent_info_get_mime_type (info));
label_text = g_string_free (text, FALSE);
gtk_label_set_text (GTK_LABEL (label), label_text);
gtk_recent_info_unref (info);
g_free (label_text);
}
/**
* Print the uri of the selected item in a recent file chooser.
* @param recent_chooser recent file chooser to print information about
*/
void mk_print_GtkRecentChooser_info(GtkRecentChooser* recent_chooser)
{
GtkRecentInfo* info;
info = gtk_recent_chooser_get_current_item(recent_chooser);
if (info != NULL) {
const gchar* uri = gtk_recent_info_get_uri(info);
g_printf("\t%s", uri);
gtk_recent_info_unref(info);
}
}
static void
recent_cb (GSimpleAction *action,
GVariant *parameter,
gpointer app)
{
GtkWidget *dialog;
GtkWindow *win;
GtkRecentInfo *info;
GtkRecentChooser *chooser;
GtkRecentFilter *filter;
GtkRecentFilter *filter_all;
const gchar *uri = NULL;
win = gtk_application_get_active_window (app);
dialog = gtk_recent_chooser_dialog_new (
_("Recent Files"),
win,
_("_Cancel"), GTK_RESPONSE_CANCEL,
_("_Open"), GTK_RESPONSE_ACCEPT,
NULL);
gtk_recent_chooser_set_sort_type (GTK_RECENT_CHOOSER (dialog), GTK_RECENT_SORT_MRU); /* Most Recently Used first */
gtk_recent_chooser_set_show_icons (GTK_RECENT_CHOOSER (dialog), TRUE);
filter = gtk_recent_filter_new ();
gtk_recent_filter_set_name (filter, _("Parlatype"));
gtk_recent_filter_add_application (filter, "parlatype");
gtk_recent_filter_add_mime_type (filter, "audio/*");
gtk_recent_chooser_add_filter (GTK_RECENT_CHOOSER (dialog), filter);
filter_all = gtk_recent_filter_new ();
gtk_recent_filter_set_name (filter_all, _("All files"));
gtk_recent_filter_add_pattern (filter_all, "*");
gtk_recent_chooser_add_filter (GTK_RECENT_CHOOSER (dialog), filter_all);
gtk_recent_chooser_set_filter (GTK_RECENT_CHOOSER (dialog), filter);
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT) {
chooser = GTK_RECENT_CHOOSER (dialog);
info = gtk_recent_chooser_get_current_item (chooser);
uri = gtk_recent_info_get_uri (info);
}
gtk_widget_destroy (dialog);
if (uri) {
/* GStreamer has problems with uris from recent chooser,
as a workaround use GFile magic */
GFile *file = g_file_new_for_uri (uri);
gchar *tmp = g_file_get_uri (file);
pt_window_open_file (PT_WINDOW (win), tmp);
g_free (tmp);
g_object_unref (file);
gtk_recent_info_unref (info);
}
}
static void
age_renderer_func (GtkTreeViewColumn *tree_column,
GtkCellRenderer *cell,
GtkTreeModel *model,
GtkTreeIter *iter,
gpointer user_data)
{
GtkRecentInfo *ri = NULL;
GDateTime *now = user_data;
GDateTime *last_used;
GTimeSpan age;
char *text;
const char *date_format;
const char *p;
gtk_tree_model_get (model, iter, RECENT_COL_INFO, &ri, -1);
last_used = g_date_time_new_from_unix_local (gtk_recent_info_get_modified (ri));
gtk_recent_info_unref (ri);
age = g_date_time_difference (now, last_used);
if (age < G_TIME_SPAN_DAY &&
g_date_time_get_day_of_month (now) == g_date_time_get_day_of_month (last_used)) {
if (go_locale_24h ())
/*
* xgettext: This is a time format for
* g_date_time_format used in locales that use a
* 24 hour clock. You probably do not need to change
* this. The default will show things like "09:50"
* and "21:50".
*/
date_format = _("%H:%M");
else
/*
* xgettext: This is a time format for
* g_date_time_format used in locales that use
* a 12 hour clock. You probably do not need
* to change this. The default will show
* things like " 9:50 am" and " 9:50 pm".
*/
date_format = _("%l:%M %P");
} else {
date_format = "%x";
}
p = text = g_date_time_format (last_used, date_format);
while (g_ascii_isspace (*p))
p++;
g_object_set (cell, "text", p, "xalign", 0.5, NULL);
g_free (text);
g_date_time_unref (last_used);
}
static void
recent_documents_activate_cb (GtkRecentChooser *chooser,
gpointer data)
{
GtkRecentInfo *recent_info;
const char *uri;
const char *mime_type;
GdkScreen *screen;
GError *error = NULL;
screen = gtk_widget_get_screen (GTK_WIDGET (chooser));
recent_info = gtk_recent_chooser_get_current_item (chooser);
uri = gtk_recent_info_get_uri (recent_info);
mime_type = gtk_recent_info_get_mime_type (recent_info);
//FIXME gtk_recent_info_get_application_info() could be useful
if (show_uri (uri, mime_type, screen, &error) != TRUE) {
char *uri_utf8;
uri_utf8 = g_filename_to_utf8 (uri, -1, NULL, NULL, NULL);
//FIXME this could fail... Maybe we want gtk_recent_info_get_display_name()
if (error) {
char *primary;
primary = g_strdup_printf (_("Could not open recently used document \"%s\""),
uri_utf8);
panel_error_dialog (NULL, screen,
"cannot_open_recent_doc", TRUE,
primary, error->message);
g_free (primary);
g_error_free (error);
} else {
char *primary;
char *secondary;
primary = g_strdup_printf (_("Could not open recently used document \"%s\""),
uri_utf8);
secondary = g_strdup_printf (_("An unknown error occurred while trying to open \"%s\"."),
uri_utf8);
panel_error_dialog (NULL, screen,
"cannot_open_recent_doc", TRUE,
primary, secondary);
g_free (primary);
g_free (secondary);
}
g_free (uri_utf8);
}
/* we can unref it only after having used the data we fetched from it */
gtk_recent_info_unref (recent_info);
}
static VALUE
rc_get_items(VALUE self)
{
GList* list = gtk_recent_chooser_get_items(_SELF(self));
VALUE ary = rb_ary_new();
while (list) {
rb_ary_push(ary, BOXED2RVAL(list->data, GTK_TYPE_RECENT_INFO));
gtk_recent_info_unref(list->data);
list = list->next;
}
g_list_free(list);
return ary;
}
void on_open_recent_activate (GtkRecentChooser *chooser, gpointer user_data)
{
GtkRecentInfo *item;
gchar *filename;
gchar *utf8_filename = NULL;
GtkWidget *dialog;
const gchar *uri;
g_return_if_fail (chooser && GTK_IS_RECENT_CHOOSER(chooser));
item = gtk_recent_chooser_get_current_item (chooser);
if (!item)
return;
uri = gtk_recent_info_get_uri (item);
filename = g_filename_from_uri (uri, NULL, NULL);
if ( filename != NULL )
{
utf8_filename = g_filename_to_utf8 (filename, -1, NULL, NULL, NULL);
g_free (filename);
}
if (! utf8_filename || ! ca_open (utf8_filename, FALSE)) {
dialog = gtk_message_dialog_new (NULL,
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
_("Problem when opening '%s' CA database"),
utf8_filename);
gtk_dialog_run (GTK_DIALOG(dialog));
gtk_widget_destroy (dialog);
} else {
__recent_add_utf8_filename (utf8_filename);
}
gtk_recent_info_unref (item);
return;
}
static void
icon_lookup_data_destroy (gpointer p)
{
AsyncIconLookupData *data = p;
if (data->icon)
{
g_object_unref (data->icon);
gtk_icon_info_free (data->icon_info);
}
else if (data->uri)
g_free (data->uri);
if (data->mimetype)
g_free (data->mimetype);
if (data->recent_info)
gtk_recent_info_unref (data->recent_info);
g_free (data);
}
static void
url_renderer_func (GtkTreeViewColumn *tree_column,
GtkCellRenderer *cell,
GtkTreeModel *model,
GtkTreeIter *iter,
gpointer user_data)
{
GtkRecentInfo *ri = NULL;
const char *uri;
char *markup, *shortname, *filename, *longname;
gtk_tree_model_get (model, iter, RECENT_COL_INFO, &ri, -1);
uri = gtk_recent_info_get_uri (ri);
filename = go_filename_from_uri (uri);
if (filename) {
shortname = g_filename_display_basename (filename);
} else {
shortname = g_filename_display_basename (uri);
}
if (filename) {
longname = g_strdup (filename);
} else {
char *duri = g_uri_unescape_string (uri, NULL);
longname = duri
? g_filename_display_name (duri)
: g_strdup (uri);
g_free (duri);
}
markup = g_markup_printf_escaped (_("<b>%s</b>\n"
"<small>Location: %s</small>"),
shortname,
longname);
g_object_set (cell, "markup", markup, NULL);
g_free (markup);
g_free (shortname);
g_free (longname);
g_free (filename);
gtk_recent_info_unref (ri);
}
QStringList On::recentFiles() {
QStringList recent;
GtkRecentManager *manager = gtk_recent_manager_get_default();
GList *list = gtk_recent_manager_get_items(manager);
GtkRecentInfo *item;
int i = 0;
GFOREACH(item, list) {
recent.append(QUrl::fromEncoded(gtk_recent_info_get_uri(item)).toString());
recent.append(QUrl::fromEncoded(gtk_recent_info_get_display_name(item)).toString());
recent.append(gdkPixbufToBase64(gtk_recent_info_get_icon(item, iconSize)));
if (i == 50) {
gtk_recent_info_unref(item);
g_list_free(list);
return recent;
}
i++;
}
/* Callback for when of the items from the File->Open Recent submenu
is selected */
void
action_open_recent(GtkAction *action, I7App *app)
{
GtkRecentInfo *item = gtk_recent_chooser_get_current_item(GTK_RECENT_CHOOSER(action));
g_assert(gtk_recent_info_has_application(item, "Inform 7"));
GFile *file = g_file_new_for_uri(gtk_recent_info_get_uri(item));
if(gtk_recent_info_has_group(item, "inform7_project")) {
i7_story_new_from_file(app, file);
} else if(gtk_recent_info_has_group(item, "inform7_extension")) {
i7_extension_new_from_file(app, file, FALSE);
} else if(gtk_recent_info_has_group(item, "inform7_builtin")) {
i7_extension_new_from_file(app, file, TRUE);
} else {
g_warning("Recent manager file does not have an Inform tag. This means "
"it was not saved by Inform. I'll try to open it anyway.");
i7_story_new_from_file(app, file);
}
g_object_unref(file);
gtk_recent_info_unref(item);
}
static void
cb_response (GtkWidget *dialog,
gint response_id,
WBCGtk *wbcg)
{
GtkBuilder *gui = g_object_get_data (G_OBJECT (dialog), "gui");
GtkTreeView *tv = GTK_TREE_VIEW (gtk_builder_get_object (gui, "docs_treeview"));
GtkTreeSelection *tsel = gtk_tree_view_get_selection (tv);
switch (response_id) {
case GTK_RESPONSE_OK: {
GtkTreeModel *model;
GtkTreeIter iter;
char *uri = NULL;
if (gtk_tree_selection_get_selected (tsel, &model, &iter)) {
GtkRecentInfo *info;
gtk_tree_model_get (model, &iter, RECENT_COL_INFO, &info, -1);
uri = g_strdup (gtk_recent_info_get_uri (info));
gtk_recent_info_unref (info);
}
gtk_widget_destroy (dialog);
if (uri) {
gui_file_read (wbcg, uri, NULL, NULL);
g_free (uri);
}
break;
}
default:
gtk_widget_destroy (dialog);
}
}
static void load_items (CinnamonDocSystem *self)
{
CinnamonDocSystemPrivate *priv = self->priv;
GList *items, *iter;
int i;
self->priv->infos_by_timestamp = NULL;
items = (GList*) g_slist_sort ((GSList*) gtk_recent_manager_get_items (priv->manager),
sort_infos_by_timestamp_descending);
i = 0;
for (iter = items; iter; iter = iter->next)
{
GtkRecentInfo *info = iter->data;
if (i < MAX_RECENT_ITEMS) {
priv->infos_by_timestamp = g_slist_prepend (priv->infos_by_timestamp, info);
}
else {
gtk_recent_info_unref (info);
}
i++;
}
priv->infos_by_timestamp = g_slist_reverse (priv->infos_by_timestamp);
g_list_free (items);
}
GtkWidget *
totem_open_location_new (void)
{
TotemOpenLocation *open_location;
char *clipboard_location;
GtkEntryCompletion *completion;
GtkTreeModel *model;
GList *recent_items, *streams_recent_items = NULL;
open_location = TOTEM_OPEN_LOCATION (g_object_new (TOTEM_TYPE_OPEN_LOCATION, NULL));
if (open_location->priv->uri_container == NULL) {
g_object_unref (open_location);
return NULL;
}
gtk_window_set_title (GTK_WINDOW (open_location), _("Open Location..."));
gtk_dialog_add_buttons (GTK_DIALOG (open_location),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_response_sensitive (GTK_DIALOG (open_location), GTK_RESPONSE_OK, FALSE);
gtk_container_set_border_width (GTK_CONTAINER (open_location), 5);
gtk_dialog_set_default_response (GTK_DIALOG (open_location), GTK_RESPONSE_OK);
/* Get item from clipboard to fill GtkEntry */
clipboard_location = totem_open_location_set_from_clipboard (open_location);
if (clipboard_location != NULL && strcmp (clipboard_location, "") != 0)
gtk_entry_set_text (open_location->priv->uri_entry, clipboard_location);
g_free (clipboard_location);
/* Add items in Totem's GtkRecentManager to the URI GtkEntry's GtkEntryCompletion */
completion = gtk_entry_completion_new();
model = GTK_TREE_MODEL (gtk_list_store_new (1, G_TYPE_STRING));
gtk_entry_set_completion (open_location->priv->uri_entry, completion);
recent_items = gtk_recent_manager_get_items (gtk_recent_manager_get_default ());
if (recent_items != NULL)
{
GList *p;
GtkTreeIter iter;
/* Filter out non-Totem items */
for (p = recent_items; p != NULL; p = p->next)
{
GtkRecentInfo *info = (GtkRecentInfo *) p->data;
if (!gtk_recent_info_has_group (info, "TotemStreams")) {
gtk_recent_info_unref (info);
continue;
}
streams_recent_items = g_list_prepend (streams_recent_items, info);
}
streams_recent_items = g_list_sort (streams_recent_items, (GCompareFunc) totem_compare_recent_stream_items);
/* Populate the list store for the combobox */
for (p = streams_recent_items; p != NULL; p = p->next)
{
GtkRecentInfo *info = (GtkRecentInfo *) p->data;
gtk_list_store_append (GTK_LIST_STORE (model), &iter);
gtk_list_store_set (GTK_LIST_STORE (model), &iter, 0, gtk_recent_info_get_uri (info), -1);
gtk_recent_info_unref (info);
}
g_list_free (streams_recent_items);
}
g_list_free (recent_items);
gtk_entry_completion_set_model (completion, model);
gtk_entry_completion_set_text_column (completion, 0);
gtk_entry_completion_set_match_func (completion, (GtkEntryCompletionMatchFunc) totem_open_location_match, model, NULL);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (open_location))),
open_location->priv->uri_container,
TRUE, /* expand */
TRUE, /* fill */
0); /* padding */
gtk_widget_show_all (gtk_dialog_get_content_area (GTK_DIALOG (open_location)));
return GTK_WIDGET (open_location);
}
GList *
gedit_recent_get_items (GeditRecentConfiguration *config)
{
GtkRecentFilterFlags needed;
GList *items;
GList *retitems = NULL;
gint length;
gboolean has_substring_filter;
if (config->limit == 0)
{
return NULL;
}
items = gtk_recent_manager_get_items (config->manager);
if (!items)
{
return NULL;
}
needed = gtk_recent_filter_get_needed (config->filter);
has_substring_filter = (config->substring_filter && *config->substring_filter != '\0');
while (items)
{
GtkRecentInfo *info;
GtkRecentFilterInfo filter_info;
gboolean is_filtered;
info = items->data;
is_filtered = FALSE;
if (config->local_only && !gtk_recent_info_is_local (info))
{
is_filtered = TRUE;
}
else if (!config->show_private && gtk_recent_info_get_private_hint (info))
{
is_filtered = TRUE;
}
else if (!config->show_not_found && !gtk_recent_info_exists (info))
{
is_filtered = TRUE;
}
else
{
if (has_substring_filter)
{
gchar *uri_lower;
uri_lower = g_utf8_strdown (gtk_recent_info_get_uri (info), -1);
if (strstr (uri_lower, config->substring_filter) == NULL)
{
is_filtered = TRUE;
}
g_free (uri_lower);
}
if (!is_filtered)
{
populate_filter_info (info, &filter_info, needed);
is_filtered = !gtk_recent_filter_filter (config->filter, &filter_info);
/* these we own */
if (filter_info.applications)
{
g_strfreev ((gchar **) filter_info.applications);
}
if (filter_info.groups)
{
g_strfreev ((gchar **) filter_info.groups);
}
}
}
if (!is_filtered)
{
retitems = g_list_prepend (retitems, info);
}
else
{
gtk_recent_info_unref (info);
}
items = g_list_delete_link (items, items);
}
if (!retitems)
{
return NULL;
}
retitems = g_list_sort_with_data (retitems, (GCompareDataFunc) sort_recent_items_mru, NULL);
length = g_list_length (retitems);
if ((config->limit != -1) && (length > config->limit))
{
GList *clamp, *l;
clamp = g_list_nth (retitems, config->limit - 1);
if (!clamp)
{
return retitems;
}
l = clamp->next;
clamp->next = NULL;
g_list_free_full (l, (GDestroyNotify) gtk_recent_info_unref);
}
return retitems;
}
/*
* _gtk_recent_chooser_get_items:
* @chooser: a #GtkRecentChooser
* @filter: a #GtkRecentFilter
* @sort_func: (allow-none): sorting function, or %NULL
* @sort_data: (allow-none): sorting function data, or %NULL
*
* Default implementation for getting the filtered, sorted and
* clamped list of recently used resources from a #GtkRecentChooser.
* This function should be used by implementations of the
* #GtkRecentChooser interface inside the GtkRecentChooser::get_items
* vfunc.
*
* Return value: a list of #GtkRecentInfo objects
*/
GList *
_gtk_recent_chooser_get_items (GtkRecentChooser *chooser,
GtkRecentFilter *filter,
GtkRecentSortFunc sort_func,
gpointer sort_data)
{
GtkRecentManager *manager;
gint limit;
GtkRecentSortType sort_type;
GList *items;
GCompareDataFunc compare_func;
gint length;
g_return_val_if_fail (GTK_IS_RECENT_CHOOSER (chooser), NULL);
manager = _gtk_recent_chooser_get_recent_manager (chooser);
if (!manager)
return NULL;
items = gtk_recent_manager_get_items (manager);
if (!items)
return NULL;
limit = gtk_recent_chooser_get_limit (chooser);
if (limit == 0)
return NULL;
if (filter)
{
GList *filter_items, *l;
gboolean local_only = FALSE;
gboolean show_private = FALSE;
gboolean show_not_found = FALSE;
g_object_get (G_OBJECT (chooser),
"local-only", &local_only,
"show-private", &show_private,
"show-not-found", &show_not_found,
NULL);
filter_items = NULL;
for (l = items; l != NULL; l = l->next)
{
GtkRecentInfo *info = l->data;
gboolean remove_item = FALSE;
if (get_is_recent_filtered (filter, info))
remove_item = TRUE;
if (local_only && !gtk_recent_info_is_local (info))
remove_item = TRUE;
if (!show_private && gtk_recent_info_get_private_hint (info))
remove_item = TRUE;
if (!show_not_found && !gtk_recent_info_exists (info))
remove_item = TRUE;
if (!remove_item)
filter_items = g_list_prepend (filter_items, info);
else
gtk_recent_info_unref (info);
}
g_list_free (items);
items = filter_items;
}
if (!items)
return NULL;
sort_type = gtk_recent_chooser_get_sort_type (chooser);
switch (sort_type)
{
case GTK_RECENT_SORT_NONE:
compare_func = NULL;
break;
case GTK_RECENT_SORT_MRU:
compare_func = (GCompareDataFunc) sort_recent_items_mru;
break;
case GTK_RECENT_SORT_LRU:
compare_func = (GCompareDataFunc) sort_recent_items_lru;
break;
case GTK_RECENT_SORT_CUSTOM:
compare_func = (GCompareDataFunc) sort_recent_items_proxy;
break;
default:
g_assert_not_reached ();
break;
}
if (compare_func)
{
SortRecentData sort_recent;
sort_recent.func = sort_func;
sort_recent.data = sort_data;
items = g_list_sort_with_data (items, compare_func, &sort_recent);
}
length = g_list_length (items);
if ((limit != -1) && (length > limit))
{
GList *clamp, *l;
clamp = g_list_nth (items, limit - 1);
if (!clamp)
return items;
l = clamp->next;
clamp->next = NULL;
g_list_free_full (l, (GDestroyNotify) gtk_recent_info_unref);
}
return items;
}
void
documents_clear_cmd_callback (GtkAction *action,
gpointer data)
{
GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (data);
GimpContext *context = gimp_container_view_get_context (editor->view);
Gimp *gimp = context->gimp;
GtkWidget *dialog;
dialog = gimp_message_dialog_new (_("Clear Document History"),
GIMP_STOCK_SHRED,
GTK_WIDGET (editor),
GTK_DIALOG_MODAL |
GTK_DIALOG_DESTROY_WITH_PARENT,
gimp_standard_help_func, NULL,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_CLEAR, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
g_signal_connect_object (gtk_widget_get_toplevel (GTK_WIDGET (editor)),
"unmap",
G_CALLBACK (gtk_widget_destroy),
dialog, G_CONNECT_SWAPPED);
gimp_message_box_set_primary_text (GIMP_MESSAGE_DIALOG (dialog)->box,
_("Clear the Recent Documents list?"));
gimp_message_box_set_text (GIMP_MESSAGE_DIALOG (dialog)->box,
_("Clearing the document history will "
"permanently remove all images from "
"the recent documents list."));
if (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK)
{
GtkRecentManager *manager = gtk_recent_manager_get_default ();
GList *items;
GList *list;
items = gtk_recent_manager_get_items (manager);
for (list = items; list; list = list->next)
{
GtkRecentInfo *info = list->data;
if (gtk_recent_info_has_application (info,
"GNU Image Manipulation Program"))
{
gtk_recent_manager_remove_item (manager,
gtk_recent_info_get_uri (info),
NULL);
}
gtk_recent_info_unref (info);
}
g_list_free (items);
gimp_container_clear (gimp->documents);
}
gtk_widget_destroy (dialog);
}
static void
reload_recent_items (GVfsBackendRecent *backend)
{
GVfsMonitor *monitor;
GList *items;
GList *node;
GList *added = NULL;
GList *changed = NULL;
GList *not_seen_items = NULL;
GList *l;
not_seen_items = g_hash_table_get_values (backend->items);
items = gtk_recent_manager_get_items (backend->recent_manager);
for (node = items; node; node = node->next)
{
GtkRecentInfo *recent_info = node->data;
const char *uri;
const char *guid;
if (!gtk_recent_info_is_local (recent_info)
|| gtk_recent_info_get_private_hint (recent_info)
|| g_strcmp0 (gtk_recent_info_get_mime_type (recent_info), "inode/directory") == 0)
continue;
uri = gtk_recent_info_get_uri (recent_info);
guid = g_hash_table_lookup (backend->uri_map, uri);
if (guid)
{
if (gtk_recent_info_exists (recent_info))
{
RecentItem *item;
item = g_hash_table_lookup (backend->items, guid);
if (recent_item_update (item, recent_info))
changed = g_list_prepend (changed, item->guid);
not_seen_items = g_list_remove (not_seen_items, item);
}
}
else
{
RecentItem *item;
item = recent_item_new (recent_info);
added = g_list_prepend (added, item->guid);
g_hash_table_insert (backend->items, item->guid, item);
g_hash_table_insert (backend->uri_map, item->uri, item->guid);
}
gtk_recent_info_unref (recent_info);
}
g_list_free (items);
monitor = recent_backend_get_dir_monitor (backend, FALSE);
/* process removals */
for (l = not_seen_items; l; l = l->next)
{
RecentItem *item = l->data;
g_hash_table_remove (backend->uri_map, item->uri);
g_hash_table_steal (backend->items, item->guid);
if (monitor)
g_vfs_monitor_emit_event (monitor, G_FILE_MONITOR_EVENT_DELETED, item->guid, NULL);
recent_item_free (item);
}
g_list_free (not_seen_items);
/* process additions */
if (monitor)
{
for (l = added; l; l = l->next)
g_vfs_monitor_emit_event (monitor, G_FILE_MONITOR_EVENT_CREATED, l->data, NULL);
}
g_list_free (added);
/* process changes */
for (l = changed; l; l = l->next)
{
/* FIXME: signals */
}
g_list_free (changed);
if (monitor)
g_object_unref (monitor);
}
static void
on_pixbuf_loaded (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
GSList *iter;
StTextureCache *cache;
AsyncTextureLoadData *data;
GdkPixbuf *pixbuf;
GError *error = NULL;
CoglHandle texdata = NULL;
data = user_data;
cache = ST_TEXTURE_CACHE (source);
g_hash_table_remove (cache->priv->outstanding_requests, data->key);
pixbuf = load_pixbuf_async_finish (cache, result, &error);
if (pixbuf == NULL)
pixbuf = load_pixbuf_fallback (data);
if (pixbuf == NULL)
goto out;
texdata = pixbuf_to_cogl_handle (pixbuf);
g_object_unref (pixbuf);
if (data->policy != ST_TEXTURE_CACHE_POLICY_NONE)
{
gpointer orig_key, value;
if (!g_hash_table_lookup_extended (cache->priv->keyed_cache, data->key,
&orig_key, &value))
{
cogl_handle_ref (texdata);
g_hash_table_insert (cache->priv->keyed_cache, g_strdup (data->key),
texdata);
}
}
for (iter = data->textures; iter; iter = iter->next)
{
ClutterTexture *texture = iter->data;
set_texture_cogl_texture (texture, texdata);
}
out:
if (texdata)
cogl_handle_unref (texdata);
g_free (data->key);
if (data->icon)
{
gtk_icon_info_free (data->icon_info);
g_object_unref (data->icon);
}
else if (data->uri)
g_free (data->uri);
if (data->recent_info)
gtk_recent_info_unref (data->recent_info);
if (data->mimetype)
g_free (data->mimetype);
/* Alternatively we could weakref and just do nothing if the texture
is destroyed */
for (iter = data->textures; iter; iter = iter->next)
{
ClutterTexture *texture = iter->data;
g_object_unref (texture);
}
g_clear_error (&error);
g_free (data);
}
