moving from https://github.com/perberos/mate-desktop-environment

author: Perberos <[email protected]> 2011-12-01 22:24:23 -0300
committer: Perberos <[email protected]> 2011-12-01 22:24:23 -0300
commit: 0e004c696b0e68b2cff37a4c3315b022a35eaf43 (patch)
tree: 43261e815529cb9518ed7be37af13b846af8b26b /libcaja-private/caja-file-utilities.c
download: caja-0e004c696b0e68b2cff37a4c3315b022a35eaf43.tar.bz2
caja-0e004c696b0e68b2cff37a4c3315b022a35eaf43.tar.xz
1 files changed, 1449 insertions, 0 deletions
diff --git a/libcaja-private/caja-file-utilities.c b/libcaja-private/caja-file-utilities.c
new file mode 100644
index 00000000..6c9a7de1
--- /dev/null
+++ b/libcaja-private/caja-file-utilities.c
@@ -0,0 +1,1449 @@
+/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
+
+/* caja-file-utilities.c - implementation of file manipulation routines.
+
+ Copyright (C) 1999, 2000, 2001 Eazel, Inc.
+
+ The Mate 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 Mate 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 Mate Library; see the file COPYING.LIB. If not,
+ write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA.
+
+ Authors: John Sullivan <[email protected]>
+*/
+
+#include <config.h>
+#include "caja-file-utilities.h"
+
+#include "caja-global-preferences.h"
+#include "caja-lib-self-check-functions.h"
+#include "caja-metadata.h"
+#include "caja-file.h"
+#include "caja-file-operations.h"
+#include "caja-search-directory.h"
+#include "caja-signaller.h"
+#include <eel/eel-glib-extensions.h>
+#include <eel/eel-stock-dialogs.h>
+#include <eel/eel-string.h>
+#include <eel/eel-debug.h>
+#include <glib.h>
+#include <glib/gi18n.h>
+#include <glib/gstdio.h>
+#include <gio/gio.h>
+#include <unistd.h>
+#include <stdlib.h>
+
+#define CAJA_USER_DIRECTORY_NAME ".config/caja"
+#define DEFAULT_CAJA_DIRECTORY_MODE (0755)
+
+#define DESKTOP_DIRECTORY_NAME "Desktop"
+#define LEGACY_DESKTOP_DIRECTORY_NAME ".mate-desktop"
+#define DEFAULT_DESKTOP_DIRECTORY_MODE (0755)
+
+static void update_xdg_dir_cache (void);
+static void schedule_user_dirs_changed (void);
+static void desktop_dir_changed (void);
+static GFile *caja_find_file_insensitive_next (GFile *parent, const gchar *name);
+
+char *
+caja_compute_title_for_location (GFile *location)
+{
+ CajaFile *file;
+ char *title;
+
+ /* TODO-gio: This doesn't really work all that great if the
+ info about the file isn't known atm... */
+
+ title = NULL;
+ if (location)
+ {
+ file = caja_file_get (location);
+ title = caja_file_get_description (file);
+ if (title == NULL)
+ {
+ title = caja_file_get_display_name (file);
+ }
+ caja_file_unref (file);
+ }
+
+ if (title == NULL)
+ {
+ title = g_strdup ("");
+ }
+
+ return title;
+}
+
+
+/**
+ * caja_get_user_directory:
+ *
+ * Get the path for the directory containing caja settings.
+ *
+ * Return value: the directory path.
+ **/
+char* caja_get_user_directory(void)
+{
+ /* FIXME bugzilla.gnome.org 41286:
+ * How should we handle the case where this mkdir fails?
+ * Note that caja_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 Caja was launched, and perhaps
+ * there is some bad side-effect of not handling that case.
+ * <<<
+ * Si alguien tiene tiempo, puede enviar este codigo a Nautilus.
+ * Obviamente, con los comentarios traducidos al Inglés.
+ */
+ char* user_directory = g_build_filename(g_get_home_dir(), ".config", "caja", NULL);
+ /* Se necesita que esta dirección sea una carpeta, con los permisos
+ * DEFAULT_CAJA_DIRECTORY_MODE. Pero si es un archivo, el programa intentará
+ * eliminar el archivo silenciosamente. */
+ if (g_file_test(user_directory, G_FILE_TEST_IS_DIR) == FALSE ||
+ g_access(user_directory, DEFAULT_CAJA_DIRECTORY_MODE) == -1)
+ {
+ /* Se puede obtener un enlace simbolico a una carpeta */
+ if (g_file_test(user_directory, G_FILE_TEST_IS_SYMLINK) == TRUE)
+ {
+ /* intentaremos saber si el enlace es una carpeta, y tiene los
+ * permisos adecuados */
+ char* link = g_file_read_link(user_directory, NULL);
+
+ if (link)
+ {
+ /* Si el enlace no es un directorio, o si falla al hacer chmod,
+ * se borra el enlace y se crea la carpeta */
+ if (g_file_test(link, G_FILE_TEST_IS_DIR) != TRUE ||
+ g_chmod(link, DEFAULT_CAJA_DIRECTORY_MODE) != 0)
+ {
+ /* podemos borrar el enlace y crear la carpeta */
+ g_unlink(user_directory);
+ g_mkdir(user_directory, DEFAULT_CAJA_DIRECTORY_MODE);
+ }
+
+ g_free(link);
+ }
+ }
+ else if (g_file_test(user_directory, G_FILE_TEST_IS_DIR) == TRUE)
+ {
+ g_chmod(user_directory, DEFAULT_CAJA_DIRECTORY_MODE);
+ }
+ else if (g_file_test(user_directory, G_FILE_TEST_EXISTS) == TRUE)
+ {
+ /* podemos borrar el enlace y crear la carpeta */
+ g_unlink(user_directory);
+ g_mkdir(user_directory, DEFAULT_CAJA_DIRECTORY_MODE);
+ }
+ else
+ {
+ /* Si no existe ningun archivo, se crea la carpeta */
+ g_mkdir_with_parents(user_directory, DEFAULT_CAJA_DIRECTORY_MODE);
+ }
+
+ /* Faltan permisos */
+ if (g_chmod(user_directory, DEFAULT_CAJA_DIRECTORY_MODE) != 0)
+ {
+ GtkWidget* dialog = gtk_message_dialog_new(
+ NULL,
+ GTK_DIALOG_DESTROY_WITH_PARENT,
+ GTK_MESSAGE_ERROR,
+ GTK_BUTTONS_CLOSE,
+ "The path for the directory containing caja settings need read and write permissions: %s",
+ user_directory);
+
+ gtk_dialog_run(GTK_DIALOG(dialog));
+ gtk_widget_destroy(dialog);
+
+ exit(0);
+ }
+ }
+
+ return user_directory;
+}
+
+/**
+ * caja_get_accel_map_file:
+ *
+ * Get the path for the filename containing caja accelerator map.
+ * The filename need not exist.
+ *
+ * Return value: the filename path, or NULL if the home directory could not be found
+ **/
+char* caja_get_accel_map_file(void)
+{
+ const gchar* override;
+
+ override = g_getenv ("MATE22_USER_DIR");
+
+ if (override)
+ {
+ return g_build_filename(override, "accels", "caja", NULL);
+ }
+ else
+ {
+ return g_build_filename(g_get_home_dir(), ".config", "accels", "caja", NULL);
+ }
+}
+
+typedef struct {
+ char*type;
+ char*path;
+ CajaFile* file;
+} XdgDirEntry;
+
+
+static XdgDirEntry *
+parse_xdg_dirs (const char *config_file)
+{
+ GArray *array;
+ char *config_file_free = NULL;
+ XdgDirEntry dir;
+ char *data;
+ char **lines;
+ char *p, *d;
+ int i;
+ char *type_start, *type_end;
+ char *value, *unescaped;
+ gboolean relative;
+
+ array = g_array_new (TRUE, TRUE, sizeof (XdgDirEntry));
+
+ if (config_file == NULL)
+ {
+ config_file_free = g_build_filename (g_get_user_config_dir (),
+ "user-dirs.dirs", NULL);
+ config_file = (const char *)config_file_free;
+ }
+
+ if (g_file_get_contents (config_file, &data, NULL, NULL))
+ {
+ lines = g_strsplit (data, "\n", 0);
+ g_free (data);
+ for (i = 0; lines[i] != NULL; i++)
+ {
+ p = lines[i];
+ while (g_ascii_isspace (*p))
+ p++;
+
+ if (*p == '#')
+ continue;
+
+ value = strchr (p, '=');
+ if (value == NULL)
+ continue;
+ *value++ = 0;
+
+ g_strchug (g_strchomp (p));
+ if (!g_str_has_prefix (p, "XDG_"))
+ continue;
+ if (!g_str_has_suffix (p, "_DIR"))
+ continue;
+ type_start = p + 4;
+ type_end = p + strlen (p) - 4;
+
+ while (g_ascii_isspace (*value))
+ value++;
+
+ if (*value != '"')
+ continue;
+ value++;
+
+ relative = FALSE;
+ if (g_str_has_prefix (value, "$HOME"))
+ {
+ relative = TRUE;
+ value += 5;
+ while (*value == '/')
+ value++;
+ }
+ else if (*value != '/')
+ continue;
+
+ d = unescaped = g_malloc (strlen (value) + 1);
+ while (*value && *value != '"')
+ {
+ if ((*value == '\\') && (*(value + 1) != 0))
+ value++;
+ *d++ = *value++;
+ }
+ *d = 0;
+
+ *type_end = 0;
+ dir.type = g_strdup (type_start);
+ if (relative)
+ {
+ dir.path = g_build_filename (g_get_home_dir (), unescaped, NULL);
+ g_free (unescaped);
+ }
+ else
+ dir.path = unescaped;
+
+ g_array_append_val (array, dir);
+ }
+
+ g_strfreev (lines);
+ }
+
+ g_free (config_file_free);
+
+ return (XdgDirEntry *)g_array_free (array, FALSE);
+}
+
+static XdgDirEntry *cached_xdg_dirs = NULL;
+static GFileMonitor *cached_xdg_dirs_monitor = NULL;
+
+static void
+xdg_dir_changed (CajaFile *file,
+ XdgDirEntry *dir)
+{
+ GFile *location, *dir_location;
+ char *path;
+
+ location = caja_file_get_location (file);
+ dir_location = g_file_new_for_path (dir->path);
+ if (!g_file_equal (location, dir_location))
+ {
+ path = g_file_get_path (location);
+
+ if (path)
+ {
+ char *argv[5];
+ int i;
+
+ g_free (dir->path);
+ dir->path = path;
+
+ i = 0;
+ argv[i++] = "xdg-user-dirs-update";
+ argv[i++] = "--set";
+ argv[i++] = dir->type;
+ argv[i++] = dir->path;
+ argv[i++] = NULL;
+
+ /* We do this sync, to avoid possible race-conditions
+ if multiple dirs change at the same time. Its
+ blocking the main thread, but these updates should
+ be very rare and very fast. */
+ g_spawn_sync (NULL,
+ argv, NULL,
+ G_SPAWN_SEARCH_PATH |
+ G_SPAWN_STDOUT_TO_DEV_NULL |
+ G_SPAWN_STDERR_TO_DEV_NULL,
+ NULL, NULL,
+ NULL, NULL, NULL, NULL);
+ g_reload_user_special_dirs_cache ();
+ schedule_user_dirs_changed ();
+ desktop_dir_changed ();
+ /* Icon might have changed */
+ caja_file_invalidate_attributes (file, CAJA_FILE_ATTRIBUTE_INFO);
+ }
+ }
+ g_object_unref (location);
+ g_object_unref (dir_location);
+}
+
+static void
+xdg_dir_cache_changed_cb (GFileMonitor *monitor,
+ GFile *file,
+ GFile *other_file,
+ GFileMonitorEvent event_type)
+{
+ if (event_type == G_FILE_MONITOR_EVENT_CHANGED ||
+ event_type == G_FILE_MONITOR_EVENT_CREATED)
+ {
+ update_xdg_dir_cache ();
+ }
+}
+
+static int user_dirs_changed_tag = 0;
+
+static gboolean
+emit_user_dirs_changed_idle (gpointer data)
+{
+ g_signal_emit_by_name (caja_signaller_get_current (),
+ "user_dirs_changed");
+ user_dirs_changed_tag = 0;
+ return FALSE;
+}
+
+static void
+schedule_user_dirs_changed (void)
+{
+ if (user_dirs_changed_tag == 0)
+ {
+ user_dirs_changed_tag = g_idle_add (emit_user_dirs_changed_idle, NULL);
+ }
+}
+
+static void
+unschedule_user_dirs_changed (void)
+{
+ if (user_dirs_changed_tag != 0)
+ {
+ g_source_remove (user_dirs_changed_tag);
+ user_dirs_changed_tag = 0;
+ }
+}
+
+static void
+free_xdg_dir_cache (void)
+{
+ int i;
+
+ if (cached_xdg_dirs != NULL)
+ {
+ for (i = 0; cached_xdg_dirs[i].type != NULL; i++)
+ {
+ if (cached_xdg_dirs[i].file != NULL)
+ {
+ caja_file_monitor_remove (cached_xdg_dirs[i].file,
+ &cached_xdg_dirs[i]);
+ g_signal_handlers_disconnect_by_func (cached_xdg_dirs[i].file,
+ G_CALLBACK (xdg_dir_changed),
+ &cached_xdg_dirs[i]);
+ caja_file_unref (cached_xdg_dirs[i].file);
+ }
+ g_free (cached_xdg_dirs[i].type);
+ g_free (cached_xdg_dirs[i].path);
+ }
+ g_free (cached_xdg_dirs);
+ }
+}
+
+static void
+destroy_xdg_dir_cache (void)
+{
+ free_xdg_dir_cache ();
+ unschedule_user_dirs_changed ();
+ desktop_dir_changed ();
+
+ if (cached_xdg_dirs_monitor != NULL)
+ {
+ g_object_unref (cached_xdg_dirs_monitor);
+ cached_xdg_dirs_monitor = NULL;
+ }
+}
+
+static void
+update_xdg_dir_cache (void)
+{
+ GFile *file;
+ char *config_file, *uri;
+ int i;
+
+ free_xdg_dir_cache ();
+ g_reload_user_special_dirs_cache ();
+ schedule_user_dirs_changed ();
+ desktop_dir_changed ();
+
+ cached_xdg_dirs = parse_xdg_dirs (NULL);
+
+ for (i = 0 ; cached_xdg_dirs[i].type != NULL; i++)
+ {
+ cached_xdg_dirs[i].file = NULL;
+ if (strcmp (cached_xdg_dirs[i].path, g_get_home_dir ()) != 0)
+ {
+ uri = g_filename_to_uri (cached_xdg_dirs[i].path, NULL, NULL);
+ cached_xdg_dirs[i].file = caja_file_get_by_uri (uri);
+ caja_file_monitor_add (cached_xdg_dirs[i].file,
+ &cached_xdg_dirs[i],
+ CAJA_FILE_ATTRIBUTE_INFO);
+ g_signal_connect (cached_xdg_dirs[i].file,
+ "changed", G_CALLBACK (xdg_dir_changed), &cached_xdg_dirs[i]);
+ g_free (uri);
+ }
+ }
+
+ if (cached_xdg_dirs_monitor == NULL)
+ {
+ config_file = g_build_filename (g_get_user_config_dir (),
+ "user-dirs.dirs", NULL);
+ file = g_file_new_for_path (config_file);
+ cached_xdg_dirs_monitor = g_file_monitor_file (file, 0, NULL, NULL);
+ g_signal_connect (cached_xdg_dirs_monitor, "changed",
+ G_CALLBACK (xdg_dir_cache_changed_cb), NULL);
+ g_object_unref (file);
+ g_free (config_file);
+
+ eel_debug_call_at_shutdown (destroy_xdg_dir_cache);
+ }
+}
+
+char *
+caja_get_xdg_dir (const char *type)
+{
+ int i;
+
+ if (cached_xdg_dirs == NULL)
+ {
+ update_xdg_dir_cache ();
+ }
+
+ for (i = 0 ; cached_xdg_dirs != NULL && cached_xdg_dirs[i].type != NULL; i++)
+ {
+ if (strcmp (cached_xdg_dirs[i].type, type) == 0)
+ {
+ return g_strdup (cached_xdg_dirs[i].path);
+ }
+ }
+ if (strcmp ("DESKTOP", type) == 0)
+ {
+ return g_build_filename (g_get_home_dir (), DESKTOP_DIRECTORY_NAME, NULL);
+ }
+ if (strcmp ("TEMPLATES", type) == 0)
+ {
+ return g_build_filename (g_get_home_dir (), "Templates", NULL);
+ }
+
+ return g_strdup (g_get_home_dir ());
+}
+
+static char *
+get_desktop_path (void)
+{
+ if (eel_preferences_get_boolean (CAJA_PREFERENCES_DESKTOP_IS_HOME_DIR))
+ {
+ return g_strdup (g_get_home_dir());
+ }
+ else
+ {
+ return caja_get_xdg_dir ("DESKTOP");
+ }
+}
+
+/**
+ * caja_get_desktop_directory:
+ *
+ * Get the path for the directory containing files on the desktop.
+ *
+ * Return value: the directory path.
+ **/
+char *
+caja_get_desktop_directory (void)
+{
+ char *desktop_directory;
+
+ desktop_directory = get_desktop_path ();
+
+ /* Don't try to create a home directory */
+ if (!eel_preferences_get_boolean (CAJA_PREFERENCES_DESKTOP_IS_HOME_DIR))
+ {
+ if (!g_file_test (desktop_directory, G_FILE_TEST_EXISTS))
+ {
+ g_mkdir (desktop_directory, DEFAULT_DESKTOP_DIRECTORY_MODE);
+ /* FIXME bugzilla.gnome.org 41286:
+ * How should we handle the case where this mkdir fails?
+ * Note that caja_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 Caja was launched, and perhaps
+ * there is some bad side-effect of not handling that case.
+ */
+ }
+ }
+
+ return desktop_directory;
+}
+
+GFile *
+caja_get_desktop_location (void)
+{
+ char *desktop_directory;
+ GFile *res;
+
+ desktop_directory = get_desktop_path ();
+
+ res = g_file_new_for_path (desktop_directory);
+ g_free (desktop_directory);
+ return res;
+}
+
+
+/**
+ * caja_get_desktop_directory_uri:
+ *
+ * Get the uri for the directory containing files on the desktop.
+ *
+ * Return value: the directory path.
+ **/
+char *
+caja_get_desktop_directory_uri (void)
+{
+ char *desktop_path;
+ char *desktop_uri;
+
+ desktop_path = caja_get_desktop_directory ();
+ desktop_uri = g_filename_to_uri (desktop_path, NULL, NULL);
+ g_free (desktop_path);
+
+ return desktop_uri;
+}
+
+char *
+caja_get_desktop_directory_uri_no_create (void)
+{
+ char *desktop_path;
+ char *desktop_uri;
+
+ desktop_path = get_desktop_path ();
+ desktop_uri = g_filename_to_uri (desktop_path, NULL, NULL);
+ g_free (desktop_path);
+
+ return desktop_uri;
+}
+
+char *
+caja_get_home_directory_uri (void)
+{
+ return g_filename_to_uri (g_get_home_dir (), NULL, NULL);
+}
+
+
+gboolean
+caja_should_use_templates_directory (void)
+{
+ char *dir;
+ gboolean res;
+
+ dir = caja_get_xdg_dir ("TEMPLATES");
+ res = strcmp (dir, g_get_home_dir ()) != 0;
+ g_free (dir);
+ return res;
+}
+
+char *
+caja_get_templates_directory (void)
+{
+ return caja_get_xdg_dir ("TEMPLATES");
+}
+
+void
+caja_create_templates_directory (void)
+{
+ char *dir;
+
+ dir = caja_get_templates_directory ();
+ if (!g_file_test (dir, G_FILE_TEST_EXISTS))
+ {
+ g_mkdir (dir, DEFAULT_CAJA_DIRECTORY_MODE);
+ }
+ g_free (dir);
+}
+
+char *
+caja_get_templates_directory_uri (void)
+{
+ char *directory, *uri;
+
+ directory = caja_get_templates_directory ();
+ uri = g_filename_to_uri (directory, NULL, NULL);
+ g_free (directory);
+ return uri;
+}
+
+char *
+caja_get_searches_directory (void)
+{
+ char *user_dir;
+ char *searches_dir;
+
+ user_dir = caja_get_user_directory ();
+ searches_dir = g_build_filename (user_dir, "searches", NULL);
+ g_free (user_dir);
+
+ if (!g_file_test (searches_dir, G_FILE_TEST_EXISTS))
+ g_mkdir (searches_dir, DEFAULT_CAJA_DIRECTORY_MODE);
+
+ return searches_dir;
+}
+
+/* These need to be reset to NULL when desktop_is_home_dir changes */
+static GFile *desktop_dir = NULL;
+static GFile *desktop_dir_dir = NULL;
+static char *desktop_dir_filename = NULL;
+static gboolean desktop_dir_changed_callback_installed = FALSE;
+
+
+static void
+desktop_dir_changed (void)
+{
+ if (desktop_dir)
+ {
+ g_object_unref (desktop_dir);
+ }
+ if (desktop_dir_dir)
+ {
+ g_object_unref (desktop_dir_dir);
+ }
+ g_free (desktop_dir_filename);
+ desktop_dir = NULL;
+ desktop_dir_dir = NULL;
+ desktop_dir_filename = NULL;
+}
+
+static void
+desktop_dir_changed_callback (gpointer callback_data)
+{
+ desktop_dir_changed ();
+}
+
+static void
+update_desktop_dir (void)
+{
+ char *path;
+ char *dirname;
+
+ path = get_desktop_path ();
+ desktop_dir = g_file_new_for_path (path);
+
+ dirname = g_path_get_dirname (path);
+ desktop_dir_dir = g_file_new_for_path (dirname);
+ g_free (dirname);
+ desktop_dir_filename = g_path_get_basename (path);
+ g_free (path);
+}
+
+gboolean
+caja_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
+caja_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
+caja_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
+caja_is_desktop_directory_file (GFile *dir,
+ const char *file)
+{
+
+ if (!desktop_dir_changed_callback_installed)
+ {
+ eel_preferences_add_callback (CAJA_PREFERENCES_DESKTOP_IS_HOME_DIR,
+ desktop_dir_changed_callback,
+ NULL);
+ desktop_dir_changed_callback_installed = TRUE;
+ }
+
+ if (desktop_dir == NULL)
+ {
+ update_desktop_dir ();
+ }
+
+ return (g_file_equal (dir, desktop_dir_dir) &&
+ strcmp (file, desktop_dir_filename) == 0);
+}
+
+gboolean
+caja_is_desktop_directory (GFile *dir)
+{
+
+ if (!desktop_dir_changed_callback_installed)
+ {
+ eel_preferences_add_callback (CAJA_PREFERENCES_DESKTOP_IS_HOME_DIR,
+ desktop_dir_changed_callback,
+ NULL);
+ desktop_dir_changed_callback_installed = TRUE;
+ }
+
+ if (desktop_dir == NULL)
+ {
+ update_desktop_dir ();
+ }
+
+ return g_file_equal (dir, desktop_dir);
+}
+
+
+/**
+ * caja_get_gmc_desktop_directory:
+ *
+ * Get the path for the directory containing the legacy gmc desktop.
+ *
+ * Return value: the directory path.
+ **/
+char *
+caja_get_gmc_desktop_directory (void)
+{
+ return g_build_filename (g_get_home_dir (), LEGACY_DESKTOP_DIRECTORY_NAME, NULL);
+}
+
+/**
+ * caja_get_pixmap_directory
+ *
+ * Get the path for the directory containing Caja pixmaps.
+ *
+ * Return value: the directory path.
+ **/
+char *
+caja_get_pixmap_directory (void)
+{
+ return g_strdup (DATADIR "/pixmaps/caja");
+}
+
+/* FIXME bugzilla.gnome.org 42423:
+ * Callers just use this and dereference so we core dump if
+ * pixmaps are missing. That is lame.
+ */
+char *
+caja_pixmap_file (const char *partial_path)
+{
+ char *path;
+
+ path = g_build_filename (DATADIR "/pixmaps/caja", partial_path, NULL);
+ if (g_file_test (path, G_FILE_TEST_EXISTS))
+ {
+ return path;
+ }
+ else
+ {
+ char *tmp;
+ tmp = caja_get_pixmap_directory ();
+ g_debug ("Failed to locate \"%s\" in Caja pixmap path \"%s\". Incomplete installation?", partial_path, tmp);
+ g_free (tmp);
+ }
+ g_free (path);
+ return NULL;
+}
+
+char *
+caja_get_data_file_path (const char *partial_path)
+{
+ char *path;
+ char *user_directory;
+
+ /* first try the user's home directory */
+ user_directory = caja_get_user_directory ();
+ path = g_build_filename (user_directory, partial_path, NULL);
+ g_free (user_directory);
+ if (g_file_test (path, G_FILE_TEST_EXISTS))
+ {
+ return path;
+ }
+ g_free (path);
+
+ /* next try the shared directory */
+ path = g_build_filename (CAJA_DATADIR, partial_path, NULL);
+ if (g_file_test (path, G_FILE_TEST_EXISTS))
+ {
+ return path;
+ }
+ g_free (path);
+
+ return NULL;
+}
+
+char *
+caja_ensure_unique_file_name (const char *directory_uri,
+ const char *base_name,
+ const char *extension)
+{
+ GFileInfo *info;
+ char *filename;
+ GFile *dir, *child;
+ int copy;
+ char *res;
+
+ dir = g_file_new_for_uri (directory_uri);
+
+ info = g_file_query_info (dir, G_FILE_ATTRIBUTE_STANDARD_TYPE, 0, NULL, NULL);
+ if (info == NULL)
+ {
+ g_object_unref (dir);
+ return NULL;
+ }
+ g_object_unref (info);
+
+ filename = g_strdup_printf ("%s%s",
+ base_name,
+ extension);
+ child = g_file_get_child (dir, filename);
+ g_free (filename);
+
+ copy = 1;
+ while ((info = g_file_query_info (child, G_FILE_ATTRIBUTE_STANDARD_TYPE, 0, NULL, NULL)) != NULL)
+ {
+ g_object_unref (info);
+ g_object_unref (child);
+
+ filename = g_strdup_printf ("%s-%d%s",
+ base_name,
+ copy,
+ extension);
+ child = g_file_get_child (dir, filename);
+ g_free (filename);
+
+ copy++;
+ }
+
+ res = g_file_get_uri (child);
+ g_object_unref (child);
+ g_object_unref (dir);
+
+ return res;
+}
+
+char *
+caja_unique_temporary_file_name (void)
+{
+ const char *prefix = "/tmp/caja-temp-file";
+ char *file_name;
+ int fd;
+
+ file_name = g_strdup_printf ("%sXXXXXX", prefix);
+
+ fd = g_mkstemp (file_name);
+ if (fd == -1)
+ {
+ g_free (file_name);
+ file_name = NULL;
+ }
+ else
+ {
+ close (fd);
+ }
+
+ return file_name;
+}
+
+GFile *
+caja_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;
+}
+
+/**
+ * caja_find_file_insensitive
+ *
+ * Attempt to find a file case-insentively. If the path can be found, the
+ * returned file maps directly to it. Otherwise, a file using the
+ * originally-cased path is returned. This function performs might perform
+ * I/O.
+ *
+ * Return value: a #GFile to a child specified by @name.
+ **/
+GFile *
+caja_find_file_insensitive (GFile *parent, const gchar *name)
+{
+ gchar **split_path;
+ gchar *component;
+ GFile *file, *next;
+ gint i;
+
+ split_path = g_strsplit (name, G_DIR_SEPARATOR_S, -1);
+
+ file = g_object_ref (parent);
+
+ for (i = 0; (component = split_path[i]) != NULL; i++)
+ {
+ if (!(next = caja_find_file_insensitive_next (file,
+ component)))
+ {
+ /* File does not exist */
+ g_object_unref (file);
+ file = NULL;
+ break;
+ }
+ g_object_unref (file);
+ file = next;
+ }
+ g_strfreev (split_path);
+
+ if (file)
+ {
+ return file;
+ }
+ return g_file_get_child (parent, name);
+}
+
+static GFile *
+caja_find_file_insensitive_next (GFile *parent, const gchar *name)
+{
+ GFileEnumerator *children;
+ GFileInfo *info;
+ gboolean use_utf8, found;
+ char *filename, *case_folded_name, *utf8_collation_key, *ascii_collation_key, *child_key;
+ GFile *file;
+ const char *child_name, *compare_key;
+
+ /* First check the given version */
+ file = g_file_get_child (parent, name);
+ if (g_file_query_exists (file, NULL))
+ {
+ return file;
+ }
+ g_object_unref (file);
+
+ ascii_collation_key = g_ascii_strdown (name, -1);
+ use_utf8 = g_utf8_validate (name, -1, NULL);
+ utf8_collation_key = NULL;
+ if (use_utf8)
+ {
+ case_folded_name = g_utf8_casefold (name, -1);
+ utf8_collation_key = g_utf8_collate_key (case_folded_name, -1);
+ g_free (case_folded_name);
+ }
+
+ /* Enumerate and compare insensitive */
+ filename = NULL;
+ children = g_file_enumerate_children (parent,
+ G_FILE_ATTRIBUTE_STANDARD_NAME,
+ 0, NULL, NULL);
+ if (children != NULL)
+ {
+ while ((info = g_file_enumerator_next_file (children, NULL, NULL)))
+ {
+ child_name = g_file_info_get_name (info);
+
+ if (use_utf8 && g_utf8_validate (child_name, -1, NULL))
+ {
+ gchar *case_folded;
+
+ case_folded = g_utf8_casefold (child_name, -1);
+ child_key = g_utf8_collate_key (case_folded, -1);
+ g_free (case_folded);
+ compare_key = utf8_collation_key;
+ }
+ else
+ {
+ child_key = g_ascii_strdown (child_name, -1);
+ compare_key = ascii_collation_key;
+ }
+
+ found = strcmp (child_key, compare_key) == 0;
+ g_free (child_key);
+ if (found)
+ {
+ filename = g_strdup (child_name);
+ break;
+ }
+ }
+ g_file_enumerator_close (children, NULL, NULL);
+ g_object_unref (children);
+ }
+
+ g_free (ascii_collation_key);
+ g_free (utf8_collation_key);
+
+ if (filename)
+ {
+ file = g_file_get_child (parent, filename);
+ g_free (filename);
+ return file;
+ }
+
+ return NULL;
+}
+
+gboolean
+caja_is_file_roller_installed (void)
+{
+ static int installed = - 1;
+
+ if (installed < 0)
+ {
+ if (g_find_program_in_path ("file-roller"))
+ {
+ installed = 1;
+ }
+ else
+ {
+ installed = 0;
+ }
+ }
+
+ return installed > 0 ? TRUE : FALSE;
+}
+
+#define GSM_NAME "org.mate.SessionManager"
+#define GSM_PATH "/org/mate/SessionManager"
+#define GSM_INTERFACE "org.mate.SessionManager"
+
+/* The following values come from
+ * http://www.gnome.org/~mccann/mate-session/docs/mate-session.html#org.mate.SessionManager.Inhibit
+ */
+#define INHIBIT_LOGOUT (1U)
+#define INHIBIT_SUSPEND (4U)
+
+static GDBusConnection *
+get_dbus_connection (void)
+{
+ static GDBusConnection *conn = NULL;
+
+ if (conn == NULL)
+ {
+ GError *error = NULL;
+
+ conn = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
+
+ if (conn == NULL)
+ {
+ g_warning ("Could not connect to session bus: %s", error->message);
+ g_error_free (error);
+ }
+ }
+
+ return conn;
+}
+
+/**
+ * caja_inhibit_power_manager:
+ * @message: a human readable message for the reason why power management
+ * is being suspended.
+ *
+ * Inhibits the power manager from logging out or suspending the machine
+ * (e.g. whenever Caja is doing file operations).
+ *
+ * Returns: an integer cookie, which must be passed to
+ * caja_uninhibit_power_manager() to resume
+ * normal power management.
+ */
+int
+caja_inhibit_power_manager (const char *message)
+{
+ GDBusConnection *connection;
+ GVariant *result;
+ GError *error = NULL;
+ guint cookie = 0;
+
+ g_return_val_if_fail (message != NULL, -1);
+
+ connection = get_dbus_connection ();
+
+ if (connection == NULL)
+ {
+ return -1;
+ }
+
+ result = g_dbus_connection_call_sync (connection,
+ GSM_NAME,
+ GSM_PATH,
+ GSM_INTERFACE,
+ "Inhibit",
+ g_variant_new ("(susu)",
+ "Caja",
+ (guint) 0,
+ message,
+ (guint) (INHIBIT_LOGOUT | INHIBIT_SUSPEND)),
+ G_VARIANT_TYPE ("(u)"),
+ G_DBUS_CALL_FLAGS_NO_AUTO_START,
+ -1,
+ NULL,
+ &error);
+
+ if (error != NULL)
+ {
+ g_warning ("Could not inhibit power management: %s", error->message);
+ g_error_free (error);
+ return -1;
+ }
+
+ g_variant_get (result, "(u)", &cookie);
+ g_variant_unref (result);
+
+ return (int) cookie;
+}
+
+/**
+ * caja_uninhibit_power_manager:
+ * @cookie: the cookie value returned by caja_inhibit_power_manager()
+ *
+ * Uninhibits power management. This function must be called after the task
+ * which inhibited power management has finished, or the system will not
+ * return to normal power management.
+ */
+void
+caja_uninhibit_power_manager (gint cookie)
+{
+ GDBusConnection *connection;
+ GVariant *result;
+ GError *error = NULL;
+
+ g_return_if_fail (cookie > 0);
+
+ connection = get_dbus_connection ();
+
+ if (connection == NULL)
+ {
+ return;
+ }
+
+ result = g_dbus_connection_call_sync (connection,
+ GSM_NAME,
+ GSM_PATH,
+ GSM_INTERFACE,
+ "Uninhibit",
+ g_variant_new ("(u)", (guint) cookie),
+ NULL,
+ G_DBUS_CALL_FLAGS_NO_AUTO_START,
+ -1,
+ NULL,
+ &error);
+
+ if (result == NULL)
+ {
+ g_warning ("Could not uninhibit power management: %s", error->message);
+ g_error_free (error);
+ return;
+ }
+
+ g_variant_unref (result);
+}
+
+/* Returns TRUE if the file is in XDG_DATA_DIRS or
+ in "~/.mate2/". This is used for deciding
+ if a desktop file is "trusted" based on the path */
+gboolean
+caja_is_in_system_dir (GFile *file)
+{
+ const char * const * data_dirs;
+ char *path, *mate2;
+ int i;
+ gboolean res;
+
+ if (!g_file_is_native (file))
+ {
+ return FALSE;
+ }
+
+ path = g_file_get_path (file);
+
+ res = FALSE;
+
+ data_dirs = g_get_system_data_dirs ();
+ for (i = 0; path != NULL && data_dirs[i] != NULL; i++)
+ {
+ if (g_str_has_prefix (path, data_dirs[i]))
+ {
+ res = TRUE;
+ break;
+ }
+
+ }
+
+ if (!res)
+ {
+ /* Panel desktop files are here, trust them */
+ mate2 = g_build_filename(g_get_home_dir(), ".mate2", NULL);
+
+ if (g_str_has_prefix (path, mate2))
+ {
+ res = TRUE;
+ }
+
+ g_free(mate2);
+ }
+ g_free (path);
+
+ return res;
+}
+
+GHashTable *
+caja_trashed_files_get_original_directories (GList *files,
+ GList **unhandled_files)
+{
+ GHashTable *directories;
+ CajaFile *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 = CAJA_FILE (l->data);
+ original_file = caja_file_get_trash_original_file (file);
+
+ original_dir = NULL;
+ if (original_file != NULL)
+ {
+ original_dir = caja_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) caja_file_unref,
+ (GDestroyNotify) caja_file_list_unref);
+ }
+ caja_file_ref (original_dir);
+ m = g_hash_table_lookup (directories, original_dir);
+ if (m != NULL)
+ {
+ g_hash_table_steal (directories, original_dir);
+ caja_file_unref (original_dir);
+ }
+ m = g_list_append (m, caja_file_ref (file));
+ g_hash_table_insert (directories, original_dir, m);
+ }
+ else if (unhandled_files != NULL)
+ {
+ *unhandled_files = g_list_append (*unhandled_files, caja_file_ref (file));
+ }
+
+ if (original_file != NULL)
+ {
+ caja_file_unref (original_file);
+ }
+
+ if (original_dir != NULL)
+ {
+ caja_file_unref (original_dir);
+ }
+ }
+
+ return directories;
+}
+
+static GList *
+locations_from_file_list (GList *file_list)
+{
+ CajaFile *file;
+ GList *l, *ret;
+
+ ret = NULL;
+
+ for (l = file_list; l != NULL; l = l->next)
+ {
+ file = CAJA_FILE (l->data);
+ ret = g_list_prepend (ret, caja_file_get_location (file));
+ }
+
+ return g_list_reverse (ret);
+}
+
+void
+caja_restore_files_from_trash (GList *files,
+ GtkWindow *parent_window)
+{
+ CajaFile *file, *original_dir;
+ GHashTable *original_dirs_hash;
+ GList *original_dirs, *unhandled_files;
+ GFile *original_dir_location;
+ GList *locations, *l;
+ char *message, *file_name;
+
+ original_dirs_hash = caja_trashed_files_get_original_directories (files, &unhandled_files);
+
+ for (l = unhandled_files; l != NULL; l = l->next)
+ {
+ file = CAJA_FILE (l->data);
+ file_name = caja_file_get_display_name (file);
+ message = g_strdup_printf (_("Could not determine original location of \"%s\" "), file_name);
+ g_free (file_name);
+
+ eel_show_warning_dialog (message,
+ _("The item cannot be restored from trash"),
+ parent_window);
+ g_free (message);
+ }
+
+ if (original_dirs_hash != NULL)
+ {
+ original_dirs = g_hash_table_get_keys (original_dirs_hash);
+ for (l = original_dirs; l != NULL; l = l->next)
+ {
+ original_dir = CAJA_FILE (l->data);
+ original_dir_location = caja_file_get_location (original_dir);
+
+ files = g_hash_table_lookup (original_dirs_hash, original_dir);
+ locations = locations_from_file_list (files);
+
+ caja_file_operations_move
+ (locations, NULL,
+ original_dir_location,
+ parent_window,
+ NULL, NULL);
+
+ eel_g_object_list_free (locations);
+ g_object_unref (original_dir_location);
+ }
+
+ g_list_free (original_dirs);
+ g_hash_table_destroy (original_dirs_hash);
+ }
+
+ caja_file_list_unref (unhandled_files);
+}
+
+#if !defined (CAJA_OMIT_SELF_CHECK)
+
+void
+caja_self_check_file_utilities (void)
+{
+}
+
+#endif /* !CAJA_OMIT_SELF_CHECK */
author	Perberos <[email protected]>	2011-12-01 22:24:23 -0300
committer	Perberos <[email protected]>	2011-12-01 22:24:23 -0300
commit	0e004c696b0e68b2cff37a4c3315b022a35eaf43 (patch)
tree	43261e815529cb9518ed7be37af13b846af8b26b /libcaja-private/caja-file-utilities.c
download	caja-0e004c696b0e68b2cff37a4c3315b022a35eaf43.tar.bz2 caja-0e004c696b0e68b2cff37a4c3315b022a35eaf43.tar.xz