GList *
nautilus_directory_match_pattern (NautilusDirectory *directory, const char *pattern)
{
GList *files, *l, *ret;
GPatternSpec *spec;
ret = NULL;
spec = g_pattern_spec_new (pattern);
files = nautilus_directory_get_file_list (directory);
for (l = files; l; l = l->next) {
NautilusFile *file;
char *name;
file = NAUTILUS_FILE (l->data);
name = nautilus_file_get_display_name (file);
if (g_pattern_match_string (spec, name)) {
ret = g_list_prepend(ret, nautilus_file_ref (file));
}
g_free (name);
}
g_pattern_spec_free (spec);
nautilus_file_list_free (files);
return ret;
}
char *
nautilus_compute_title_for_location (GFile *location)
{
NautilusFile *file;
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"));
}
title = NULL;
if (location) {
file = nautilus_file_get (location);
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;
}
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);
eel_show_warning_dialog (message,
_("The item cannot be restored from trash"),
parent_window);
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);
}
static gboolean
go_to_server_cb (NautilusWindow *window,
GFile *location,
GError *error,
gpointer user_data)
{
gboolean retval;
if (error == NULL) {
GBookmarkFile *bookmarks;
GError *error = NULL;
char *datadir;
char *filename;
char *uri;
char *title;
NautilusFile *file;
gboolean safe_to_save = TRUE;
file = nautilus_file_get_existing (location);
bookmarks = g_bookmark_file_new ();
datadir = g_build_filename (g_get_user_config_dir (), "nautilus", NULL);
filename = g_build_filename (datadir, "servers", NULL);
g_mkdir_with_parents (datadir, 0700);
g_free (datadir);
g_bookmark_file_load_from_file (bookmarks,
filename,
&error);
if (error != NULL) {
if (! g_error_matches (error, G_FILE_ERROR, G_FILE_ERROR_NOENT)) {
/* only warn if the file exists */
g_warning ("Unable to open server bookmarks: %s", error->message);
safe_to_save = FALSE;
}
g_error_free (error);
}
if (safe_to_save) {
uri = nautilus_file_get_uri (file);
title = nautilus_file_get_display_name (file);
g_bookmark_file_set_title (bookmarks, uri, title);
g_bookmark_file_set_visited (bookmarks, uri, -1);
g_bookmark_file_add_application (bookmarks, uri, NULL, NULL);
g_free (uri);
g_free (title);
g_bookmark_file_to_file (bookmarks, filename, NULL);
}
g_free (filename);
g_bookmark_file_free (bookmarks);
retval = TRUE;
} else {
retval = FALSE;
}
return retval;
}
void
nautilus_report_error_loading_directory (NautilusFile *file,
GError *error,
GtkWindow *parent_window)
{
char *file_name;
char *message;
if (error == NULL ||
error->message == NULL)
{
return;
}
if (error->domain == G_IO_ERROR &&
error->code == G_IO_ERROR_NOT_MOUNTED)
{
/* This case is retried automatically */
return;
}
file_name = nautilus_file_get_display_name (file);
if (error->domain == G_IO_ERROR)
{
switch (error->code)
{
case G_IO_ERROR_PERMISSION_DENIED:
{
message = g_strdup_printf (_("You do not have the permissions necessary to view the contents of “%s”."),
file_name);
}
break;
case G_IO_ERROR_NOT_FOUND:
{
message = g_strdup_printf (_("“%s” could not be found. Perhaps it has recently been deleted."),
file_name);
}
break;
default:
message = g_strdup_printf (_("Sorry, could not display all the contents of “%s”: %s"), file_name,
error->message);
}
}
else
{
message = g_strdup (error->message);
}
eel_show_error_dialog (_("This location could not be displayed."), message, parent_window);
g_free (file_name);
g_free (message);
}
static char *
get_truncated_name_for_file (NautilusFile *file)
{
g_autofree char *file_name = NULL;
g_assert (NAUTILUS_IS_FILE (file));
file_name = nautilus_file_get_display_name (file);
return eel_str_middle_truncate (file_name, MAXIMUM_DISPLAYED_FILE_NAME_LENGTH);
}
void
nautilus_report_error_setting_group (NautilusFile *file,
GError *error,
GtkWindow *parent_window)
{
char *file_name;
char *message;
if (error == NULL)
{
return;
}
file_name = nautilus_file_get_display_name (file);
message = NULL;
if (error->domain == G_IO_ERROR)
{
switch (error->code)
{
case G_IO_ERROR_PERMISSION_DENIED:
{
message = g_strdup_printf (_("You do not have the permissions necessary to change the group of “%s”."),
file_name);
}
break;
default:
{
}
break;
}
}
if (message == NULL)
{
/* We should invent decent error messages for every case we actually experience. */
g_warning ("Hit unhandled case %s:%d in nautilus_report_error_setting_group",
g_quark_to_string (error->domain), error->code);
/* fall through */
message = g_strdup_printf (_("Sorry, could not change the group of “%s”: %s"), file_name,
error->message);
}
eel_show_error_dialog (_("The group could not be changed."), message, parent_window);
g_free (file_name);
g_free (message);
}
void
nautilus_restore_files_from_trash (GList *files,
GtkWindow *parent_window)
{
NautilusFile *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 = 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);
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 = NAUTILUS_FILE (l->data);
original_dir_location = nautilus_file_get_location (original_dir);
files = g_hash_table_lookup (original_dirs_hash, original_dir);
locations = locations_from_file_list (files);
nautilus_file_operations_move
(locations, NULL,
original_dir_location,
parent_window,
NULL, NULL);
g_list_free_full (locations, g_object_unref);
g_object_unref (original_dir_location);
}
g_list_free (original_dirs);
g_hash_table_destroy (original_dirs_hash);
}
nautilus_file_list_unref (unhandled_files);
}
void
fm_rename_file (NautilusFile *file,
const char *new_name,
NautilusFileOperationCallback callback,
gpointer callback_data)
{
char *old_name, *wait_message;
FMRenameData *data;
char *uri;
GError *error;
g_return_if_fail (NAUTILUS_IS_FILE (file));
g_return_if_fail (new_name != NULL);
/* Stop any earlier rename that's already in progress. */
error = g_error_new (G_IO_ERROR, G_IO_ERROR_CANCELLED, "Cancelled");
finish_rename (file, TRUE, error);
g_error_free (error);
data = g_new0 (FMRenameData, 1);
data->name = g_strdup (new_name);
data->callback = callback;
data->callback_data = callback_data;
/* Attach the new name to the file. */
g_object_set_data_full (G_OBJECT (file),
NEW_NAME_TAG,
data, (GDestroyNotify)fm_rename_data_free);
/* Start the timed wait to cancel the rename. */
old_name = nautilus_file_get_display_name (file);
wait_message = g_strdup_printf (_("Renaming \"%s\" to \"%s\"."),
old_name,
new_name);
g_free (old_name);
eel_timed_wait_start (cancel_rename_callback, file, wait_message,
NULL); /* FIXME bugzilla.gnome.org 42395: Parent this? */
g_free (wait_message);
uri = nautilus_file_get_uri (file);
nautilus_debug_log (FALSE, NAUTILUS_DEBUG_LOG_DOMAIN_USER,
"rename file old=\"%s\", new=\"%s\"",
uri, new_name);
g_free (uri);
/* Start the rename. */
nautilus_file_rename (file, new_name,
rename_callback, NULL);
}
static void
nautilus_mime_application_chooser_apply_labels (NautilusMimeApplicationChooser *chooser)
{
gchar *label, *extension = NULL, *description = NULL;
gint num_files;
NautilusFile *file;
num_files = g_list_length (chooser->details->files);
file = chooser->details->files->data;
/* here we assume all files are of the same content type */
if (g_content_type_is_unknown (chooser->details->content_type)) {
extension = nautilus_file_get_extension (file);
/* Translators: the %s here is a file extension */
description = g_strdup_printf (_("%s document"), extension);
} else {
description = g_content_type_get_description (chooser->details->content_type);
}
if (num_files > 1) {
/* Translators; %s here is a mime-type description */
label = g_strdup_printf (_("Open all files of type “%s” with"),
description);
} else {
gchar *display_name;
display_name = nautilus_file_get_display_name (file);
/* Translators: first %s is filename, second %s is mime-type description */
label = g_strdup_printf (_("Select an application to open “%s” and other files of type “%s”"),
display_name, description);
g_free (display_name);
}
gtk_label_set_markup (GTK_LABEL (chooser->details->label), label);
g_free (label);
g_free (extension);
g_free (description);
}
static void
bookmark_set_name_from_ready_file (NautilusBookmark *self,
NautilusFile *file)
{
gchar *display_name;
if (self->details->has_custom_name) {
return;
}
display_name = nautilus_file_get_display_name (self->details->file);
if (nautilus_file_is_home (self->details->file)) {
nautilus_bookmark_set_name_internal (self, _("Home"));
} else if (g_strcmp0 (self->details->name, display_name) != 0) {
nautilus_bookmark_set_name_internal (self, display_name);
DEBUG ("%s: name changed to %s", nautilus_bookmark_get_name (self), display_name);
}
g_free (display_name);
}
void
nautilus_report_error_setting_permissions (NautilusFile *file,
GError *error,
GtkWindow *parent_window)
{
char *file_name;
char *message;
if (error == NULL) {
return;
}
file_name = nautilus_file_get_display_name (file);
message = g_strdup_printf (_("Sorry, could not change the permissions of “%s”: %s"), file_name, error->message);
eel_show_error_dialog (_("The permissions could not be changed."), message, parent_window);
g_free (file_name);
g_free (message);
}
char *
nautilus_compute_title_for_location (GFile *location)
{
NautilusFile *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 = nautilus_file_get (location);
title = nautilus_file_get_display_name (file);
nautilus_file_unref (file);
}
if (title == NULL) {
title = g_strdup ("");
}
return title;
}
void
nautilus_report_error_renaming_file (NautilusFile *file,
const char *new_name,
GError *error,
GtkWindow *parent_window)
{
char *original_name, *original_name_truncated;
char *new_name_truncated;
char *message;
/* Truncate names for display since very long file names with no spaces
* in them won't get wrapped, and can create insanely wide dialog boxes.
*/
original_name = nautilus_file_get_display_name (file);
original_name_truncated = eel_str_middle_truncate (original_name, MAXIMUM_DISPLAYED_FILE_NAME_LENGTH);
g_free (original_name);
new_name_truncated = eel_str_middle_truncate (new_name, MAXIMUM_DISPLAYED_FILE_NAME_LENGTH);
message = NULL;
if (error->domain == G_IO_ERROR) {
switch (error->code) {
case G_IO_ERROR_EXISTS:
message = g_strdup_printf (_("The name “%s” is already used in this location. "
"Please use a different name."),
new_name_truncated);
break;
case G_IO_ERROR_NOT_FOUND:
message = g_strdup_printf (_("There is no “%s” in this location. "
"Perhaps it was just moved or deleted?"),
original_name_truncated);
break;
case G_IO_ERROR_PERMISSION_DENIED:
message = g_strdup_printf (_("You do not have the permissions necessary to rename “%s”."),
original_name_truncated);
break;
case G_IO_ERROR_INVALID_FILENAME:
if (strchr (new_name, '/') != NULL) {
message = g_strdup_printf (_("The name “%s” is not valid because it contains the character “/”. "
"Please use a different name."),
new_name_truncated);
} else {
message = g_strdup_printf (_("The name “%s” is not valid. "
"Please use a different name."),
new_name_truncated);
}
break;
case G_IO_ERROR_FILENAME_TOO_LONG:
message = g_strdup_printf (_("The name “%s” is too long. "
"Please use a different name."),
new_name_truncated);
break;
default:
break;
}
}
if (message == NULL) {
/* We should invent decent error messages for every case we actually experience. */
g_warning ("Hit unhandled case %s:%d in nautilus_report_error_renaming_file",
g_quark_to_string (error->domain), error->code);
/* fall through */
message = g_strdup_printf (_("Sorry, could not rename “%s” to “%s”: %s"),
original_name_truncated, new_name_truncated,
error->message);
}
g_free (original_name_truncated);
g_free (new_name_truncated);
eel_show_error_dialog (_("The item could not be renamed."), message, parent_window);
g_free (message);
}
/* This callback returns the text, both the editable part, and the
* part below that is not editable.
*/
static void
nautilus_canvas_view_container_get_icon_text (NautilusCanvasContainer *container,
NautilusCanvasIconData *data,
char **editable_text,
char **additional_text,
gboolean include_invisible)
{
GQuark *attributes;
char *text_array[4];
int i, j, num_attributes;
NautilusCanvasView *canvas_view;
NautilusFile *file;
gboolean use_additional;
file = NAUTILUS_FILE (data);
g_assert (NAUTILUS_IS_FILE (file));
g_assert (editable_text != NULL);
canvas_view = get_canvas_view (container);
g_return_if_fail (canvas_view != NULL);
use_additional = (additional_text != NULL);
/* In the smallest zoom mode, no text is drawn. */
if (nautilus_canvas_container_get_zoom_level (container) == NAUTILUS_ZOOM_LEVEL_SMALLEST &&
!include_invisible) {
*editable_text = NULL;
} else {
/* Strip the suffix for nautilus object xml files. */
*editable_text = nautilus_file_get_display_name (file);
}
if (!use_additional) {
return;
}
if (NAUTILUS_IS_DESKTOP_ICON_FILE (file) ||
nautilus_file_is_nautilus_link (file)) {
/* Don't show the normal extra information for desktop icons,
* or desktop files, it doesn't make sense. */
*additional_text = NULL;
return;
}
/* Find out what attributes go below each icon. */
attributes = nautilus_canvas_view_container_get_icon_text_attribute_names (container,
&num_attributes);
/* Get the attributes. */
j = 0;
for (i = 0; i < num_attributes; ++i) {
char *text;
if (attributes[i] == attribute_none_q) {
continue;
}
text = nautilus_file_get_string_attribute_q (file, attributes[i]);
if (text == NULL) {
continue;
}
text_array[j++] = text;
}
text_array[j] = NULL;
/* Return them. */
if (j == 0) {
*additional_text = NULL;
} else if (j == 1) {
/* Only one item, avoid the strdup + free */
*additional_text = text_array[0];
} else {
*additional_text = g_strjoinv ("\n", text_array);
for (i = 0; i < j; i++) {
g_free (text_array[i]);
}
}
}
static void
file_list_ready_cb (GList *files,
gpointer user_data)
{
NautilusFileConflictDialog *fcd = user_data;
NautilusFile *src, *dest, *dest_dir;
time_t src_mtime, dest_mtime;
gboolean source_is_dir, dest_is_dir, should_show_type;
NautilusFileConflictDialogDetails *details;
char *primary_text, *message, *secondary_text;
const gchar *message_extra;
char *dest_name, *dest_dir_name, *edit_name;
char *label_text;
char *size, *date, *type = NULL;
GdkPixbuf *pixbuf;
GtkWidget *label;
GString *str;
PangoAttrList *attr_list;
details = fcd->details;
details->handle = NULL;
dest_dir = g_list_nth_data (files, 0);
dest = g_list_nth_data (files, 1);
src = g_list_nth_data (files, 2);
src_mtime = nautilus_file_get_mtime (src);
dest_mtime = nautilus_file_get_mtime (dest);
dest_name = nautilus_file_get_display_name (dest);
dest_dir_name = nautilus_file_get_display_name (dest_dir);
source_is_dir = nautilus_file_is_directory (src);
dest_is_dir = nautilus_file_is_directory (dest);
type = nautilus_file_get_mime_type (dest);
should_show_type = !nautilus_file_is_mime_type (src, type);
g_free (type);
type = NULL;
/* Set up the right labels */
if (dest_is_dir) {
if (source_is_dir) {
primary_text = g_strdup_printf
(_("Merge folder “%s”?"),
dest_name);
message_extra =
_("Merging will ask for confirmation before replacing any files in "
"the folder that conflict with the files being copied.");
if (src_mtime > dest_mtime) {
message = g_strdup_printf (
_("An older folder with the same name already exists in “%s”."),
dest_dir_name);
} else if (src_mtime < dest_mtime) {
message = g_strdup_printf (
_("A newer folder with the same name already exists in “%s”."),
dest_dir_name);
} else {
message = g_strdup_printf (
_("Another folder with the same name already exists in “%s”."),
dest_dir_name);
}
} else {
message_extra =
_("Replacing it will remove all files in the folder.");
primary_text = g_strdup_printf
(_("Replace folder “%s”?"), dest_name);
message = g_strdup_printf
(_("A folder with the same name already exists in “%s”."),
dest_dir_name);
}
} else {
primary_text = g_strdup_printf
(_("Replace file “%s”?"), dest_name);
message_extra = _("Replacing it will overwrite its content.");
if (src_mtime > dest_mtime) {
message = g_strdup_printf (
_("An older file with the same name already exists in “%s”."),
dest_dir_name);
} else if (src_mtime < dest_mtime) {
message = g_strdup_printf (
_("A newer file with the same name already exists in “%s”."),
dest_dir_name);
} else {
message = g_strdup_printf (
_("Another file with the same name already exists in “%s”."),
dest_dir_name);
}
}
secondary_text = g_strdup_printf ("%s\n%s", message, message_extra);
g_free (message);
label = gtk_label_new (primary_text);
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_label_set_line_wrap_mode (GTK_LABEL (label), PANGO_WRAP_WORD_CHAR);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (details->titles_vbox),
label, FALSE, FALSE, 0);
gtk_widget_show (label);
attr_list = pango_attr_list_new ();
pango_attr_list_insert (attr_list, pango_attr_weight_new (PANGO_WEIGHT_BOLD));
pango_attr_list_insert (attr_list, pango_attr_scale_new (PANGO_SCALE_LARGE));
g_object_set (label,
"attributes", attr_list,
NULL);
pango_attr_list_unref (attr_list);
label = gtk_label_new (secondary_text);
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (details->titles_vbox),
label, FALSE, FALSE, 0);
gtk_widget_show (label);
g_free (primary_text);
g_free (secondary_text);
/* Set up file icons */
pixbuf = nautilus_file_get_icon_pixbuf (dest,
NAUTILUS_ICON_SIZE_LARGE,
TRUE,
gtk_widget_get_scale_factor (fcd->details->titles_vbox),
NAUTILUS_FILE_ICON_FLAGS_USE_THUMBNAILS);
details->dest_image = gtk_image_new_from_pixbuf (pixbuf);
gtk_box_pack_start (GTK_BOX (details->first_hbox),
details->dest_image, FALSE, FALSE, 0);
gtk_widget_show (details->dest_image);
g_object_unref (pixbuf);
pixbuf = nautilus_file_get_icon_pixbuf (src,
NAUTILUS_ICON_SIZE_LARGE,
TRUE,
gtk_widget_get_scale_factor (fcd->details->titles_vbox),
NAUTILUS_FILE_ICON_FLAGS_USE_THUMBNAILS);
details->src_image = gtk_image_new_from_pixbuf (pixbuf);
gtk_box_pack_start (GTK_BOX (details->second_hbox),
details->src_image, FALSE, FALSE, 0);
gtk_widget_show (details->src_image);
g_object_unref (pixbuf);
/* Set up labels */
label = gtk_label_new (NULL);
date = nautilus_file_get_string_attribute (dest,
"date_modified");
size = nautilus_file_get_string_attribute (dest, "size");
if (should_show_type) {
type = nautilus_file_get_string_attribute (dest, "type");
}
str = g_string_new (NULL);
g_string_append_printf (str, "<b>%s</b>\n", _("Original file"));
g_string_append_printf (str, "%s %s\n", _("Size:"), size);
if (should_show_type) {
g_string_append_printf (str, "%s %s\n", _("Type:"), type);
}
g_string_append_printf (str, "%s %s", _("Last modified:"), date);
label_text = str->str;
gtk_label_set_markup (GTK_LABEL (label),
label_text);
gtk_box_pack_start (GTK_BOX (details->first_hbox),
label, FALSE, FALSE, 0);
gtk_widget_show (label);
g_free (size);
g_free (type);
g_free (date);
g_string_erase (str, 0, -1);
/* Second label */
label = gtk_label_new (NULL);
date = nautilus_file_get_string_attribute (src,
"date_modified");
size = nautilus_file_get_string_attribute (src, "size");
if (should_show_type) {
type = nautilus_file_get_string_attribute (src, "type");
}
g_string_append_printf (str, "<b>%s</b>\n", _("Replace with"));
g_string_append_printf (str, "%s %s\n", _("Size:"), size);
if (should_show_type) {
g_string_append_printf (str, "%s %s\n", _("Type:"), type);
}
g_string_append_printf (str, "%s %s", _("Last modified:"), date);
label_text = g_string_free (str, FALSE);
gtk_label_set_markup (GTK_LABEL (label),
label_text);
gtk_box_pack_start (GTK_BOX (details->second_hbox),
label, FALSE, FALSE, 0);
gtk_widget_show (label);
g_free (size);
g_free (date);
g_free (type);
g_free (label_text);
/* Populate the entry */
edit_name = nautilus_file_get_edit_name (dest);
details->conflict_name = edit_name;
gtk_entry_set_text (GTK_ENTRY (details->entry), edit_name);
if (source_is_dir && dest_is_dir) {
gtk_button_set_label (GTK_BUTTON (details->replace_button),
_("Merge"));
}
nautilus_file_monitor_add (src, fcd, NAUTILUS_FILE_ATTRIBUTES_FOR_ICON);
nautilus_file_monitor_add (dest, fcd, NAUTILUS_FILE_ATTRIBUTES_FOR_ICON);
details->src_handler_id = g_signal_connect (src, "changed",
G_CALLBACK (file_icons_changed), fcd);
details->dest_handler_id = g_signal_connect (dest, "changed",
G_CALLBACK (file_icons_changed), fcd);
}
static void
set_copy_move_dialog_text (FileConflictDialogData *data)
{
g_autofree gchar *primary_text = NULL;
g_autofree gchar *secondary_text = NULL;
const gchar *message_extra;
time_t source_mtime;
time_t destination_mtime;
g_autofree gchar *message = NULL;
g_autofree gchar *destination_name = NULL;
g_autofree gchar *destination_directory_name = NULL;
gboolean source_is_directory;
gboolean destination_is_directory;
source_mtime = nautilus_file_get_mtime (data->source);
destination_mtime = nautilus_file_get_mtime (data->destination);
destination_name = nautilus_file_get_display_name (data->destination);
destination_directory_name = nautilus_file_get_display_name (data->destination_directory);
source_is_directory = nautilus_file_is_directory (data->source);
destination_is_directory = nautilus_file_is_directory (data->destination);
if (destination_is_directory)
{
if (source_is_directory)
{
primary_text = g_strdup_printf (_("Merge folder “%s”?"),
destination_name);
message_extra = _("Merging will ask for confirmation before replacing any files in "
"the folder that conflict with the files being copied.");
if (source_mtime > destination_mtime)
{
message = g_strdup_printf (_("An older folder with the same name already exists in “%s”."),
destination_directory_name);
}
else if (source_mtime < destination_mtime)
{
message = g_strdup_printf (_("A newer folder with the same name already exists in “%s”."),
destination_directory_name);
}
else
{
message = g_strdup_printf (_("Another folder with the same name already exists in “%s”."),
destination_directory_name);
}
}
else
{
primary_text = g_strdup_printf (_("Replace folder “%s”?"),
destination_name);
message_extra = _("Replacing it will remove all files in the folder.");
message = g_strdup_printf (_("A folder with the same name already exists in “%s”."),
destination_directory_name);
}
}
else
{
primary_text = g_strdup_printf (_("Replace file “%s”?"),
destination_name);
message_extra = _("Replacing it will overwrite its content.");
if (source_mtime > destination_mtime)
{
message = g_strdup_printf (_("An older file with the same name already exists in “%s”."),
destination_directory_name);
}
else if (source_mtime < destination_mtime)
{
message = g_strdup_printf (_("A newer file with the same name already exists in “%s”."),
destination_directory_name);
}
else
{
message = g_strdup_printf (_("Another file with the same name already exists in “%s”."),
destination_directory_name);
}
}
secondary_text = g_strdup_printf ("%s\n%s", message, message_extra);
nautilus_file_conflict_dialog_set_text (data->dialog,
primary_text,
secondary_text);
}