static void
get_themes_from_themes_dir (GFile *themes_dir,
HDAvailableBackgrounds *backgrounds)
{
GFileEnumerator *enumerator;
GFileInfo *info;
GError *error = NULL;
enumerator = g_file_enumerate_children (themes_dir,
G_FILE_ATTRIBUTE_STANDARD_NAME,
G_FILE_QUERY_INFO_NONE,
NULL,
&error);
if (error)
{
char *path = g_file_get_path (themes_dir);
g_warning ("%s. Could not enumerate themes_dir %s. %s",
__FUNCTION__,
path,
error->message);
g_free (path);
g_error_free (error);
return;
}
do
{
info = g_file_enumerator_next_file (enumerator,
NULL,
&error);
if (error)
{
char *path = g_file_get_path (themes_dir);
g_warning ("%s. Error enumerating themes_dir %s. %s",
__FUNCTION__,
path,
error->message);
g_free (path);
g_error_free (error);
goto cleanup;
}
if (info)
{
const char *name;
name = g_file_info_get_name (info);
if (g_strcmp0 (name, "default") != 0)
{
HDBackground *background;
GFile *theme_dir = g_file_get_child (themes_dir, name);
GFile *desktop_file = g_file_resolve_relative_path (theme_dir,
"./backgrounds/theme_bg.desktop");
GFile *theme_file = g_file_get_child (theme_dir,
"index.theme");
background = hd_theme_background_new (desktop_file,
theme_file);
hd_imageset_background_init_async (HD_IMAGESET_BACKGROUND (background),
NULL,
(GAsyncReadyCallback) theme_loaded,
backgrounds);
g_object_unref (theme_dir);
g_object_unref (desktop_file);
g_object_unref (theme_file);
}
g_object_unref (info);
}
}
while (info);
cleanup:
g_object_unref (enumerator);
}
gboolean
e_reap_trash_directory_sync (GFile *trash_directory,
gint expiry_in_days,
GCancellable *cancellable,
GError **error)
{
GFileEnumerator *file_enumerator;
GQueue directories = G_QUEUE_INIT;
GFile *reaping_directory;
GFileInfo *file_info;
const gchar *attributes;
gboolean success = TRUE;
GError *local_error = NULL;
g_return_val_if_fail (G_IS_FILE (trash_directory), FALSE);
g_return_val_if_fail (expiry_in_days > 0, FALSE);
reaping_directory = g_file_get_child (
trash_directory, REAPING_DIRECTORY_NAME);
attributes =
G_FILE_ATTRIBUTE_STANDARD_NAME ","
G_FILE_ATTRIBUTE_STANDARD_TYPE ","
G_FILE_ATTRIBUTE_TIME_MODIFIED;
file_enumerator = g_file_enumerate_children (
trash_directory, attributes,
G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
cancellable, error);
if (file_enumerator == NULL)
return FALSE;
file_info = g_file_enumerator_next_file (
file_enumerator, cancellable, &local_error);
while (file_info != NULL) {
GFileType file_type;
GTimeVal mtime;
GDate *date_now;
GDate *date_mtime;
const gchar *name;
gboolean reap_it;
gint days_old;
name = g_file_info_get_name (file_info);
file_type = g_file_info_get_file_type (file_info);
g_file_info_get_modification_time (file_info, &mtime);
/* Calculate how many days ago the file was modified. */
date_now = g_date_new ();
g_date_set_time_t (date_now, time (NULL));
date_mtime = g_date_new ();
g_date_set_time_val (date_mtime, &mtime);
days_old = g_date_days_between (date_mtime, date_now);
g_date_free (date_mtime);
g_date_free (date_now);
reap_it =
(file_type == G_FILE_TYPE_DIRECTORY) &&
(days_old >= expiry_in_days);
if (reap_it) {
GFile *child;
child = g_file_get_child (trash_directory, name);
/* If we find an unfinished reaping directory, put
* it on the head of the queue so we reap it first. */
if (g_file_equal (child, reaping_directory))
g_queue_push_head (&directories, child);
else
g_queue_push_tail (&directories, child);
}
g_object_unref (file_info);
file_info = g_file_enumerator_next_file (
file_enumerator, cancellable, &local_error);
}
if (local_error != NULL) {
g_propagate_error (error, local_error);
success = FALSE;
}
g_object_unref (file_enumerator);
/* Now delete the directories we've queued up. */
while (success && !g_queue_is_empty (&directories)) {
GFile *directory;
directory = g_queue_pop_head (&directories);
/* First we rename the directory to prevent it
* from being recovered while being deleted. */
if (!g_file_equal (directory, reaping_directory))
success = g_file_move (
directory, reaping_directory,
G_FILE_COPY_NONE, cancellable,
NULL, NULL, error);
if (success)
success = e_file_recursive_delete_sync (
reaping_directory, cancellable, error);
g_object_unref (directory);
}
/* Flush the queue in case we aborted on an error. */
while (!g_queue_is_empty (&directories))
g_object_unref (g_queue_pop_head (&directories));
g_object_unref (reaping_directory);
return success;
}
static gboolean
dlg_add_folder_load_options (DialogData *data,
const char *name)
{
GFile *options_dir;
GFile *options_file;
char *file_path;
GKeyFile *key_file;
GError *error = NULL;
char *base_dir = NULL;
char *filename = NULL;
char *include_files = NULL;
char *exclude_files = NULL;
char *exclude_folders = NULL;
gboolean update;
gboolean recursive;
gboolean no_symlinks;
options_dir = get_user_config_subdirectory (ADD_FOLDER_OPTIONS_DIR, TRUE);
options_file = g_file_get_child (options_dir, name);
file_path = g_file_get_path (options_file);
key_file = g_key_file_new ();
if (! g_key_file_load_from_file (key_file, file_path, G_KEY_FILE_KEEP_COMMENTS, &error)) {
if (error->code != G_IO_ERROR_NOT_FOUND)
g_warning ("Could not load options file: %s\n", error->message);
g_clear_error (&error);
g_object_unref (options_file);
g_object_unref (options_dir);
g_key_file_free (key_file);
return FALSE;
}
base_dir = g_key_file_get_string (key_file, "Options", "base_dir", NULL);
filename = g_key_file_get_string (key_file, "Options", "filename", NULL);
include_files = g_key_file_get_string (key_file, "Options", "include_files", NULL);
exclude_files = g_key_file_get_string (key_file, "Options", "exclude_files", NULL);
exclude_folders = g_key_file_get_string (key_file, "Options", "exclude_folders", NULL);
update = g_key_file_get_boolean (key_file, "Options", "update", NULL);
recursive = g_key_file_get_boolean (key_file, "Options", "recursive", NULL);
no_symlinks = g_key_file_get_boolean (key_file, "Options", "no_symlinks", NULL);
sync_widgets_with_options (data,
base_dir,
filename,
include_files,
exclude_files,
exclude_folders,
update,
recursive,
no_symlinks);
dlg_add_folder_save_last_used_options (data, file_path);
g_free (base_dir);
g_free (filename);
g_free (include_files);
g_free (exclude_files);
g_free (exclude_folders);
g_key_file_free (key_file);
g_free (file_path);
g_object_unref (options_file);
g_object_unref (options_dir);
return TRUE;
}
gboolean
athena_link_local_create (const char *directory_uri,
const char *base_name,
const char *display_name,
const char *image,
const char *target_uri,
const GdkPoint *point,
int screen,
gboolean unique_filename)
{
char *real_directory_uri;
char *uri, *contents;
GFile *file;
GList dummy_list;
AthenaFileChangesQueuePosition item;
g_return_val_if_fail (directory_uri != NULL, FALSE);
g_return_val_if_fail (base_name != NULL, FALSE);
g_return_val_if_fail (display_name != NULL, FALSE);
g_return_val_if_fail (target_uri != NULL, FALSE);
if (eel_uri_is_trash (directory_uri) ||
eel_uri_is_search (directory_uri)) {
return FALSE;
}
if (eel_uri_is_desktop (directory_uri)) {
real_directory_uri = athena_get_desktop_directory_uri ();
} else {
real_directory_uri = g_strdup (directory_uri);
}
if (unique_filename) {
uri = athena_ensure_unique_file_name (real_directory_uri,
base_name, ".desktop");
if (uri == NULL) {
g_free (real_directory_uri);
return FALSE;
}
file = g_file_new_for_uri (uri);
g_free (uri);
} else {
char *link_name;
GFile *dir;
link_name = g_strdup_printf ("%s.desktop", base_name);
/* replace '/' with '-', just in case */
g_strdelimit (link_name, "/", '-');
dir = g_file_new_for_uri (directory_uri);
file = g_file_get_child (dir, link_name);
g_free (link_name);
g_object_unref (dir);
}
g_free (real_directory_uri);
contents = g_strdup_printf ("[Desktop Entry]\n"
"Encoding=UTF-8\n"
"Name=%s\n"
"Type=Link\n"
"URL=%s\n"
"%s%s\n",
display_name,
target_uri,
image != NULL ? "Icon=" : "",
image != NULL ? image : "");
if (!g_file_replace_contents (file,
contents, strlen (contents),
NULL, FALSE,
G_FILE_CREATE_NONE,
NULL, NULL, NULL)) {
g_free (contents);
g_object_unref (file);
return FALSE;
}
g_free (contents);
dummy_list.data = file;
dummy_list.next = NULL;
dummy_list.prev = NULL;
athena_directory_notify_files_added (&dummy_list);
if (point != NULL) {
item.location = file;
item.set = TRUE;
item.point.x = point->x;
item.point.y = point->y;
item.screen = screen;
dummy_list.data = &item;
dummy_list.next = NULL;
dummy_list.prev = NULL;
athena_directory_schedule_position_set (&dummy_list);
}
g_object_unref (file);
return TRUE;
}
static void
_uri_handle_recurse (GFile *dir,
GCancellable *cancel,
GHashTable *handled,
RBUriRecurseFunc func,
gpointer user_data)
{
GFileEnumerator *files;
GFileInfo *info;
GError *error = NULL;
GFileType file_type;
const char *file_id;
gboolean file_handled;
const char *attributes =
G_FILE_ATTRIBUTE_STANDARD_NAME ","
G_FILE_ATTRIBUTE_STANDARD_TYPE ","
G_FILE_ATTRIBUTE_STANDARD_IS_HIDDEN ","
G_FILE_ATTRIBUTE_ID_FILE ","
G_FILE_ATTRIBUTE_ACCESS_CAN_READ;
files = g_file_enumerate_children (dir, attributes, G_FILE_QUERY_INFO_NONE, cancel, &error);
if (error != NULL) {
char *where;
/* handle the case where we're given a single file to process */
if (error->code == G_IO_ERROR_NOT_DIRECTORY) {
g_clear_error (&error);
info = g_file_query_info (dir, attributes, G_FILE_QUERY_INFO_NONE, cancel, &error);
if (error == NULL) {
if (_should_process (info)) {
(func) (dir, FALSE, user_data);
}
g_object_unref (info);
return;
}
}
where = g_file_get_uri (dir);
rb_debug ("error enumerating %s: %s", where, error->message);
g_free (where);
g_error_free (error);
return;
}
while (1) {
GFile *child;
gboolean is_dir;
gboolean ret;
ret = TRUE;
info = g_file_enumerator_next_file (files, cancel, &error);
if (error != NULL) {
rb_debug ("error enumerating files: %s", error->message);
break;
} else if (info == NULL) {
break;
}
if (_should_process (info) == FALSE) {
g_object_unref (info);
continue;
}
/* already handled? */
file_id = g_file_info_get_attribute_string (info, G_FILE_ATTRIBUTE_ID_FILE);
if (file_id == NULL) {
/* have to hope for the best, I guess */
file_handled = FALSE;
} else if (g_hash_table_lookup (handled, file_id) != NULL) {
file_handled = TRUE;
} else {
file_handled = FALSE;
g_hash_table_insert (handled, g_strdup (file_id), GINT_TO_POINTER (1));
}
/* type? */
file_type = g_file_info_get_attribute_uint32 (info, G_FILE_ATTRIBUTE_STANDARD_TYPE);
switch (file_type) {
case G_FILE_TYPE_DIRECTORY:
case G_FILE_TYPE_MOUNTABLE:
is_dir = TRUE;
break;
default:
is_dir = FALSE;
break;
}
if (file_handled == FALSE) {
child = g_file_get_child (dir, g_file_info_get_name (info));
ret = (func) (child, is_dir, user_data);
if (is_dir) {
_uri_handle_recurse (child, cancel, handled, func, user_data);
}
g_object_unref (child);
}
g_object_unref (info);
if (ret == FALSE)
break;
}
g_object_unref (files);
}
int
main (int argc, char *argv[])
{
GError *error;
GOptionContext *context;
GFile *source, *dest, *target;
gboolean dest_is_dir;
char *basename;
int i;
GFileCopyFlags flags;
int retval = 0;
gchar *param;
gchar *summary;
setlocale (LC_ALL, "");
bindtextdomain (GETTEXT_PACKAGE, GVFS_LOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
error = NULL;
param = g_strdup_printf ("%s... %s", _("SOURCE"), _("DEST"));
summary = _("Move one or more files from SOURCE to DEST.");
context = g_option_context_new (param);
g_option_context_set_summary (context, summary);
g_option_context_add_main_entries (context, entries, GETTEXT_PACKAGE);
g_option_context_parse (context, &argc, &argv, &error);
if (error != NULL)
{
g_printerr (_("Error parsing commandline options: %s\n"), error->message);
g_printerr ("\n");
g_printerr (_("Try \"%s --help\" for more information."), g_get_prgname ());
g_printerr ("\n");
g_error_free (error);
return 1;
}
if (argc <= 2)
{
show_help (context, _("Missing operand\n"));
return 1;
}
dest = g_file_new_for_commandline_arg (argv[argc-1]);
if (no_target_directory && argc > 3)
{
show_help (context, _("Too many arguments\n"));
g_object_unref (dest);
return 1;
}
dest_is_dir = is_dir (dest);
if (!dest_is_dir && argc > 3)
{
g_printerr (_("Target %s is not a directory\n"), argv[argc-1]);
show_help (context, NULL);
g_object_unref (dest);
return 1;
}
g_option_context_free (context);
g_free (param);
for (i = 1; i < argc - 1; i++)
{
source = g_file_new_for_commandline_arg (argv[i]);
if (dest_is_dir && !no_target_directory)
{
basename = g_file_get_basename (source);
target = g_file_get_child (dest, basename);
g_free (basename);
}
else
target = g_object_ref (dest);
flags = 0;
if (backup)
flags |= G_FILE_COPY_BACKUP;
if (!interactive)
flags |= G_FILE_COPY_OVERWRITE;
error = NULL;
if (!g_file_move (source, target, flags, NULL, progress?show_progress:NULL, NULL, &error))
{
if (interactive && g_error_matches (error, G_IO_ERROR, G_IO_ERROR_EXISTS))
{
char line[16];
g_error_free (error);
error = NULL;
basename = g_file_get_basename (target);
g_print ("overwrite %s?", basename);
g_free (basename);
if (fgets(line, sizeof (line), stdin) &&
line[0] == 'y')
{
flags |= G_FILE_COPY_OVERWRITE;
if (!g_file_move (source, target, flags, NULL, NULL, NULL, &error))
goto move_failed;
}
}
else
{
move_failed:
g_printerr (_("Error moving file %s: %s\n"), argv[i], error->message);
g_error_free (error);
retval = 1;
}
}
g_object_unref (source);
g_object_unref (target);
}
g_object_unref (dest);
return retval;
}
static void
visit_directory (GFile *dir, SearchThreadData *data)
{
GFileEnumerator *enumerator;
GFileInfo *info;
GFile *child;
const char *mime_type, *display_name;
char *lower_name, *normalized;
gboolean hit;
int i;
GList *l;
const char *id;
gboolean visited;
enumerator = g_file_enumerate_children (dir,
data->mime_types != NULL ?
STD_ATTRIBUTES ","
G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE
:
STD_ATTRIBUTES
,
0, data->cancellable, NULL);
if (enumerator == NULL) {
return;
}
while ((info = g_file_enumerator_next_file (enumerator, data->cancellable, NULL)) != NULL) {
if (g_file_info_get_is_hidden (info)) {
goto next;
}
display_name = g_file_info_get_display_name (info);
if (display_name == NULL) {
goto next;
}
normalized = g_utf8_normalize (display_name, -1, G_NORMALIZE_NFD);
lower_name = g_utf8_strdown (normalized, -1);
g_free (normalized);
hit = TRUE;
for (i = 0; data->words[i] != NULL; i++) {
if (strstr (lower_name, data->words[i]) == NULL) {
hit = FALSE;
break;
}
}
g_free (lower_name);
if (hit && data->mime_types) {
mime_type = g_file_info_get_content_type (info);
hit = FALSE;
for (l = data->mime_types; mime_type != NULL && l != NULL; l = l->next) {
if (g_content_type_equals (mime_type, l->data)) {
hit = TRUE;
break;
}
}
}
child = g_file_get_child (dir, g_file_info_get_name (info));
if (hit) {
data->uri_hits = g_list_prepend (data->uri_hits, g_file_get_uri (child));
}
data->n_processed_files++;
if (data->n_processed_files > BATCH_SIZE) {
send_batch (data);
}
if (g_file_info_get_file_type (info) == G_FILE_TYPE_DIRECTORY) {
id = g_file_info_get_attribute_string (info, G_FILE_ATTRIBUTE_ID_FILE);
visited = FALSE;
if (id) {
if (g_hash_table_lookup_extended (data->visited,
id, NULL, NULL)) {
visited = TRUE;
} else {
g_hash_table_insert (data->visited, g_strdup (id), NULL);
}
}
if (!visited) {
g_queue_push_tail (data->directories, g_object_ref (child));
}
}
g_object_unref (child);
next:
g_object_unref (info);
}
g_object_unref (enumerator);
}
