diff options
Diffstat (limited to '')
| -rw-r--r-- | src/nautilus-file-utilities.c | 1515 |
1 files changed, 1515 insertions, 0 deletions
diff --git a/src/nautilus-file-utilities.c b/src/nautilus-file-utilities.c new file mode 100644 index 0000000..6043a11 --- /dev/null +++ b/src/nautilus-file-utilities.c @@ -0,0 +1,1515 @@ +/* nautilus-file-utilities.c - implementation of file manipulation routines. + * + * Copyright (C) 1999, 2000, 2001 Eazel, Inc. + * + * The Gnome Library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public License as + * published by the Free Software Foundation; either version 2 of the + * License, or (at your option) any later version. + * + * The Gnome Library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with the Gnome Library; see the file COPYING.LIB. If not, + * see <http://www.gnu.org/licenses/>. + * + * Authors: John Sullivan <sullivan@eazel.com> + */ + +#include <config.h> +#include "nautilus-file-utilities.h" + +#include "nautilus-application.h" +#include "nautilus-global-preferences.h" +#include "nautilus-icon-names.h" +#include "nautilus-lib-self-check-functions.h" +#include "nautilus-metadata.h" +#include "nautilus-file.h" +#include "nautilus-file-operations.h" +#include "nautilus-search-directory.h" +#include "nautilus-starred-directory.h" +#include "nautilus-ui-utilities.h" +#include <eel/eel-glib-extensions.h> +#include <eel/eel-string.h> +#include <eel/eel-debug.h> +#include <eel/eel-vfs-extensions.h> +#include <glib.h> +#include <glib/gi18n.h> +#include <glib/gstdio.h> +#include <gio/gio.h> +#include <unistd.h> +#include <stdlib.h> + +#define NAUTILUS_USER_DIRECTORY_NAME "nautilus" +#define DEFAULT_NAUTILUS_DIRECTORY_MODE (0755) + +/* Allowed characters outside alphanumeric for unreserved. */ +#define G_URI_OTHER_UNRESERVED "-._~" + +/* This or something equivalent will eventually go into glib/guri.h */ +gboolean +nautilus_uri_parse (const char *uri, + char **host, + guint16 *port, + char **userinfo) +{ + g_autofree char *tmp_str = NULL; + const char *start, *p; + char c; + + g_return_val_if_fail (uri != NULL, FALSE); + + if (host) + { + *host = NULL; + } + + if (port) + { + *port = 0; + } + + if (userinfo) + { + *userinfo = NULL; + } + + /* From RFC 3986 Decodes: + * URI = scheme ":" hier-part [ "?" query ] [ "#" fragment ] + * hier-part = "//" authority path-abempty + * path-abempty = *( "/" segment ) + * authority = [ userinfo "@" ] host [ ":" port ] + */ + + /* Check we have a valid scheme */ + tmp_str = g_uri_parse_scheme (uri); + + if (tmp_str == NULL) + { + return FALSE; + } + + /* Decode hier-part: + * hier-part = "//" authority path-abempty + */ + p = uri; + start = strstr (p, "//"); + + if (start == NULL) + { + return FALSE; + } + + start += 2; + + if (strchr (start, '@') != NULL) + { + /* Decode userinfo: + * userinfo = *( unreserved / pct-encoded / sub-delims / ":" ) + * unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~" + * pct-encoded = "%" HEXDIG HEXDIG + */ + p = start; + while (1) + { + c = *p++; + + if (c == '@') + { + break; + } + + /* pct-encoded */ + if (c == '%') + { + if (!(g_ascii_isxdigit (p[0]) || + g_ascii_isxdigit (p[1]))) + { + return FALSE; + } + + p++; + + continue; + } + + /* unreserved / sub-delims / : */ + if (!(g_ascii_isalnum (c) || + strchr (G_URI_OTHER_UNRESERVED, c) || + strchr (G_URI_RESERVED_CHARS_SUBCOMPONENT_DELIMITERS, c) || + c == ':')) + { + return FALSE; + } + } + + if (userinfo) + { + *userinfo = g_strndup (start, p - start - 1); + } + + start = p; + } + else + { + p = start; + } + + + /* decode host: + * host = IP-literal / IPv4address / reg-name + * reg-name = *( unreserved / pct-encoded / sub-delims ) + */ + + /* If IPv6 or IPvFuture */ + if (*p == '[') + { + start++; + p++; + while (1) + { + c = *p++; + + if (c == ']') + { + break; + } + + /* unreserved / sub-delims */ + if (!(g_ascii_isalnum (c) || + strchr (G_URI_OTHER_UNRESERVED, c) || + strchr (G_URI_RESERVED_CHARS_SUBCOMPONENT_DELIMITERS, c) || + c == ':' || + c == '.')) + { + goto error; + } + } + } + else + { + while (1) + { + c = *p++; + + if (c == ':' || + c == '/' || + c == '?' || + c == '#' || + c == '\0') + { + break; + } + + /* pct-encoded */ + if (c == '%') + { + if (!(g_ascii_isxdigit (p[0]) || + g_ascii_isxdigit (p[1]))) + { + goto error; + } + + p++; + + continue; + } + + /* unreserved / sub-delims */ + if (!(g_ascii_isalnum (c) || + strchr (G_URI_OTHER_UNRESERVED, c) || + strchr (G_URI_RESERVED_CHARS_SUBCOMPONENT_DELIMITERS, c))) + { + goto error; + } + } + } + + if (host) + { + *host = g_uri_unescape_segment (start, p - 1, NULL); + } + + if (c == ':') + { + /* Decode pot: + * port = *DIGIT + */ + guint tmp = 0; + + while (1) + { + c = *p++; + + if (c == '/' || + c == '?' || + c == '#' || + c == '\0') + { + break; + } + + if (!g_ascii_isdigit (c)) + { + goto error; + } + + tmp = (tmp * 10) + (c - '0'); + + if (tmp > 65535) + { + goto error; + } + } + if (port) + { + *port = (guint16) tmp; + } + } + + return TRUE; + +error: + if (host && *host) + { + g_free (*host); + *host = NULL; + } + + if (userinfo && *userinfo) + { + g_free (*userinfo); + *userinfo = NULL; + } + + return FALSE; +} + +char * +nautilus_compute_title_for_location (GFile *location) +{ + NautilusFile *file; + GMount *mount; + char *title; + + /* TODO-gio: This doesn't really work all that great if the + * info about the file isn't known atm... */ + + if (nautilus_is_home_directory (location)) + { + return g_strdup (_("Home")); + } + + if ((mount = nautilus_get_mounted_mount_for_root (location)) != NULL) + { + title = g_mount_get_name (mount); + + g_object_unref (mount); + + return title; + } + + title = NULL; + if (location) + { + file = nautilus_file_get (location); + + if (nautilus_file_is_other_locations (file)) + { + title = g_strdup (_("Other Locations")); + } + else if (nautilus_file_is_starred_location (file)) + { + title = g_strdup (_("Starred")); + } + else + { + title = nautilus_file_get_description (file); + + if (title == NULL) + { + title = nautilus_file_get_display_name (file); + } + } + nautilus_file_unref (file); + } + + if (title == NULL) + { + title = g_file_get_basename (location); + } + + return title; +} + + +/** + * nautilus_get_user_directory: + * + * Get the path for the directory containing nautilus settings. + * + * Return value: the directory path. + **/ +char * +nautilus_get_user_directory (void) +{ + char *user_directory = NULL; + + user_directory = g_build_filename (g_get_user_config_dir (), + NAUTILUS_USER_DIRECTORY_NAME, + NULL); + + if (!g_file_test (user_directory, G_FILE_TEST_EXISTS)) + { + g_mkdir_with_parents (user_directory, DEFAULT_NAUTILUS_DIRECTORY_MODE); + /* FIXME bugzilla.gnome.org 41286: + * How should we handle the case where this mkdir fails? + * Note that nautilus_application_startup will refuse to launch if this + * directory doesn't get created, so that case is OK. But the directory + * could be deleted after Nautilus was launched, and perhaps + * there is some bad side-effect of not handling that case. + */ + } + + return user_directory; +} + +/** + * nautilus_get_scripts_directory_path: + * + * Get the path for the directory containing nautilus scripts. + * + * Return value: the directory path containing nautilus scripts + **/ +char * +nautilus_get_scripts_directory_path (void) +{ + return g_build_filename (g_get_user_data_dir (), "nautilus", "scripts", NULL); +} + +char * +nautilus_get_home_directory_uri (void) +{ + return g_filename_to_uri (g_get_home_dir (), NULL, NULL); +} + + +gboolean +nautilus_should_use_templates_directory (void) +{ + const char *dir; + gboolean res; + + dir = g_get_user_special_dir (G_USER_DIRECTORY_TEMPLATES); + res = dir && (g_strcmp0 (dir, g_get_home_dir ()) != 0); + return res; +} + +char * +nautilus_get_templates_directory (void) +{ + return g_strdup (g_get_user_special_dir (G_USER_DIRECTORY_TEMPLATES)); +} + +char * +nautilus_get_templates_directory_uri (void) +{ + char *directory, *uri; + + directory = nautilus_get_templates_directory (); + uri = g_filename_to_uri (directory, NULL, NULL); + g_free (directory); + return uri; +} + +gboolean +nautilus_is_home_directory_file (GFile *dir, + const char *filename) +{ + char *dirname; + static GFile *home_dir_dir = NULL; + static char *home_dir_filename = NULL; + + if (home_dir_dir == NULL) + { + dirname = g_path_get_dirname (g_get_home_dir ()); + home_dir_dir = g_file_new_for_path (dirname); + g_free (dirname); + home_dir_filename = g_path_get_basename (g_get_home_dir ()); + } + + return (g_file_equal (dir, home_dir_dir) && + strcmp (filename, home_dir_filename) == 0); +} + +gboolean +nautilus_is_home_directory (GFile *dir) +{ + static GFile *home_dir = NULL; + + if (home_dir == NULL) + { + home_dir = g_file_new_for_path (g_get_home_dir ()); + } + + return g_file_equal (dir, home_dir); +} + +gboolean +nautilus_is_root_directory (GFile *dir) +{ + static GFile *root_dir = NULL; + + if (root_dir == NULL) + { + root_dir = g_file_new_for_path ("/"); + } + + return g_file_equal (dir, root_dir); +} + +gboolean +nautilus_is_search_directory (GFile *dir) +{ + g_autofree gchar *uri = NULL; + + uri = g_file_get_uri (dir); + return eel_uri_is_search (uri); +} + +gboolean +nautilus_is_recent_directory (GFile *dir) +{ + g_autofree gchar *uri = NULL; + + uri = g_file_get_uri (dir); + + return eel_uri_is_recent (uri); +} + +gboolean +nautilus_is_starred_directory (GFile *dir) +{ + g_autofree gchar *uri = NULL; + + uri = g_file_get_uri (dir); + + if (eel_uri_is_starred (uri)) + { + return TRUE; + } + + return FALSE; +} + +gboolean +nautilus_is_trash_directory (GFile *dir) +{ + g_autofree gchar *uri = NULL; + + uri = g_file_get_uri (dir); + return eel_uri_is_trash (uri); +} + +gboolean +nautilus_is_other_locations_directory (GFile *dir) +{ + g_autofree gchar *uri = NULL; + + uri = g_file_get_uri (dir); + return eel_uri_is_other_locations (uri); +} + +GMount * +nautilus_get_mounted_mount_for_root (GFile *location) +{ + g_autoptr (GVolumeMonitor) volume_monitor = NULL; + GList *mounts; + GList *l; + GMount *mount; + GMount *result = NULL; + GFile *root = NULL; + + volume_monitor = g_volume_monitor_get (); + mounts = g_volume_monitor_get_mounts (volume_monitor); + + for (l = mounts; l != NULL; l = l->next) + { + mount = l->data; + + if (g_mount_is_shadowed (mount)) + { + continue; + } + + root = g_mount_get_root (mount); + if (g_file_equal (location, root)) + { + result = g_object_ref (mount); + break; + } + } + + g_clear_object (&root); + g_list_free_full (mounts, g_object_unref); + + return result; +} + +GFile * +nautilus_generate_unique_file_in_directory (GFile *directory, + const char *basename) +{ + g_autofree char *basename_without_extension = NULL; + const char *extension; + GFile *child; + int copy; + + g_return_val_if_fail (directory != NULL, NULL); + g_return_val_if_fail (basename != NULL, NULL); + g_return_val_if_fail (g_file_query_exists (directory, NULL), NULL); + + basename_without_extension = eel_filename_strip_extension (basename); + extension = eel_filename_get_extension_offset (basename); + + child = g_file_get_child (directory, basename); + + copy = 1; + while (g_file_query_exists (child, NULL)) + { + g_autofree char *filename = NULL; + + g_object_unref (child); + + filename = g_strdup_printf ("%s (%d)%s", + basename_without_extension, + copy, + extension ? extension : ""); + child = g_file_get_child (directory, filename); + + copy++; + } + + return child; +} + +GFile * +nautilus_find_existing_uri_in_hierarchy (GFile *location) +{ + GFileInfo *info; + GFile *tmp; + + g_assert (location != NULL); + + location = g_object_ref (location); + while (location != NULL) + { + info = g_file_query_info (location, + G_FILE_ATTRIBUTE_STANDARD_NAME, + 0, NULL, NULL); + g_object_unref (info); + if (info != NULL) + { + return location; + } + tmp = location; + location = g_file_get_parent (location); + g_object_unref (tmp); + } + + return location; +} + +static gboolean +have_program_in_path (const char *name) +{ + gchar *path; + gboolean result; + + path = g_find_program_in_path (name); + result = (path != NULL); + g_free (path); + return result; +} + +static GIcon * +special_directory_get_icon (GUserDirectory directory, + gboolean symbolic) +{ +#define ICON_CASE(x) \ + case G_USER_DIRECTORY_ ## x: \ + return (symbolic) ? g_themed_icon_new (NAUTILUS_ICON_FOLDER_ ## x) : g_themed_icon_new (NAUTILUS_ICON_FULLCOLOR_FOLDER_ ## x); + + switch (directory) + { + ICON_CASE (DOCUMENTS); + ICON_CASE (DOWNLOAD); + ICON_CASE (MUSIC); + ICON_CASE (PICTURES); + ICON_CASE (PUBLIC_SHARE); + ICON_CASE (TEMPLATES); + ICON_CASE (VIDEOS); + + default: + { + return (symbolic) ? g_themed_icon_new (NAUTILUS_ICON_FOLDER) : g_themed_icon_new (NAUTILUS_ICON_FULLCOLOR_FOLDER); + } + } + +#undef ICON_CASE +} + +GIcon * +nautilus_special_directory_get_symbolic_icon (GUserDirectory directory) +{ + return special_directory_get_icon (directory, TRUE); +} + +GIcon * +nautilus_special_directory_get_icon (GUserDirectory directory) +{ + return special_directory_get_icon (directory, FALSE); +} + +gboolean +nautilus_is_file_roller_installed (void) +{ + static int installed = -1; + + if (installed < 0) + { + if (have_program_in_path ("file-roller")) + { + installed = 1; + } + else + { + installed = 0; + } + } + + return installed > 0 ? TRUE : FALSE; +} + +GHashTable * +nautilus_trashed_files_get_original_directories (GList *files, + GList **unhandled_files) +{ + GHashTable *directories; + NautilusFile *file, *original_file, *original_dir; + GList *l, *m; + + directories = NULL; + + if (unhandled_files != NULL) + { + *unhandled_files = NULL; + } + + for (l = files; l != NULL; l = l->next) + { + file = NAUTILUS_FILE (l->data); + original_file = nautilus_file_get_trash_original_file (file); + + original_dir = NULL; + if (original_file != NULL) + { + original_dir = nautilus_file_get_parent (original_file); + } + + if (original_dir != NULL) + { + if (directories == NULL) + { + directories = g_hash_table_new_full (g_direct_hash, g_direct_equal, + (GDestroyNotify) nautilus_file_unref, + (GDestroyNotify) nautilus_file_list_free); + } + nautilus_file_ref (original_dir); + m = g_hash_table_lookup (directories, original_dir); + if (m != NULL) + { + g_hash_table_steal (directories, original_dir); + nautilus_file_unref (original_dir); + } + m = g_list_append (m, nautilus_file_ref (file)); + g_hash_table_insert (directories, original_dir, m); + } + else if (unhandled_files != NULL) + { + *unhandled_files = g_list_append (*unhandled_files, nautilus_file_ref (file)); + } + + nautilus_file_unref (original_file); + nautilus_file_unref (original_dir); + } + + return directories; +} + +GList * +nautilus_file_list_from_uri_list (GList *uris) +{ + GList *l; + GList *result = NULL; + + for (l = uris; l != NULL; l = l->next) + { + g_autoptr (GFile) location = NULL; + + location = g_file_new_for_uri (l->data); + result = g_list_prepend (result, nautilus_file_get (location)); + } + + return g_list_reverse (result); +} + +static GList * +locations_from_file_list (GList *file_list) +{ + NautilusFile *file; + GList *l, *ret; + + ret = NULL; + + for (l = file_list; l != NULL; l = l->next) + { + file = NAUTILUS_FILE (l->data); + ret = g_list_prepend (ret, nautilus_file_get_location (file)); + } + + return g_list_reverse (ret); +} + +typedef struct +{ + GHashTable *original_dirs_hash; + GtkWindow *parent_window; +} RestoreFilesData; + +static void +ensure_dirs_task_ready_cb (GObject *_source, + GAsyncResult *res, + gpointer user_data) +{ + NautilusFile *original_dir; + GFile *original_dir_location; + GList *original_dirs, *files, *locations, *l; + RestoreFilesData *data = user_data; + + original_dirs = g_hash_table_get_keys (data->original_dirs_hash); + for (l = original_dirs; l != NULL; l = l->next) + { + original_dir = NAUTILUS_FILE (l->data); + original_dir_location = nautilus_file_get_location (original_dir); + + files = g_hash_table_lookup (data->original_dirs_hash, original_dir); + locations = locations_from_file_list (files); + + nautilus_file_operations_move_async (locations, + original_dir_location, + data->parent_window, + NULL, NULL, NULL); + + g_list_free_full (locations, g_object_unref); + g_object_unref (original_dir_location); + } + + g_list_free (original_dirs); + + g_hash_table_unref (data->original_dirs_hash); + g_slice_free (RestoreFilesData, data); +} + +static void +ensure_dirs_task_thread_func (GTask *task, + gpointer source, + gpointer task_data, + GCancellable *cancellable) +{ + RestoreFilesData *data = task_data; + NautilusFile *original_dir; + GFile *original_dir_location; + GList *original_dirs, *l; + + original_dirs = g_hash_table_get_keys (data->original_dirs_hash); + for (l = original_dirs; l != NULL; l = l->next) + { + original_dir = NAUTILUS_FILE (l->data); + original_dir_location = nautilus_file_get_location (original_dir); + + g_file_make_directory_with_parents (original_dir_location, cancellable, NULL); + g_object_unref (original_dir_location); + } + + g_task_return_pointer (task, NULL, NULL); +} + +static void +restore_files_ensure_parent_directories (GHashTable *original_dirs_hash, + GtkWindow *parent_window) +{ + RestoreFilesData *data; + GTask *ensure_dirs_task; + + data = g_slice_new0 (RestoreFilesData); + data->parent_window = parent_window; + data->original_dirs_hash = g_hash_table_ref (original_dirs_hash); + + ensure_dirs_task = g_task_new (NULL, NULL, ensure_dirs_task_ready_cb, data); + g_task_set_task_data (ensure_dirs_task, data, NULL); + g_task_run_in_thread (ensure_dirs_task, ensure_dirs_task_thread_func); + g_object_unref (ensure_dirs_task); +} + +void +nautilus_restore_files_from_trash (GList *files, + GtkWindow *parent_window) +{ + NautilusFile *file; + GHashTable *original_dirs_hash; + GList *unhandled_files, *l; + char *message, *file_name; + + original_dirs_hash = nautilus_trashed_files_get_original_directories (files, &unhandled_files); + + for (l = unhandled_files; l != NULL; l = l->next) + { + file = NAUTILUS_FILE (l->data); + file_name = nautilus_file_get_display_name (file); + message = g_strdup_printf (_("Could not determine original location of “%s” "), file_name); + g_free (file_name); + + show_dialog (message, + _("The item cannot be restored from trash"), + parent_window, + GTK_MESSAGE_WARNING); + g_free (message); + } + + if (original_dirs_hash != NULL) + { + restore_files_ensure_parent_directories (original_dirs_hash, parent_window); + g_hash_table_unref (original_dirs_hash); + } + + nautilus_file_list_unref (unhandled_files); +} + +typedef struct +{ + NautilusMountGetContent callback; + gpointer user_data; +} GetContentTypesData; + +static void +get_types_cb (GObject *source_object, + GAsyncResult *res, + gpointer user_data) +{ + GetContentTypesData *data; + char **types; + + data = user_data; + types = g_mount_guess_content_type_finish (G_MOUNT (source_object), res, NULL); + + g_object_set_data_full (source_object, + "nautilus-content-type-cache", + g_strdupv (types), + (GDestroyNotify) g_strfreev); + + if (data->callback) + { + data->callback ((const char **) types, data->user_data); + } + g_strfreev (types); + g_slice_free (GetContentTypesData, data); +} + +void +nautilus_get_x_content_types_for_mount_async (GMount *mount, + NautilusMountGetContent callback, + GCancellable *cancellable, + gpointer user_data) +{ + char **cached; + GetContentTypesData *data; + + if (mount == NULL) + { + if (callback) + { + callback (NULL, user_data); + } + return; + } + + cached = g_object_get_data (G_OBJECT (mount), "nautilus-content-type-cache"); + if (cached != NULL) + { + if (callback) + { + callback ((const char **) cached, user_data); + } + return; + } + + data = g_slice_new0 (GetContentTypesData); + data->callback = callback; + data->user_data = user_data; + + g_mount_guess_content_type (mount, + FALSE, + cancellable, + get_types_cb, + data); +} + +char ** +nautilus_get_cached_x_content_types_for_mount (GMount *mount) +{ + char **cached; + + if (mount == NULL) + { + return NULL; + } + + cached = g_object_get_data (G_OBJECT (mount), "nautilus-content-type-cache"); + if (cached != NULL) + { + return g_strdupv (cached); + } + + return NULL; +} + +char * +get_message_for_content_type (const char *content_type) +{ + char *message; + char *description; + + description = g_content_type_get_description (content_type); + + /* Customize greeting for well-known content types */ + if (strcmp (content_type, "x-content/audio-cdda") == 0) + { + /* translators: these describe the contents of removable media */ + message = g_strdup (_("Audio CD")); + } + else if (strcmp (content_type, "x-content/audio-dvd") == 0) + { + message = g_strdup (_("Audio DVD")); + } + else if (strcmp (content_type, "x-content/video-dvd") == 0) + { + message = g_strdup (_("Video DVD")); + } + else if (strcmp (content_type, "x-content/video-vcd") == 0) + { + message = g_strdup (_("Video CD")); + } + else if (strcmp (content_type, "x-content/video-svcd") == 0) + { + message = g_strdup (_("Super Video CD")); + } + else if (strcmp (content_type, "x-content/image-photocd") == 0) + { + message = g_strdup (_("Photo CD")); + } + else if (strcmp (content_type, "x-content/image-picturecd") == 0) + { + message = g_strdup (_("Picture CD")); + } + else if (strcmp (content_type, "x-content/image-dcf") == 0) + { + message = g_strdup (_("Contains digital photos")); + } + else if (strcmp (content_type, "x-content/audio-player") == 0) + { + message = g_strdup (_("Contains music")); + } + else if (strcmp (content_type, "x-content/unix-software") == 0) + { + message = g_strdup (_("Contains software to run")); + } + else if (strcmp (content_type, "x-content/ostree-repository") == 0) + { + message = g_strdup (_("Contains software to install")); + } + else + { + /* fallback to generic greeting */ + message = g_strdup_printf (_("Detected as “%s”"), description); + } + + g_free (description); + + return message; +} + +char * +get_message_for_two_content_types (const char * const *content_types) +{ + char *message; + + g_assert (content_types[0] != NULL); + g_assert (content_types[1] != NULL); + + /* few combinations make sense */ + if (strcmp (content_types[0], "x-content/image-dcf") == 0 + || strcmp (content_types[1], "x-content/image-dcf") == 0) + { + if (strcmp (content_types[0], "x-content/audio-player") == 0) + { + /* translators: these describe the contents of removable media */ + message = g_strdup (_("Contains music and photos")); + } + else if (strcmp (content_types[1], "x-content/audio-player") == 0) + { + message = g_strdup (_("Contains photos and music")); + } + else + { + message = g_strdup (_("Contains digital photos")); + } + } + else if ((strcmp (content_types[0], "x-content/video-vcd") == 0 + || strcmp (content_types[1], "x-content/video-vcd") == 0) + && (strcmp (content_types[0], "x-content/video-dvd") == 0 + || strcmp (content_types[1], "x-content/video-dvd") == 0)) + { + message = g_strdup_printf ("%s/%s", + get_message_for_content_type (content_types[0]), + get_message_for_content_type (content_types[1])); + } + else + { + message = get_message_for_content_type (content_types[0]); + } + + return message; +} + +gboolean +should_handle_content_type (const char *content_type) +{ + g_autoptr (GAppInfo) default_app = NULL; + + default_app = g_app_info_get_default_for_type (content_type, FALSE); + + return !g_str_has_prefix (content_type, "x-content/blank-") && + !g_content_type_is_a (content_type, "x-content/win32-software") && + default_app != NULL; +} + +gboolean +should_handle_content_types (const char * const *content_types) +{ + int i; + + for (i = 0; content_types[i] != NULL; i++) + { + if (should_handle_content_type (content_types[i])) + { + return TRUE; + } + } + + return FALSE; +} + +gboolean +nautilus_file_selection_equal (GList *selection_a, + GList *selection_b) +{ + GList *al, *bl; + gboolean selection_matches; + + if (selection_a == NULL || selection_b == NULL) + { + return (selection_a == selection_b); + } + + if (g_list_length (selection_a) != g_list_length (selection_b)) + { + return FALSE; + } + + selection_matches = TRUE; + + for (al = selection_a; al; al = al->next) + { + GFile *a_location = nautilus_file_get_location (NAUTILUS_FILE (al->data)); + gboolean found = FALSE; + + for (bl = selection_b; bl; bl = bl->next) + { + GFile *b_location = nautilus_file_get_location (NAUTILUS_FILE (bl->data)); + found = g_file_equal (b_location, a_location); + g_object_unref (b_location); + + if (found) + { + break; + } + } + + selection_matches = found; + g_object_unref (a_location); + + if (!selection_matches) + { + break; + } + } + + return selection_matches; +} + +static char * +trim_whitespace (const gchar *string) +{ + glong space_count; + glong length; + gchar *offset; + + space_count = 0; + length = g_utf8_strlen (string, -1); + offset = g_utf8_offset_to_pointer (string, length); + + while (space_count <= length) + { + gunichar character; + + offset = g_utf8_prev_char (offset); + character = g_utf8_get_char (offset); + + if (!g_unichar_isspace (character)) + { + break; + } + + space_count++; + } + + if (space_count == 0) + { + return g_strdup (string); + } + + return g_utf8_substring (string, 0, length - space_count); +} + +char * +nautilus_get_common_filename_prefix (GList *file_list, + int min_required_len) +{ + GList *file_names = NULL; + GList *directory_names = NULL; + char *result_files; + g_autofree char *result = NULL; + g_autofree char *result_trimmed = NULL; + + if (file_list == NULL) + { + return NULL; + } + + for (GList *l = file_list; l != NULL; l = l->next) + { + char *name; + + g_return_val_if_fail (NAUTILUS_IS_FILE (l->data), NULL); + + name = nautilus_file_get_display_name (l->data); + + /* Since the concept of file extensions does not apply to directories, + * we filter those out. + */ + if (nautilus_file_is_directory (l->data)) + { + directory_names = g_list_prepend (directory_names, name); + } + else + { + file_names = g_list_prepend (file_names, name); + } + } + + result_files = nautilus_get_common_filename_prefix_from_filenames (file_names, min_required_len); + + if (directory_names == NULL) + { + return result_files; + } + + if (result_files != NULL) + { + directory_names = g_list_prepend (directory_names, result_files); + } + + result = eel_str_get_common_prefix (directory_names, min_required_len); + + g_list_free_full (file_names, g_free); + g_list_free_full (directory_names, g_free); + + if (result == NULL) + { + return NULL; + } + + result_trimmed = trim_whitespace (result); + + if (g_utf8_strlen (result_trimmed, -1) < min_required_len) + { + return NULL; + } + + return g_steal_pointer (&result_trimmed); +} + +char * +nautilus_get_common_filename_prefix_from_filenames (GList *filenames, + int min_required_len) +{ + GList *stripped_filenames = NULL; + char *common_prefix; + char *truncated; + int common_prefix_len; + + for (GList *i = filenames; i != NULL; i = i->next) + { + gchar *stripped_filename; + + stripped_filename = eel_filename_strip_extension (i->data); + + stripped_filenames = g_list_prepend (stripped_filenames, stripped_filename); + } + + common_prefix = eel_str_get_common_prefix (stripped_filenames, min_required_len); + if (common_prefix == NULL) + { + return NULL; + } + + g_list_free_full (stripped_filenames, g_free); + + truncated = trim_whitespace (common_prefix); + g_free (common_prefix); + + common_prefix_len = g_utf8_strlen (truncated, -1); + if (common_prefix_len < min_required_len) + { + g_free (truncated); + return NULL; + } + + return truncated; +} + +glong +nautilus_get_max_child_name_length_for_location (GFile *location) +{ + g_autofree gchar *path = NULL; + glong name_max; + glong path_max; + glong max_child_name_length; + + g_return_val_if_fail (G_IS_FILE (location), -1); + + if (!g_file_has_uri_scheme (location, "file")) + { + /* FIXME: Can we query length limits for non-"file://" locations? */ + return -1; + } + + path = g_file_get_path (location); + + g_return_val_if_fail (path != NULL, -1); + + name_max = pathconf (path, _PC_NAME_MAX); + path_max = pathconf (path, _PC_PATH_MAX); + max_child_name_length = -1; + + if (name_max == -1) + { + if (path_max != -1) + { + /* We don't know the name max, but we know the name can't make the + * path longer than this. + * Subtracting 1 because PATH_MAX includes the terminating null + * character, as per limits.h(0P). */ + max_child_name_length = MAX ((path_max - 1) - strlen (path), 0); + } + } + else + { + /* No need to subtract 1, because NAME_MAX excludes the terminating null + * character, as per limits.h(0P) */ + max_child_name_length = name_max; + if (path_max != -1) + { + max_child_name_length = CLAMP ((path_max - 1) - strlen (path), + 0, + max_child_name_length); + } + } + + return max_child_name_length; +} + +#if !defined (NAUTILUS_OMIT_SELF_CHECK) + +void +nautilus_self_check_file_utilities (void) +{ +} + +void +nautilus_ensure_extension_builtins (void) +{ + /* Please add new extension types here, even if you can guarantee + * that they will be registered by the time the extension point + * is iterating over its extensions. + */ + g_type_ensure (NAUTILUS_TYPE_SEARCH_DIRECTORY); + g_type_ensure (NAUTILUS_TYPE_STARRED_DIRECTORY); +} + +void +nautilus_ensure_extension_points (void) +{ + static gsize once_init_value = 0; + + if (g_once_init_enter (&once_init_value)) + { + GIOExtensionPoint *extension_point; + + extension_point = g_io_extension_point_register (NAUTILUS_DIRECTORY_PROVIDER_EXTENSION_POINT_NAME); + g_io_extension_point_set_required_type (extension_point, NAUTILUS_TYPE_DIRECTORY); + + g_once_init_leave (&once_init_value, 1); + } +} + +#endif /* !NAUTILUS_OMIT_SELF_CHECK */ + +gboolean +nautilus_file_can_rename_files (GList *files) +{ + GList *l; + NautilusFile *file; + + for (l = files; l != NULL; l = l->next) + { + file = NAUTILUS_FILE (l->data); + + if (!nautilus_file_can_rename (file)) + { + return FALSE; + } + } + + return TRUE; +} + +/* Try to get a native file:// URI instead of any other GVFS + * scheme, for interoperability with apps only handling file:// URIs. + */ +gchar * +nautilus_uri_to_native_uri (const gchar *uri) +{ + g_autoptr (GFile) file = NULL; + g_autofree gchar *path = NULL; + + file = g_file_new_for_uri (uri); + path = g_file_get_path (file); + + if (path != NULL) + { + return g_filename_to_uri (path, NULL, NULL); + } + + return NULL; +} + +NautilusQueryRecursive +location_settings_search_get_recursive (void) +{ + switch (g_settings_get_enum (nautilus_preferences, "recursive-search")) + { + case NAUTILUS_SPEED_TRADEOFF_ALWAYS: + { + return NAUTILUS_QUERY_RECURSIVE_ALWAYS; + } + break; + + case NAUTILUS_SPEED_TRADEOFF_LOCAL_ONLY: + { + return NAUTILUS_QUERY_RECURSIVE_LOCAL_ONLY; + } + break; + + case NAUTILUS_SPEED_TRADEOFF_NEVER: + { + return NAUTILUS_QUERY_RECURSIVE_NEVER; + } + break; + } + + return NAUTILUS_QUERY_RECURSIVE_ALWAYS; +} + +NautilusQueryRecursive +location_settings_search_get_recursive_for_location (GFile *location) +{ + NautilusQueryRecursive recursive = location_settings_search_get_recursive (); + + g_return_val_if_fail (location, recursive); + + if (recursive == NAUTILUS_QUERY_RECURSIVE_LOCAL_ONLY) + { + g_autoptr (NautilusFile) file = nautilus_file_get_existing (location); + + g_return_val_if_fail (file != NULL, recursive); + + if (nautilus_file_is_remote (file)) + { + recursive = NAUTILUS_QUERY_RECURSIVE_NEVER; + } + } + + return recursive; +} + +/* check_schema_available() was copied from GNOME Settings */ +gboolean +check_schema_available (const gchar *schema_id) +{ + GSettingsSchemaSource *source; + g_autoptr (GSettingsSchema) schema = NULL; + + if (nautilus_application_is_sandboxed ()) + { + return TRUE; + } + + source = g_settings_schema_source_get_default (); + if (!source) + { + return FALSE; + } + + schema = g_settings_schema_source_lookup (source, schema_id, TRUE); + if (!schema) + { + return FALSE; + } + + return TRUE; +} |