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); }