static void
sync_search_directory (NautilusWindowSlot *slot)
{
NautilusDirectory *directory;
NautilusQuery *query;
gchar *text;
GFile *location;
g_assert (NAUTILUS_IS_FILE (slot->viewed_file));
directory = nautilus_directory_get_for_file (slot->viewed_file);
g_assert (NAUTILUS_IS_SEARCH_DIRECTORY (directory));
query = nautilus_query_editor_get_query (slot->query_editor);
text = nautilus_query_get_text (query);
if (!strlen (text)) {
location = nautilus_query_editor_get_location (slot->query_editor);
slot->load_with_search = TRUE;
nautilus_window_slot_open_location (slot, location, 0);
g_object_unref (location);
} else {
nautilus_search_directory_set_query (NAUTILUS_SEARCH_DIRECTORY (directory),
query);
nautilus_window_slot_reload (slot);
}
g_free (text);
g_object_unref (query);
nautilus_directory_unref (directory);
}
static NautilusIconInfo *
nautilus_canvas_view_container_get_icon_images (NautilusCanvasContainer *container,
NautilusCanvasIconData *data,
int size,
gboolean for_drag_accept)
{
NautilusCanvasView *canvas_view;
NautilusFile *file;
NautilusFileIconFlags flags;
NautilusIconInfo *icon_info;
gint scale;
file = (NautilusFile *) data;
g_assert (NAUTILUS_IS_FILE (file));
canvas_view = get_canvas_view (container);
g_return_val_if_fail (canvas_view != NULL, NULL);
flags = NAUTILUS_FILE_ICON_FLAGS_USE_EMBLEMS |
NAUTILUS_FILE_ICON_FLAGS_USE_THUMBNAILS;
if (for_drag_accept) {
flags |= NAUTILUS_FILE_ICON_FLAGS_FOR_DRAG_ACCEPT;
}
scale = gtk_widget_get_scale_factor (GTK_WIDGET (canvas_view));
icon_info = nautilus_file_get_icon (file, size, scale, flags);
return icon_info;
}
void
nautilus_directory_remove_file (NautilusDirectory *directory, NautilusFile *file)
{
GList *node;
g_assert (NAUTILUS_IS_DIRECTORY (directory));
g_assert (NAUTILUS_IS_FILE (file));
g_assert (file->details->name != NULL);
/* Find the list node in the hash table. */
node = extract_from_hash_table (directory, file);
g_assert (node != NULL);
g_assert (node->data == file);
/* Remove the item from the list. */
directory->details->file_list = g_list_remove_link
(directory->details->file_list, node);
g_list_free_1 (node);
nautilus_directory_remove_file_from_work_queue (directory, file);
if (!file->details->unconfirmed) {
directory->details->confirmed_file_count--;
}
/* Unref if we are monitoring. */
if (nautilus_directory_is_file_list_monitored (directory)) {
nautilus_file_unref (file);
}
}
void
nautilus_directory_add_file (NautilusDirectory *directory, NautilusFile *file)
{
GList *node;
gboolean add_to_work_queue;
g_assert (NAUTILUS_IS_DIRECTORY (directory));
g_assert (NAUTILUS_IS_FILE (file));
g_assert (file->details->name != NULL);
/* Add to list. */
node = g_list_prepend (directory->details->file_list, file);
directory->details->file_list = node;
/* Add to hash table. */
add_to_hash_table (directory, file, node);
directory->details->confirmed_file_count++;
add_to_work_queue = FALSE;
if (nautilus_directory_is_file_list_monitored (directory)) {
/* Ref if we are monitoring, since monitoring owns the file list. */
nautilus_file_ref (file);
add_to_work_queue = TRUE;
} else if (nautilus_directory_has_active_request_for_file (directory, file)) {
/* We're waiting for the file in a call_when_ready. Make sure
we add the file to the work queue so that said waiter won't
wait forever for e.g. all files in the directory to be done */
add_to_work_queue = TRUE;
}
if (add_to_work_queue) {
nautilus_directory_add_file_to_work_queue (directory, file);
}
}
void
nautilus_drag_file_receive_dropped_keyword (NautilusFile *file,
const char *keyword)
{
GList *keywords, *word;
g_return_if_fail (NAUTILUS_IS_FILE (file));
g_return_if_fail (keyword != NULL);
/* special case the erase emblem */
if (strcmp (keyword, NAUTILUS_FILE_DND_ERASE_KEYWORD) == 0) {
keywords = NULL;
} else {
keywords = nautilus_file_get_keywords (file);
word = g_list_find_custom (keywords, keyword, (GCompareFunc) strcmp);
if (word == NULL) {
keywords = g_list_prepend (keywords, g_strdup (keyword));
} else {
keywords = g_list_remove_link (keywords, word);
g_free (word->data);
g_list_free_1 (word);
}
}
nautilus_file_set_keywords (file, keywords);
eel_g_list_free_deep (keywords);
}
static void
rename_callback (NautilusFile *file,
GFile *result_location,
GError *error,
gpointer callback_data)
{
NautilusRenameData *data;
gboolean cancelled = FALSE;
g_assert (NAUTILUS_IS_FILE (file));
g_assert (callback_data == NULL);
data = g_object_get_data (G_OBJECT (file), NEW_NAME_TAG);
g_assert (data != NULL);
if (error)
{
if (!(error->domain == G_IO_ERROR && error->code == G_IO_ERROR_CANCELLED))
{
/* If rename failed, notify the user. */
nautilus_report_error_renaming_file (file, data->name, error, NULL);
}
else
{
cancelled = TRUE;
}
}
finish_rename (file, !cancelled, error);
}
static gboolean
vfs_contains_file (NautilusDirectory *directory,
NautilusFile *file)
{
g_assert (NAUTILUS_IS_VFS_DIRECTORY (directory));
g_assert (NAUTILUS_IS_FILE (file));
return file->details->directory == directory;
}
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);
}
static void
initialize_background_from_settings (NautilusFile *file,
EelBackground *background)
{
char *color;
char *image;
EelBackgroundImagePlacement placement;
g_assert (NAUTILUS_IS_FILE (file));
g_assert (EEL_IS_BACKGROUND (background));
g_assert (g_object_get_data (G_OBJECT (background), "eel_background_file")
== file);
if (eel_background_is_desktop (background)) {
nautilus_file_background_read_desktop_settings (&color, &image, &placement);
} else {
color = nautilus_file_get_metadata (file,
NAUTILUS_METADATA_KEY_LOCATION_BACKGROUND_COLOR,
NULL);
image = nautilus_file_get_metadata (file,
NAUTILUS_METADATA_KEY_LOCATION_BACKGROUND_IMAGE,
NULL);
placement = EEL_BACKGROUND_TILED; /* non-tiled only avail for desktop, at least for now */
/* if there's none, read the default from the theme */
if (color == NULL && image == NULL) {
nautilus_file_background_get_default_settings
(&color, &image, &placement);
}
}
/* Block the other handler while we are responding to changes
* in the metadata so it doesn't try to change the metadata.
*/
g_signal_handlers_block_by_func
(background,
G_CALLBACK (background_changed_callback),
file);
eel_background_set_color (background, color);
eel_background_set_image_uri (background, image);
eel_background_set_image_placement (background, placement);
/* Unblock the handler. */
g_signal_handlers_unblock_by_func
(background,
G_CALLBACK (background_changed_callback),
file);
g_free (color);
g_free (image);
}
static void
nautilus_canvas_view_container_stop_monitor_top_left (NautilusCanvasContainer *container,
NautilusCanvasIconData *data,
gconstpointer client)
{
NautilusFile *file;
file = (NautilusFile *) data;
g_assert (NAUTILUS_IS_FILE (file));
nautilus_file_monitor_remove (file, client);
}
NautilusDirectory *
nautilus_directory_get_for_file (NautilusFile *file)
{
char *uri;
NautilusDirectory *directory;
g_return_val_if_fail (NAUTILUS_IS_FILE (file), NULL);
uri = nautilus_file_get_uri (file);
directory = nautilus_directory_get_by_uri (uri);
g_free (uri);
return directory;
}
gboolean
nautilus_directory_contains_file (NautilusDirectory *directory,
NautilusFile *file)
{
g_return_val_if_fail (NAUTILUS_IS_DIRECTORY (directory), FALSE);
g_return_val_if_fail (NAUTILUS_IS_FILE (file), FALSE);
if (nautilus_file_is_gone (file)) {
return FALSE;
}
return NAUTILUS_DIRECTORY_CLASS (G_OBJECT_GET_CLASS (directory))->contains_file (directory, file);
}
static void
ready_callback (NautilusFile *file,
gpointer callback_data)
{
DesktopCallback *desktop_callback;
g_assert (NAUTILUS_IS_FILE (file));
g_assert (callback_data != NULL);
desktop_callback = callback_data;
g_assert (g_list_find (desktop_callback->non_ready_files, file) != NULL);
desktop_callback_remove_file (desktop_callback, file);
}
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);
}
gboolean
nautilus_directory_contains_file (NautilusDirectory *directory,
NautilusFile *file)
{
g_return_val_if_fail (NAUTILUS_IS_DIRECTORY (directory), FALSE);
g_return_val_if_fail (NAUTILUS_IS_FILE (file), FALSE);
if (nautilus_file_is_gone (file)) {
return FALSE;
}
return EEL_CALL_METHOD_WITH_RETURN_VALUE
(NAUTILUS_DIRECTORY_CLASS, directory,
contains_file, (directory, file));
}
static char *
nautilus_canvas_view_container_get_icon_description (NautilusCanvasContainer *container,
NautilusCanvasIconData *data)
{
NautilusFile *file;
char *mime_type;
const char *description;
file = NAUTILUS_FILE (data);
g_assert (NAUTILUS_IS_FILE (file));
mime_type = nautilus_file_get_mime_type (file);
description = g_content_type_get_description (mime_type);
g_free (mime_type);
return g_strdup (description);
}
void
nautilus_rename_file (NautilusFile *file,
const char *new_name,
NautilusFileOperationCallback callback,
gpointer callback_data)
{
g_autoptr (GError) error = NULL;
NautilusRenameData *data;
g_autofree char *truncated_old_name = NULL;
g_autofree char *truncated_new_name = NULL;
g_autofree char *wait_message = NULL;
g_autofree char *uri = NULL;
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);
data = g_new0 (NautilusRenameData, 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) nautilus_rename_data_free);
/* Start the timed wait to cancel the rename. */
truncated_old_name = get_truncated_name_for_file (file);
truncated_new_name = eel_str_middle_truncate (new_name, MAXIMUM_DISPLAYED_FILE_NAME_LENGTH);
wait_message = g_strdup_printf (_("Renaming “%s” to “%s”."),
truncated_old_name,
truncated_new_name);
eel_timed_wait_start (cancel_rename_callback, file, wait_message,
NULL); /* FIXME bugzilla.gnome.org 42395: Parent this? */
uri = nautilus_file_get_uri (file);
DEBUG ("Renaming file %s to %s", uri, new_name);
/* Start the rename. */
nautilus_file_rename (file, new_name,
rename_callback, NULL);
}
static void
nautilus_canvas_view_container_prioritize_thumbnailing (NautilusCanvasContainer *container,
NautilusCanvasIconData *data)
{
NautilusFile *file;
char *uri;
file = (NautilusFile *) data;
g_assert (NAUTILUS_IS_FILE (file));
if (nautilus_file_is_thumbnailing (file)) {
uri = nautilus_file_get_uri (file);
nautilus_thumbnail_prioritize (uri);
g_free (uri);
}
}
static void
nautilus_canvas_view_container_start_monitor_top_left (NautilusCanvasContainer *container,
NautilusCanvasIconData *data,
gconstpointer client,
gboolean large_text)
{
NautilusFile *file;
NautilusFileAttributes attributes;
file = (NautilusFile *) data;
g_assert (NAUTILUS_IS_FILE (file));
attributes = NAUTILUS_FILE_ATTRIBUTE_TOP_LEFT_TEXT;
if (large_text) {
attributes |= NAUTILUS_FILE_ATTRIBUTE_LARGE_TOP_LEFT_TEXT;
}
nautilus_file_monitor_add (file, client, attributes);
}
static void
query_editor_changed_callback (NautilusSearchBar *bar,
NautilusQuery *query,
gboolean reload,
NautilusWindowSlot *slot)
{
NautilusDirectory *directory;
g_assert (NAUTILUS_IS_FILE (slot->viewed_file));
directory = nautilus_directory_get_for_file (slot->viewed_file);
g_assert (NAUTILUS_IS_SEARCH_DIRECTORY (directory));
nautilus_search_directory_set_query (NAUTILUS_SEARCH_DIRECTORY (directory),
query);
if (reload) {
nautilus_window_slot_reload (slot);
}
nautilus_directory_unref (directory);
}
static void
query_editor_changed_callback (NautilusQueryEditor *editor,
NautilusQuery *query,
gboolean reload,
NautilusWindowSlot *slot)
{
NautilusDirectory *directory;
g_assert (NAUTILUS_IS_FILE (slot->viewed_file));
directory = nautilus_directory_get_for_file (slot->viewed_file);
if (!NAUTILUS_IS_SEARCH_DIRECTORY (directory)) {
/* this is the first change from the query editor. we
ask for a location change to the search directory,
indicate the directory needs to be sync'd with the
current query. */
create_new_search (slot);
} else {
sync_search_directory (slot);
}
nautilus_directory_unref (directory);
}
gboolean
nautilus_drag_can_accept_items (NautilusFile *drop_target_item,
const GList *items)
{
int max;
if (drop_target_item == NULL)
return FALSE;
g_assert (NAUTILUS_IS_FILE (drop_target_item));
/* Iterate through selection checking if item will get accepted by the
* drop target. If more than 100 items selected, return an over-optimisic
* result
*/
for (max = 100; items != NULL && max >= 0; items = items->next, max--) {
if (!nautilus_drag_can_accept_item (drop_target_item,
((NautilusDragSelectionItem *)items->data)->uri)) {
return FALSE;
}
}
return TRUE;
}
/* key routine that hooks up a background and location */
void
nautilus_connect_background_to_file_metadata (GtkWidget *widget,
NautilusFile *file,
GdkDragAction default_drag_action)
{
EelBackground *background;
gpointer old_file;
/* Get at the background object we'll be connecting. */
background = eel_get_widget_background (widget);
/* Check if it is already connected. */
old_file = g_object_get_data (G_OBJECT (background), "eel_background_file");
if (old_file == file) {
return;
}
/* Disconnect old signal handlers. */
if (old_file != NULL) {
g_assert (NAUTILUS_IS_FILE (old_file));
g_signal_handlers_disconnect_by_func
(background,
G_CALLBACK (background_changed_callback), old_file);
g_signal_handlers_disconnect_by_func
(background,
G_CALLBACK (background_destroyed_callback), old_file);
g_signal_handlers_disconnect_by_func
(background,
G_CALLBACK (background_reset_callback), old_file);
g_signal_handlers_disconnect_by_func
(old_file,
G_CALLBACK (saved_settings_changed_callback), background);
nautilus_file_monitor_remove (old_file, background);
eel_preferences_remove_callback (NAUTILUS_PREFERENCES_THEME,
nautilus_file_background_theme_changed,
background);
eel_preferences_remove_callback (NAUTILUS_PREFERENCES_BACKGROUND_SET,
nautilus_file_background_theme_changed,
background);
eel_preferences_remove_callback (NAUTILUS_PREFERENCES_BACKGROUND_COLOR,
nautilus_file_background_theme_changed,
background);
eel_preferences_remove_callback (NAUTILUS_PREFERENCES_BACKGROUND_FILENAME,
nautilus_file_background_theme_changed,
background);
}
/* Attach the new directory. */
nautilus_file_ref (file);
g_object_set_data_full (G_OBJECT (background), "eel_background_file",
file, (GDestroyNotify) nautilus_file_unref);
g_object_set_data (G_OBJECT (background), "default_drag_action", GINT_TO_POINTER (default_drag_action));
/* Connect new signal handlers. */
if (file != NULL) {
g_signal_connect_object (background, "settings_changed",
G_CALLBACK (background_changed_callback), file, 0);
g_signal_connect_object (background, "destroy",
G_CALLBACK (background_destroyed_callback), file, 0);
g_signal_connect_object (background, "reset",
G_CALLBACK (background_reset_callback), file, 0);
g_signal_connect_object (file, "changed",
G_CALLBACK (saved_settings_changed_callback), background, 0);
/* arrange to receive file metadata */
nautilus_file_monitor_add (file,
background,
NAUTILUS_FILE_ATTRIBUTE_INFO);
/* arrange for notification when the theme changes */
eel_preferences_add_callback (NAUTILUS_PREFERENCES_THEME,
nautilus_file_background_theme_changed, background);
eel_preferences_add_callback (NAUTILUS_PREFERENCES_BACKGROUND_SET,
nautilus_file_background_theme_changed, background);
eel_preferences_add_callback (NAUTILUS_PREFERENCES_BACKGROUND_COLOR,
nautilus_file_background_theme_changed, background);
eel_preferences_add_callback (NAUTILUS_PREFERENCES_BACKGROUND_FILENAME,
nautilus_file_background_theme_changed, background);
}
/* Update the background based on the file metadata. */
initialize_background_from_settings (file, background);
}
/* handle the background changed signal */
static void
background_changed_callback (EelBackground *background,
GdkDragAction action,
NautilusFile *file)
{
char *color;
char *image;
g_assert (EEL_IS_BACKGROUND (background));
g_assert (NAUTILUS_IS_FILE (file));
g_assert (g_object_get_data (G_OBJECT (background), "eel_background_file") == file);
color = eel_background_get_color (background);
image = eel_background_get_image_uri (background);
if (eel_background_is_desktop (background)) {
eel_background_save_to_gconf (background);
} else {
/* Block the other handler while we are writing metadata so it doesn't
* try to change the background.
*/
g_signal_handlers_block_by_func (
file, G_CALLBACK (saved_settings_changed_callback), background);
if (action != NAUTILUS_DND_ACTION_SET_AS_FOLDER_BACKGROUND && action != NAUTILUS_DND_ACTION_SET_AS_GLOBAL_BACKGROUND) {
GdkDragAction default_drag_action;
default_drag_action = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (background), "default_drag_action"));
action = default_drag_action;
}
if (action == NAUTILUS_DND_ACTION_SET_AS_GLOBAL_BACKGROUND) {
nautilus_file_set_metadata (file,
NAUTILUS_METADATA_KEY_LOCATION_BACKGROUND_COLOR,
NULL,
NULL);
nautilus_file_set_metadata (file,
NAUTILUS_METADATA_KEY_LOCATION_BACKGROUND_IMAGE,
NULL,
NULL);
eel_preferences_set
(NAUTILUS_PREFERENCES_BACKGROUND_COLOR, color ? color : "");
eel_preferences_set
(NAUTILUS_PREFERENCES_BACKGROUND_FILENAME, image ? image : "");
eel_preferences_set_boolean
(NAUTILUS_PREFERENCES_BACKGROUND_SET, TRUE);
} else {
nautilus_file_set_metadata (file,
NAUTILUS_METADATA_KEY_LOCATION_BACKGROUND_COLOR,
NULL,
color);
nautilus_file_set_metadata (file,
NAUTILUS_METADATA_KEY_LOCATION_BACKGROUND_IMAGE,
NULL,
image);
}
/* Unblock the handler. */
g_signal_handlers_unblock_by_func (
file, G_CALLBACK (saved_settings_changed_callback), background);
}
g_free (color);
g_free (image);
}
static NautilusIconInfo *
nautilus_canvas_view_container_get_icon_images (NautilusCanvasContainer *container,
NautilusCanvasIconData *data,
int size,
char **embedded_text,
gboolean for_drag_accept,
gboolean need_large_embeddded_text,
gboolean *embedded_text_needs_loading,
gboolean *has_window_open)
{
NautilusCanvasView *canvas_view;
NautilusFile *file;
gboolean use_embedding;
NautilusFileIconFlags flags;
NautilusIconInfo *icon_info;
GdkPixbuf *pixbuf;
GIcon *emblemed_icon;
GEmblem *emblem;
GList *emblem_icons, *l;
file = (NautilusFile *) data;
g_assert (NAUTILUS_IS_FILE (file));
canvas_view = get_canvas_view (container);
g_return_val_if_fail (canvas_view != NULL, NULL);
use_embedding = FALSE;
if (embedded_text) {
*embedded_text = nautilus_file_peek_top_left_text (file, need_large_embeddded_text, embedded_text_needs_loading);
use_embedding = *embedded_text != NULL;
}
*has_window_open = nautilus_file_has_open_window (file);
flags = NAUTILUS_FILE_ICON_FLAGS_USE_MOUNT_ICON_AS_EMBLEM |
NAUTILUS_FILE_ICON_FLAGS_USE_THUMBNAILS;
if (use_embedding) {
flags |= NAUTILUS_FILE_ICON_FLAGS_EMBEDDING_TEXT;
}
if (for_drag_accept) {
flags |= NAUTILUS_FILE_ICON_FLAGS_FOR_DRAG_ACCEPT;
}
icon_info = nautilus_file_get_icon (file, size, flags);
emblem_icons = nautilus_file_get_emblem_icons (file);
/* apply emblems */
if (emblem_icons != NULL) {
l = emblem_icons;
emblem = g_emblem_new (l->data);
pixbuf = nautilus_icon_info_get_pixbuf (icon_info);
emblemed_icon = g_emblemed_icon_new (G_ICON (pixbuf), emblem);
g_object_unref (emblem);
for (l = l->next; l != NULL; l = l->next) {
emblem = g_emblem_new (l->data);
g_emblemed_icon_add_emblem (G_EMBLEMED_ICON (emblemed_icon),
emblem);
g_object_unref (emblem);
}
g_clear_object (&icon_info);
icon_info = nautilus_icon_info_lookup (emblemed_icon, size);
g_object_unref (pixbuf);
g_object_unref (emblemed_icon);
}
if (emblem_icons != NULL) {
g_list_free_full (emblem_icons, g_object_unref);
}
return icon_info;
}
/* 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]);
}
}
}
