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);
}
static void
refresh_recent_project_view (GtkListBox *box)
{
GSettings *settings;
GtkRecentManager *manager;
GtkRecentData *recent_project;
GList *items, *list;
gint i;
guint recent_limit;
manager = gtk_recent_manager_get_default ();
items = gtk_recent_manager_get_items (manager);
items = g_list_reverse (items);
list = items;
settings = g_settings_new (PREF_SCHEMA);
i = 0;
g_settings_get (settings, RECENT_LIMIT, "i", &recent_limit);
while (i < recent_limit && list != NULL)
{
if (strcmp (gtk_recent_info_get_mime_type (list->data), "application/x-anjuta") == 0)
{
recent_project = list->data;
add_recent_project_row (box, recent_project);
i++;
}
list = list->next;
}
g_list_free_full(items, (GDestroyNotify)gtk_recent_info_unref);
g_object_unref (settings);
}
static gboolean
get_is_recent_filtered (GtkRecentFilter *filter,
GtkRecentInfo *info)
{
GtkRecentFilterInfo filter_info;
GtkRecentFilterFlags needed;
gboolean retval;
g_assert (info != NULL);
needed = gtk_recent_filter_get_needed (filter);
filter_info.contains = GTK_RECENT_FILTER_URI | GTK_RECENT_FILTER_MIME_TYPE;
filter_info.uri = gtk_recent_info_get_uri (info);
filter_info.mime_type = gtk_recent_info_get_mime_type (info);
if (needed & GTK_RECENT_FILTER_DISPLAY_NAME)
{
filter_info.display_name = gtk_recent_info_get_display_name (info);
filter_info.contains |= GTK_RECENT_FILTER_DISPLAY_NAME;
}
else
filter_info.uri = NULL;
if (needed & GTK_RECENT_FILTER_APPLICATION)
{
filter_info.applications = (const gchar **) gtk_recent_info_get_applications (info, NULL);
filter_info.contains |= GTK_RECENT_FILTER_APPLICATION;
}
else
filter_info.applications = NULL;
if (needed & GTK_RECENT_FILTER_GROUP)
{
filter_info.groups = (const gchar **) gtk_recent_info_get_groups (info, NULL);
filter_info.contains |= GTK_RECENT_FILTER_GROUP;
}
else
filter_info.groups = NULL;
if (needed & GTK_RECENT_FILTER_AGE)
{
filter_info.age = gtk_recent_info_get_age (info);
filter_info.contains |= GTK_RECENT_FILTER_AGE;
}
else
filter_info.age = -1;
retval = gtk_recent_filter_filter (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);
return !retval;
}
/**
* gnm_app_history_get_list:
*
* creating it if necessary.
*
* Return value: (element-type char) (transfer full): the list, which must be
* freed along with the strings in it.
**/
GSList *
gnm_app_history_get_list (int max_elements)
{
GSList *res = NULL;
GList *items, *l;
GtkFileFilter *filter;
int n_elements = 0;
if (app->recent == NULL)
return NULL;
items = gtk_recent_manager_get_items (app->recent);
items = g_list_sort (items, (GCompareFunc)compare_mru);
filter = gnm_app_create_opener_filter (NULL);
for (l = items; l && n_elements < max_elements; l = l->next) {
GtkRecentInfo *ri = l->data;
const char *uri = gtk_recent_info_get_uri (ri);
gboolean want_it;
if (gtk_recent_info_has_application (ri, g_get_application_name ())) {
want_it = TRUE;
} else {
GtkFileFilterInfo fi;
char *display_name = g_filename_display_basename (uri);
memset (&fi, 0, sizeof (fi));
fi.contains = (GTK_FILE_FILTER_MIME_TYPE |
GTK_FILE_FILTER_URI |
GTK_FILE_FILTER_DISPLAY_NAME);
fi.uri = uri;
fi.mime_type = gtk_recent_info_get_mime_type (ri);
fi.display_name = display_name;
want_it = gtk_file_filter_filter (filter, &fi);
g_free (display_name);
}
if (want_it) {
char *filename = go_filename_from_uri (uri);
if (filename && !g_file_test (filename, G_FILE_TEST_EXISTS))
want_it = FALSE;
g_free (filename);
}
if (want_it) {
res = g_slist_prepend (res, g_strdup (uri));
n_elements++;
}
}
g_list_free_full (items, (GDestroyNotify)gtk_recent_info_unref);
g_object_ref_sink (filter);
g_object_unref (filter);
return g_slist_reverse (res);
}
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 GIcon *
icon_for_recent (GtkRecentInfo *info)
{
const char *mimetype;
mimetype = gtk_recent_info_get_mime_type (info);
if (!mimetype)
{
return g_themed_icon_new (GTK_STOCK_FILE);
}
return icon_for_mimetype (mimetype);
}
static void
populate_filter_info (GtkRecentInfo *info,
GtkRecentFilterInfo *filter_info,
GtkRecentFilterFlags needed)
{
filter_info->uri = gtk_recent_info_get_uri (info);
filter_info->mime_type = gtk_recent_info_get_mime_type (info);
filter_info->contains = GTK_RECENT_FILTER_URI | GTK_RECENT_FILTER_MIME_TYPE;
if (needed & GTK_RECENT_FILTER_DISPLAY_NAME)
{
filter_info->display_name = gtk_recent_info_get_display_name (info);
filter_info->contains |= GTK_RECENT_FILTER_DISPLAY_NAME;
}
else
{
filter_info->uri = NULL;
}
if (needed & GTK_RECENT_FILTER_APPLICATION)
{
filter_info->applications = (const gchar **) gtk_recent_info_get_applications (info, NULL);
filter_info->contains |= GTK_RECENT_FILTER_APPLICATION;
}
else
{
filter_info->applications = NULL;
}
if (needed & GTK_RECENT_FILTER_GROUP)
{
filter_info->groups = (const gchar **) gtk_recent_info_get_groups (info, NULL);
filter_info->contains |= GTK_RECENT_FILTER_GROUP;
}
else
{
filter_info->groups = NULL;
}
if (needed & GTK_RECENT_FILTER_AGE)
{
filter_info->age = gtk_recent_info_get_age (info);
filter_info->contains |= GTK_RECENT_FILTER_AGE;
}
else
{
filter_info->age = -1;
}
}
static void
load_pixbuf_thread (GSimpleAsyncResult *result,
GObject *object,
GCancellable *cancellable)
{
GdkPixbuf *pixbuf;
AsyncIconLookupData *data;
GError *error = NULL;
data = g_object_get_data (G_OBJECT (result), "load_pixbuf_async");
g_assert (data != NULL);
if (data->thumbnail)
{
const char *uri;
const char *mimetype;
if (data->recent_info)
{
uri = gtk_recent_info_get_uri (data->recent_info);
mimetype = gtk_recent_info_get_mime_type (data->recent_info);
}
else
{
uri = data->uri;
mimetype = data->mimetype;
}
pixbuf = impl_load_thumbnail (data->cache, uri, mimetype, data->width, &error);
}
else if (data->uri)
pixbuf = impl_load_pixbuf_file (data->uri, data->width, data->height, &error);
else if (data->icon)
pixbuf = impl_load_pixbuf_gicon (data->icon, data->icon_info, data->width, &error);
else
g_assert_not_reached ();
if (error != NULL)
{
g_simple_async_result_set_from_error (result, error);
return;
}
if (pixbuf)
g_simple_async_result_set_op_res_gpointer (result, g_object_ref (pixbuf),
g_object_unref);
}
static void
build_recent_projects (GtkWidget *box, Starter *wcm)
{
GtkRecentManager *manager;
GList *list;
gint limit = 1000;
gint i = 0;
manager = gtk_recent_manager_get_default ();
list = gtk_recent_manager_get_items (manager);
while (i < limit && list != NULL)
{
if (strcmp (gtk_recent_info_get_mime_type (list->data), "application/x-anjuta") == 0)
{
GtkWidget *button;
GFile *file;
button = anjuta_starter_button_new (gtk_recent_info_get_display_name (list->data));
gtk_widget_show (button);
gtk_box_pack_start (GTK_BOX (box), button, TRUE, TRUE, 0);
file = g_file_new_for_uri (gtk_recent_info_get_uri (list->data));
g_object_set_data_full (G_OBJECT (button), "file", file,
(GDestroyNotify)destroy_notify);
g_signal_connect (button, "clicked",
G_CALLBACK (recent_project_clicked_cb),
wcm);
}
i++;
list = g_list_next (list);
}
g_list_foreach (list, (GFunc)gtk_recent_info_unref, NULL);
g_list_free (list);
}
static VALUE
rg_mime_type(VALUE self)
{
return CSTR2RVAL(gtk_recent_info_get_mime_type(_SELF(self)));
}
/**
* shell_doc_system_open:
* @system: A #ShellDocSystem
* @info: A #GtkRecentInfo
* @workspace: Open on this workspace, or -1 for default
*
* Launch the default application associated with the mime type of
* @info, using its uri.
*/
void
shell_doc_system_open (ShellDocSystem *system,
GtkRecentInfo *info,
int workspace)
{
GFile *file;
GAppInfo *app_info;
gboolean needs_uri;
GAppLaunchContext *context;
context = shell_global_create_app_launch_context (shell_global_get ());
if (workspace != -1)
gdk_app_launch_context_set_desktop ((GdkAppLaunchContext *)context, workspace);
file = g_file_new_for_uri (gtk_recent_info_get_uri (info));
needs_uri = g_file_get_path (file) == NULL;
g_object_unref (file);
app_info = g_app_info_get_default_for_type (gtk_recent_info_get_mime_type (info), needs_uri);
if (app_info != NULL)
{
GList *uris;
uris = g_list_prepend (NULL, (gpointer)gtk_recent_info_get_uri (info));
g_app_info_launch_uris (app_info, uris, context, NULL);
g_list_free (uris);
}
else
{
char *app_name;
const char *app_exec;
char *app_exec_quoted;
guint count;
time_t time;
app_name = gtk_recent_info_last_application (info);
if (gtk_recent_info_get_application_info (info, app_name, &app_exec, &count, &time))
{
GRegex *regex;
/* TODO: Change this once better support for creating
GAppInfo is added to GtkRecentInfo, as right now
this relies on the fact that the file uri is
already a part of appExec, so we don't supply any
files to app_info.launch().
The 'command line' passed to
create_from_command_line is allowed to contain
'%<something>' macros that are expanded to file
name / icon name, etc, so we need to escape % as %%
*/
regex = g_regex_new ("%", 0, 0, NULL);
app_exec_quoted = g_regex_replace (regex, app_exec, -1, 0, "%%", 0, NULL);
g_regex_unref (regex);
app_info = g_app_info_create_from_commandline (app_exec_quoted, NULL, 0, NULL);
g_free (app_exec_quoted);
/* The point of passing an app launch context to
launch() is mostly to get startup notification and
associated benefits like the app appearing on the
right desktop; but it doesn't really work for now
because with the way we create the appInfo we
aren't reading the application's desktop file, and
thus don't find the StartupNotify=true in it. So,
despite passing the app launch context, no startup
notification occurs.
*/
g_app_info_launch (app_info, NULL, context, NULL);
}
g_free (app_name);
}
g_object_unref (context);
}
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
brasero_project_type_chooser_build_recent (BraseroProjectTypeChooser *self,
GtkRecentManager *recent)
{
GtkSizeGroup *image_group;
GtkSizeGroup *group;
GList *list = NULL;
gchar *filename;
GList *recents;
GList *iter;
recents = gtk_recent_manager_get_items (recent);
for (iter = recents; iter; iter = iter->next) {
GtkRecentInfo *info;
const gchar *mime;
info = iter->data;
mime = gtk_recent_info_get_mime_type (info);
if (!mime)
continue;
/* filter those we want */
if (strcmp (mime, "application/x-brasero")
&& strcmp (mime, "application/x-cd-image")
&& strcmp (mime, "application/x-cdrdao-toc")
&& strcmp (mime, "application/x-toc")
&& strcmp (mime, "application/x-cue")
&& strcmp (mime, "audio/x-scpls")
&& strcmp (mime, "audio/x-ms-asx")
&& strcmp (mime, "audio/x-mp3-playlist")
&& strcmp (mime, "audio/x-mpegurl"))
continue;
/* sort */
list = g_list_insert_sorted (list,
info,
brasero_project_type_chooser_sort_recent);
if (g_list_length (list) > 5)
list = g_list_delete_link (list, g_list_last (list));
}
group = gtk_size_group_new (GTK_SIZE_GROUP_BOTH);
image_group = gtk_size_group_new (GTK_SIZE_GROUP_BOTH);
/* If a project was left unfinished last time then add another entry */
filename = g_build_filename (g_get_user_config_dir (),
"brasero",
BRASERO_SESSION_TMP_PROJECT_PATH,
NULL);
if (g_file_test (filename, G_FILE_TEST_EXISTS)) {
gchar *uri;
GtkWidget *link;
GtkWidget *image;
uri = g_filename_to_uri (filename, NULL, NULL);
image = gtk_image_new_from_icon_name ("brasero", GTK_ICON_SIZE_BUTTON);
gtk_size_group_add_widget (image_group, image);
link = gtk_button_new_with_label (_("Last _Unsaved Project"));
g_object_set_data_full (G_OBJECT (link),
"BraseroButtonURI", uri,
g_free);
gtk_button_set_relief (GTK_BUTTON (link), GTK_RELIEF_NONE);
gtk_button_set_alignment (GTK_BUTTON (link), 0.0, 0.5);
gtk_button_set_focus_on_click (GTK_BUTTON (link), FALSE);
gtk_button_set_image (GTK_BUTTON (link), image);
gtk_button_set_use_underline (GTK_BUTTON (link), TRUE);
g_signal_connect (link,
"clicked",
G_CALLBACK (brasero_project_type_chooser_last_unsaved_clicked_cb),
self);
gtk_widget_show (link);
gtk_widget_set_tooltip_text (link, _("Load the last project that was not burned and not saved"));
gtk_box_pack_start (GTK_BOX (self->priv->recent_box), link, FALSE, TRUE, 0);
gtk_size_group_add_widget (group, link);
}
g_free (filename);
for (iter = list; iter; iter = iter->next) {
GtkRecentInfo *info;
GList *child_iter;
const gchar *name;
GIcon *icon;
GtkWidget *image;
const gchar *uri;
GtkWidget *child;
GtkWidget *link;
GList *children;
gchar *tooltip;
info = iter->data;
tooltip = gtk_recent_info_get_uri_display (info);
icon = gtk_recent_info_get_gicon (info);
image = gtk_image_new_from_gicon (icon, GTK_ICON_SIZE_BUTTON);
g_object_unref (icon);
gtk_size_group_add_widget (image_group, image);
gtk_widget_show (image);
gtk_widget_set_tooltip_text (image, tooltip);
name = gtk_recent_info_get_display_name (info);
uri = gtk_recent_info_get_uri (info);
/* Don't use mnemonics with filenames */
link = gtk_button_new_with_label (name);
g_object_set_data_full (G_OBJECT (link),
"BraseroButtonURI", g_strdup (uri),
g_free);
gtk_button_set_relief (GTK_BUTTON (link), GTK_RELIEF_NONE);
gtk_button_set_image (GTK_BUTTON (link), image);
gtk_button_set_alignment (GTK_BUTTON (link), 0.0, 0.5);
gtk_button_set_focus_on_click (GTK_BUTTON (link), FALSE);
g_signal_connect (link,
"clicked",
G_CALLBACK (brasero_project_type_chooser_recent_clicked_cb),
self);
gtk_widget_show (link);
gtk_widget_set_tooltip_text (link, tooltip);
gtk_box_pack_start (GTK_BOX (self->priv->recent_box), link, FALSE, TRUE, 0);
g_free (tooltip);
gtk_size_group_add_widget (group, link);
/* That's a tedious hack to avoid mnemonics which are hardcoded
* when you add an image to a button. BUG? */
if (!GTK_IS_BIN (link))
continue;
child = gtk_bin_get_child (GTK_BIN (link));
if (!GTK_IS_ALIGNMENT (child))
continue;
gtk_alignment_set (GTK_ALIGNMENT (child),
0.0,
0.5,
1.0,
1.0);
child = gtk_bin_get_child (GTK_BIN (child));
if (!GTK_IS_BOX (child))
continue;
children = gtk_container_get_children (GTK_CONTAINER (child));
for (child_iter = children; child_iter; child_iter = child_iter->next) {
GtkWidget *widget;
widget = child_iter->data;
if (GTK_IS_LABEL (widget)) {
gtk_label_set_use_underline (GTK_LABEL (widget), FALSE);
gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5);
/* Make sure that the name is not too long */
gtk_box_set_child_packing (GTK_BOX (child),
widget,
TRUE,
TRUE,
0,
GTK_PACK_START);
gtk_label_set_ellipsize (GTK_LABEL (widget),
PANGO_ELLIPSIZE_END);
break;
}
}
g_list_free (children);
}
g_object_unref (image_group);
g_object_unref (group);
if (!g_list_length (list)) {
GtkWidget *label;
gchar *string;
string = g_strdup_printf ("<i>%s</i>", _("No recently used project"));
label = gtk_label_new (string);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
g_free (string);
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (self->priv->recent_box), label, FALSE, FALSE, 0);
}
g_list_free (list);
g_list_foreach (recents, (GFunc) gtk_recent_info_unref, NULL);
g_list_free (recents);
}
