static gboolean
iter_is_valid (FMTreeModel *model, const GtkTreeIter *iter)
{
TreeNode *node, *parent;
if (iter->stamp != model->details->stamp) {
return FALSE;
}
node = iter->user_data;
parent = iter->user_data2;
if (node == NULL) {
if (parent != NULL) {
if (!NEMO_IS_FILE (parent->file)) {
return FALSE;
}
if (!tree_node_has_dummy_child (parent)) {
return FALSE;
}
}
} else {
if (!NEMO_IS_FILE (node->file)) {
return FALSE;
}
if (parent != NULL) {
return FALSE;
}
}
if (iter->user_data3 != NULL) {
return FALSE;
}
return TRUE;
}
static void
query_editor_changed_callback (NemoQueryEditor *editor,
NemoQuery *query,
gboolean reload,
NemoWindowSlot *slot)
{
NemoDirectory *directory;
g_assert (NEMO_IS_FILE (slot->viewed_file));
directory = nemo_directory_get_for_file (slot->viewed_file);
if (!NEMO_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);
/* Focus is now on the new slot, move it back to query_editor */
gtk_widget_grab_focus (GTK_WIDGET (slot->query_editor));
} else {
sync_search_directory (slot);
}
nemo_directory_unref (directory);
}
void
nemo_directory_remove_file (NemoDirectory *directory, NemoFile *file)
{
GList *node;
g_assert (NEMO_IS_DIRECTORY (directory));
g_assert (NEMO_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);
nemo_directory_remove_file_from_work_queue (directory, file);
if (!file->details->unconfirmed) {
directory->details->confirmed_file_count--;
}
/* Unref if we are monitoring. */
if (nemo_directory_is_file_list_monitored (directory)) {
nemo_file_unref (file);
}
}
void
nemo_directory_add_file (NemoDirectory *directory, NemoFile *file)
{
GList *node;
gboolean add_to_work_queue;
g_assert (NEMO_IS_DIRECTORY (directory));
g_assert (NEMO_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 (nemo_directory_is_file_list_monitored (directory)) {
/* Ref if we are monitoring, since monitoring owns the file list. */
nemo_file_ref (file);
add_to_work_queue = TRUE;
} else if (nemo_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) {
nemo_directory_add_file_to_work_queue (directory, file);
}
}
static void
nemo_icon_view_container_stop_monitor_top_left (NemoIconContainer *container,
NemoIconData *data,
gconstpointer client)
{
NemoFile *file;
file = (NemoFile *) data;
g_assert (NEMO_IS_FILE (file));
nemo_file_monitor_remove (file, client);
}
NemoDirectory *
nemo_directory_get_for_file (NemoFile *file)
{
char *uri;
NemoDirectory *directory;
g_return_val_if_fail (NEMO_IS_FILE (file), NULL);
uri = nemo_file_get_uri (file);
directory = nemo_directory_get_by_uri (uri);
g_free (uri);
return directory;
}
gboolean
nemo_directory_contains_file (NemoDirectory *directory,
NemoFile *file)
{
g_return_val_if_fail (NEMO_IS_DIRECTORY (directory), FALSE);
g_return_val_if_fail (NEMO_IS_FILE (file), FALSE);
if (nemo_file_is_gone (file)) {
return FALSE;
}
return NEMO_DIRECTORY_CLASS (G_OBJECT_GET_CLASS (directory))->contains_file (directory, file);
}
static void
nemo_icon_view_container_prioritize_thumbnailing (NemoIconContainer *container,
NemoIconData *data)
{
NemoFile *file;
char *uri;
file = (NemoFile *) data;
g_assert (NEMO_IS_FILE (file));
if (nemo_file_is_thumbnailing (file)) {
uri = nemo_file_get_uri (file);
nemo_thumbnail_prioritize (uri);
g_free (uri);
}
}
static void
nemo_icon_view_container_start_monitor_top_left (NemoIconContainer *container,
NemoIconData *data,
gconstpointer client,
gboolean large_text)
{
NemoFile *file;
NemoFileAttributes attributes;
file = (NemoFile *) data;
g_assert (NEMO_IS_FILE (file));
attributes = NEMO_FILE_ATTRIBUTE_TOP_LEFT_TEXT;
if (large_text) {
attributes |= NEMO_FILE_ATTRIBUTE_LARGE_TOP_LEFT_TEXT;
}
nemo_file_monitor_add (file, client, attributes);
}
static void
sync_search_directory (NemoWindowSlot *slot)
{
NemoDirectory *directory;
NemoQuery *query;
g_assert (NEMO_IS_FILE (slot->viewed_file));
directory = nemo_directory_get_for_file (slot->viewed_file);
g_assert (NEMO_IS_SEARCH_DIRECTORY (directory));
query = nemo_query_editor_get_query (slot->query_editor);
nemo_search_directory_set_query (NEMO_SEARCH_DIRECTORY (directory),
query);
g_object_unref (query);
nemo_window_slot_reload (slot);
nemo_directory_unref (directory);
}
static char *
nemo_icon_view_container_get_icon_description (NemoIconContainer *container,
NemoIconData *data)
{
NemoFile *file;
char *mime_type;
const char *description;
file = NEMO_FILE (data);
g_assert (NEMO_IS_FILE (file));
if (NEMO_IS_DESKTOP_ICON_FILE (file)) {
return NULL;
}
mime_type = nemo_file_get_mime_type (file);
description = g_content_type_get_description (mime_type);
g_free (mime_type);
return g_strdup (description);
}
gboolean
nemo_drag_can_accept_items (NemoFile *drop_target_item,
const GList *items)
{
int max;
if (drop_target_item == NULL)
return FALSE;
g_assert (NEMO_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 (!nemo_drag_can_accept_item (drop_target_item,
((NemoDragSelectionItem *)items->data)->uri)) {
return FALSE;
}
}
return TRUE;
}
static NemoIconInfo *
nemo_icon_view_container_get_icon_images (NemoIconContainer *container,
NemoIconData *data,
int size,
char **embedded_text,
gboolean for_drag_accept,
gboolean need_large_embeddded_text,
gboolean *embedded_text_needs_loading,
gboolean *has_window_open)
{
NemoIconView *icon_view;
char **emblems_to_ignore;
NemoFile *file;
NemoFileIconFlags flags;
NemoIconInfo *icon_info;
GdkPixbuf *pixbuf;
GIcon *emblemed_icon;
GEmblem *emblem;
GList *emblem_icons, *l;
gint scale;
file = (NemoFile *) data;
g_assert (NEMO_IS_FILE (file));
icon_view = get_icon_view (container);
g_return_val_if_fail (icon_view != NULL, NULL);
*has_window_open = nemo_file_has_open_window (file);
flags = NEMO_FILE_ICON_FLAGS_USE_MOUNT_ICON_AS_EMBLEM |
NEMO_FILE_ICON_FLAGS_USE_THUMBNAILS;
if (for_drag_accept) {
flags |= NEMO_FILE_ICON_FLAGS_FOR_DRAG_ACCEPT;
}
emblems_to_ignore = nemo_view_get_emblem_names_to_exclude
(NEMO_VIEW (icon_view));
emblem_icons = nemo_file_get_emblem_icons (file,
emblems_to_ignore);
g_strfreev (emblems_to_ignore);
scale = gtk_widget_get_scale_factor (GTK_WIDGET (icon_view));
icon_info = nemo_file_get_icon (file, size, scale, flags);
/* apply emblems */
if (emblem_icons != NULL) {
l = emblem_icons;
pixbuf = nemo_icon_info_get_pixbuf (icon_info);
gint w, h, s;
gboolean bad_ratio;
w = gdk_pixbuf_get_width (pixbuf);
h = gdk_pixbuf_get_height (pixbuf);
s = MAX (w, h);
if (s < size)
size = s;
bad_ratio = nemo_icon_get_emblem_size_for_icon_size (size) * scale > w ||
nemo_icon_get_emblem_size_for_icon_size (size) * scale > h;
if (bad_ratio)
goto skip_emblem; /* Would prefer to not use goto, but
* I don't want to do these checks on
* non-emblemed icons (the majority)
* as it would be too costly */
emblem = g_emblem_new (l->data);
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 = nemo_icon_info_lookup (emblemed_icon, size, scale);
g_object_unref (emblemed_icon);
skip_emblem:
g_object_unref (pixbuf);
}
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
nemo_icon_view_container_get_icon_text (NemoIconContainer *container,
NemoIconData *data,
char **editable_text,
char **additional_text,
gboolean include_invisible)
{
GQuark *attributes;
char *text_array[4];
int i, j, num_attributes;
NemoIconView *icon_view;
NemoFile *file;
gboolean use_additional;
file = NEMO_FILE (data);
g_assert (NEMO_IS_FILE (file));
g_assert (editable_text != NULL);
icon_view = get_icon_view (container);
g_return_if_fail (icon_view != NULL);
use_additional = (additional_text != NULL);
/* In the smallest zoom mode, no text is drawn. */
if (nemo_icon_container_get_zoom_level (container) == NEMO_ZOOM_LEVEL_SMALLEST &&
!include_invisible) {
*editable_text = NULL;
} else {
/* Strip the suffix for nemo object xml files. */
*editable_text = nemo_file_get_display_name (file);
}
if (!use_additional) {
return;
}
if (nemo_icon_view_is_compact (icon_view)) {
*additional_text = NULL;
return;
}
if (NEMO_IS_DESKTOP_ICON_FILE (file) ||
nemo_file_is_nemo_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 = nemo_icon_view_container_get_icon_text_attribute_names (container,
&num_attributes);
/* Get the attributes. */
j = 0;
for (i = 0; i < num_attributes; ++i) {
if (attributes[i] == attribute_none_q) {
continue;
}
text_array[j++] =
nemo_file_get_string_attribute_with_default_q (file, attributes[i]);
}
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]);
}
}
}
