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]); } } }