mirror of
https://gitlab.gnome.org/GNOME/nautilus
synced 2024-09-19 15:51:40 +00:00
7295589544
from all volumes). Some loose ends are already reported in bugs 2146, 2243, and 2244. * libnautilus-extensions/Makefile.am: * libnautilus-extensions/nautilus-merged-directory.h: * libnautilus-extensions/nautilus-merged-directory.c: Moved all the guts of NautilusTrashDirectory that are solely about having a single directory that's a union of a bunch of real directories into a separate base class. Also finished the implementation, leaving only unimportant loose ends. * libnautilus-extensions/nautilus-trash-directory.h: * libnautilus-extensions/nautilus-trash-directory.c: (get_volume_vfs_uri_if_writable), (find_directory_callback), (add_volume), (remove_trash_volume), (remove_volume), (add_one_volume), (volume_mounted_callback), (volume_unmounted_callback), (nautilus_trash_directory_initialize), (remove_trash_volume_cover), (trash_destroy), (nautilus_trash_directory_initialize_class): Added the code to find the trash on all volumes. * libnautilus-extensions/nautilus-glib-extensions.h: * libnautilus-extensions/nautilus-glib-extensions.c: (flatten_hash_table_element), (nautilus_g_hash_table_safe_for_each): Added a new version of the hash table iterator that works even if the callback removes items from the hash table. * libnautilus-extensions/nautilus-scalable-font.c: (nautilus_scalable_font_largest_fitting_font_size): Added code to handle the case of an empty name; the old code worked with NULL, but not with "". * src/file-manager/fm-desktop-icon-view.c: (fm_desktop_icon_view_trash_state_changed_callback), (find_and_rename_trash_link), (create_or_rename_trash): * src/file-manager/nautilus-trash-monitor.c: (nautilus_trash_monitor_initialize): Changed to use the new "trash:" URL instead of locating one of the trash folders. * src/file-manager/fm-directory-view.h: * src/file-manager/fm-directory-view.c: (fm_directory_view_initialize_class), (fm_directory_all_selected_items_in_trash): * src/file-manager/fm-search-list-view.c: (fm_search_list_view_initialize_class): The "share_parent" optimization didn't work for the new trash. Instead of fixing it, I just removed it. * src/nautilus-window-manage-views.c: (compute_default_title), (nautilus_window_update_title): Made two changes to the default title: 1) Use "" instead of "Nautilus" when there's no title. We still use "Nautilus" in the window title, but not in the sidebar any more. 2) Use the scheme part of a URI if there's nothing after the colon. This works nicely for the trash. * libnautilus-extensions/nautilus-background-canvas-group.c: (nautilus_background_canvas_group_render): Removed some unneeded code and the FIXME that goes with it. * libnautilus-extensions/nautilus-directory.c: (nautilus_directory_is_not_empty): Removed an overzealous assert.
554 lines
16 KiB
C
554 lines
16 KiB
C
/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*-
|
|
|
|
nautilus-merged-directory.c: Subclass of NautilusDirectory to implement the
|
|
virtual merged directory.
|
|
|
|
Copyright (C) 1999, 2000 Eazel, Inc.
|
|
|
|
This program is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU General Public License as
|
|
published by the Free Software Foundation; either version 2 of the
|
|
License, or (at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public
|
|
License along with this program; if not, write to the
|
|
Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
Boston, MA 02111-1307, USA.
|
|
|
|
Author: Darin Adler <darin@eazel.com>
|
|
*/
|
|
|
|
#include <config.h>
|
|
#include "nautilus-merged-directory.h"
|
|
|
|
#include "nautilus-directory-private.h"
|
|
#include "nautilus-file.h"
|
|
#include "nautilus-glib-extensions.h"
|
|
#include "nautilus-gtk-macros.h"
|
|
#include <gtk/gtksignal.h>
|
|
|
|
struct NautilusMergedDirectoryDetails {
|
|
GList *directories;
|
|
GHashTable *callbacks;
|
|
GHashTable *monitors;
|
|
};
|
|
|
|
typedef struct {
|
|
/* Basic configuration. */
|
|
NautilusMergedDirectory *merged;
|
|
NautilusDirectoryCallback callback;
|
|
gpointer callback_data;
|
|
|
|
GList *wait_for_attributes;
|
|
gboolean wait_for_metadata;
|
|
|
|
GList *non_ready_directories;
|
|
GList *merged_file_list;
|
|
} MergedCallback;
|
|
|
|
typedef struct {
|
|
NautilusMergedDirectory *merged;
|
|
|
|
GList *monitor_attributes;
|
|
gboolean monitor_metadata;
|
|
gboolean force_reload;
|
|
} MergedMonitor;
|
|
|
|
static void nautilus_merged_directory_initialize (gpointer object,
|
|
gpointer klass);
|
|
static void nautilus_merged_directory_initialize_class (gpointer klass);
|
|
static void remove_all_real_directories (NautilusMergedDirectory *merged);
|
|
static guint merged_callback_hash (gconstpointer merged_callback);
|
|
static gboolean merged_callback_equal (gconstpointer merged_callback,
|
|
gconstpointer merged_callback_2);
|
|
|
|
NAUTILUS_DEFINE_CLASS_BOILERPLATE (NautilusMergedDirectory,
|
|
nautilus_merged_directory,
|
|
NAUTILUS_TYPE_DIRECTORY)
|
|
|
|
static void
|
|
nautilus_merged_directory_initialize (gpointer object, gpointer klass)
|
|
{
|
|
NautilusMergedDirectory *merged;
|
|
|
|
merged = NAUTILUS_MERGED_DIRECTORY (object);
|
|
|
|
merged->details = g_new0 (NautilusMergedDirectoryDetails, 1);
|
|
merged->details->callbacks = g_hash_table_new
|
|
(merged_callback_hash, merged_callback_equal);
|
|
merged->details->monitors = g_hash_table_new
|
|
(g_direct_hash, g_direct_equal);
|
|
}
|
|
|
|
static void
|
|
merged_destroy (GtkObject *object)
|
|
{
|
|
NautilusMergedDirectory *merged;
|
|
|
|
merged = NAUTILUS_MERGED_DIRECTORY (object);
|
|
|
|
remove_all_real_directories (merged);
|
|
|
|
if (g_hash_table_size (merged->details->callbacks) != 0) {
|
|
g_warning ("call_when_ready still pending when merged virtual directory is destroyed");
|
|
}
|
|
if (g_hash_table_size (merged->details->monitors) != 0) {
|
|
g_warning ("file monitor still active when merged virtual directory is destroyed");
|
|
}
|
|
|
|
g_hash_table_destroy (merged->details->callbacks);
|
|
g_hash_table_destroy (merged->details->monitors);
|
|
g_free (merged->details);
|
|
|
|
NAUTILUS_CALL_PARENT_CLASS (GTK_OBJECT_CLASS, destroy, (object));
|
|
}
|
|
|
|
static guint
|
|
merged_callback_hash (gconstpointer merged_callback_as_pointer)
|
|
{
|
|
const MergedCallback *merged_callback;
|
|
|
|
merged_callback = merged_callback_as_pointer;
|
|
return GPOINTER_TO_UINT (merged_callback->callback)
|
|
^ GPOINTER_TO_UINT (merged_callback->callback_data);
|
|
}
|
|
|
|
static gboolean
|
|
merged_callback_equal (gconstpointer merged_callback_as_pointer,
|
|
gconstpointer merged_callback_as_pointer_2)
|
|
{
|
|
const MergedCallback *merged_callback, *merged_callback_2;
|
|
|
|
merged_callback = merged_callback_as_pointer;
|
|
merged_callback_2 = merged_callback_as_pointer_2;
|
|
|
|
return merged_callback->callback == merged_callback_2->callback
|
|
&& merged_callback->callback_data == merged_callback_2->callback_data;
|
|
}
|
|
|
|
/* Return true if any directory in the list does. */
|
|
static gboolean
|
|
merged_contains_file (NautilusDirectory *directory,
|
|
NautilusFile *file)
|
|
{
|
|
NautilusMergedDirectory *merged;
|
|
GList *p;
|
|
|
|
merged = NAUTILUS_MERGED_DIRECTORY (directory);
|
|
|
|
for (p = merged->details->directories; p != NULL; p = p->next) {
|
|
if (nautilus_directory_contains_file (p->data, file)) {
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
static void
|
|
merged_callback_destroy (MergedCallback *merged_callback)
|
|
{
|
|
g_assert (merged_callback != NULL);
|
|
g_assert (NAUTILUS_IS_MERGED_DIRECTORY (merged_callback->merged));
|
|
|
|
nautilus_g_list_free_deep (merged_callback->wait_for_attributes);
|
|
g_list_free (merged_callback->non_ready_directories);
|
|
nautilus_file_list_free (merged_callback->merged_file_list);
|
|
g_free (merged_callback);
|
|
}
|
|
|
|
static void
|
|
merged_callback_check_done (MergedCallback *merged_callback)
|
|
{
|
|
/* Check if we are ready. */
|
|
if (merged_callback->non_ready_directories != NULL) {
|
|
return;
|
|
}
|
|
|
|
/* Remove from the hash table before sending it. */
|
|
g_hash_table_remove (merged_callback->merged->details->callbacks, merged_callback);
|
|
|
|
/* We are ready, so do the real callback. */
|
|
(* merged_callback->callback) (NAUTILUS_DIRECTORY (merged_callback->merged),
|
|
merged_callback->merged_file_list,
|
|
merged_callback->callback_data);
|
|
|
|
/* And we are done. */
|
|
merged_callback_destroy (merged_callback);
|
|
}
|
|
|
|
static void
|
|
merged_callback_remove_directory (MergedCallback *merged_callback,
|
|
NautilusDirectory *directory)
|
|
{
|
|
merged_callback->non_ready_directories = g_list_remove
|
|
(merged_callback->non_ready_directories,
|
|
directory);
|
|
|
|
/* Check if we are ready. */
|
|
merged_callback_check_done (merged_callback);
|
|
}
|
|
|
|
static void
|
|
directory_ready_callback (NautilusDirectory *directory,
|
|
GList *files,
|
|
gpointer callback_data)
|
|
{
|
|
MergedCallback *merged_callback;
|
|
|
|
g_assert (NAUTILUS_IS_DIRECTORY (directory));
|
|
g_assert (callback_data != NULL);
|
|
|
|
merged_callback = callback_data;
|
|
g_assert (g_list_find (merged_callback->non_ready_directories, directory) != NULL);
|
|
|
|
/* Update based on this call. */
|
|
merged_callback->merged_file_list = g_list_concat
|
|
(merged_callback->merged_file_list,
|
|
nautilus_file_list_copy (files));
|
|
|
|
/* Check if we are ready. */
|
|
merged_callback_remove_directory (merged_callback,
|
|
directory);
|
|
}
|
|
|
|
static void
|
|
merged_callback_connect_directory (MergedCallback *merged_callback,
|
|
NautilusDirectory *real_merged)
|
|
{
|
|
nautilus_directory_call_when_ready
|
|
(real_merged,
|
|
merged_callback->wait_for_attributes,
|
|
merged_callback->wait_for_metadata,
|
|
directory_ready_callback, merged_callback);
|
|
}
|
|
|
|
static void
|
|
merged_call_when_ready (NautilusDirectory *directory,
|
|
GList *file_attributes,
|
|
gboolean wait_for_metadata,
|
|
NautilusDirectoryCallback callback,
|
|
gpointer callback_data)
|
|
{
|
|
NautilusMergedDirectory *merged;
|
|
MergedCallback search_key, *merged_callback;
|
|
GList *p;
|
|
|
|
merged = NAUTILUS_MERGED_DIRECTORY (directory);
|
|
|
|
/* Check to be sure we aren't overwriting. */
|
|
search_key.callback = callback;
|
|
search_key.callback_data = callback_data;
|
|
if (g_hash_table_lookup (merged->details->callbacks, &search_key) != NULL) {
|
|
g_warning ("tried to add a new callback while an old one was pending");
|
|
return;
|
|
}
|
|
|
|
/* Create a merged_callback record. */
|
|
merged_callback = g_new0 (MergedCallback, 1);
|
|
merged_callback->merged = merged;
|
|
merged_callback->callback = callback;
|
|
merged_callback->callback_data = callback_data;
|
|
merged_callback->wait_for_attributes = nautilus_g_str_list_copy (file_attributes);
|
|
merged_callback->wait_for_metadata = wait_for_metadata;
|
|
for (p = merged->details->directories; p != NULL; p = p->next) {
|
|
merged_callback->non_ready_directories = g_list_prepend
|
|
(merged_callback->non_ready_directories, p->data);
|
|
}
|
|
|
|
/* Put it in the hash table. */
|
|
g_hash_table_insert (merged->details->callbacks,
|
|
merged_callback, merged_callback);
|
|
|
|
/* Handle the pathological case where there are no directories. */
|
|
if (merged->details->directories == NULL) {
|
|
merged_callback_check_done (merged_callback);
|
|
}
|
|
|
|
/* Now tell all the directories about it. */
|
|
for (p = merged->details->directories; p != NULL; p = p->next) {
|
|
merged_callback_connect_directory (merged_callback, p->data);
|
|
}
|
|
}
|
|
|
|
static void
|
|
merged_cancel_callback (NautilusDirectory *directory,
|
|
NautilusDirectoryCallback callback,
|
|
gpointer callback_data)
|
|
{
|
|
NautilusMergedDirectory *merged;
|
|
MergedCallback search_key, *merged_callback;
|
|
GList *p;
|
|
|
|
merged = NAUTILUS_MERGED_DIRECTORY (directory);
|
|
|
|
/* Find the entry in the table. */
|
|
search_key.callback = callback;
|
|
search_key.callback_data = callback_data;
|
|
merged_callback = g_hash_table_lookup (merged->details->callbacks, &search_key);
|
|
if (merged_callback == NULL) {
|
|
return;
|
|
}
|
|
|
|
/* Remove from the hash table before working with it. */
|
|
g_hash_table_remove (merged_callback->merged->details->callbacks, merged_callback);
|
|
|
|
/* Tell all the directories to cancel the call. */
|
|
for (p = merged_callback->non_ready_directories; p != NULL; p = p->next) {
|
|
nautilus_directory_cancel_callback
|
|
(p->data,
|
|
directory_ready_callback, merged_callback);
|
|
}
|
|
merged_callback_destroy (merged_callback);
|
|
}
|
|
|
|
/* Create a monitor on each of the directories in the list. */
|
|
static void
|
|
merged_file_monitor_add (NautilusDirectory *directory,
|
|
gconstpointer client,
|
|
GList *file_attributes,
|
|
gboolean monitor_metadata,
|
|
gboolean force_reload)
|
|
{
|
|
NautilusMergedDirectory *merged;
|
|
MergedMonitor *monitor;
|
|
GList *p;
|
|
|
|
merged = NAUTILUS_MERGED_DIRECTORY (directory);
|
|
|
|
/* Map the client to a unique value so this doesn't interfere
|
|
* with direct monitoring of the directory by the same client.
|
|
*/
|
|
monitor = g_hash_table_lookup (merged->details->monitors, client);
|
|
if (monitor != NULL) {
|
|
g_assert (monitor->merged == merged);
|
|
nautilus_g_list_free_deep (monitor->monitor_attributes);
|
|
} else {
|
|
monitor = g_new0 (MergedMonitor, 1);
|
|
monitor->merged = merged;
|
|
g_hash_table_insert (merged->details->monitors,
|
|
(gpointer) client, monitor);
|
|
}
|
|
monitor->monitor_attributes = nautilus_g_str_list_copy (file_attributes);
|
|
monitor->monitor_metadata = monitor_metadata;
|
|
monitor->force_reload = force_reload;
|
|
|
|
/* Call through to the real directory add calls. */
|
|
for (p = merged->details->directories; p != NULL; p = p->next) {
|
|
nautilus_directory_file_monitor_add
|
|
(p->data, monitor,
|
|
file_attributes, monitor_metadata, force_reload);
|
|
}
|
|
}
|
|
|
|
/* Remove the monitor from each of the directories in the list. */
|
|
static void
|
|
merged_file_monitor_remove (NautilusDirectory *directory,
|
|
gconstpointer client)
|
|
{
|
|
NautilusMergedDirectory *merged;
|
|
MergedMonitor *monitor;
|
|
GList *p;
|
|
|
|
merged = NAUTILUS_MERGED_DIRECTORY (directory);
|
|
|
|
/* Map the client to the value used by the earlier add call. */
|
|
monitor = g_hash_table_lookup (merged->details->monitors, client);
|
|
if (monitor == NULL) {
|
|
return;
|
|
}
|
|
g_hash_table_remove (merged->details->monitors, client);
|
|
|
|
/* Call through to the real directory remove calls. */
|
|
for (p = merged->details->directories; p != NULL; p = p->next) {
|
|
nautilus_directory_file_monitor_remove
|
|
(p->data, monitor);
|
|
}
|
|
|
|
nautilus_g_list_free_deep (monitor->monitor_attributes);
|
|
g_free (monitor);
|
|
}
|
|
|
|
/* Return true only if all directories in the list do. */
|
|
static gboolean
|
|
merged_are_all_files_seen (NautilusDirectory *directory)
|
|
{
|
|
NautilusMergedDirectory *merged;
|
|
GList *p;
|
|
|
|
merged = NAUTILUS_MERGED_DIRECTORY (directory);
|
|
|
|
for (p = merged->details->directories; p != NULL; p = p->next) {
|
|
if (!nautilus_directory_are_all_files_seen (p->data)) {
|
|
return FALSE;
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
/* Return true if any directory in the list does. */
|
|
static gboolean
|
|
merged_is_not_empty (NautilusDirectory *directory)
|
|
{
|
|
NautilusMergedDirectory *merged;
|
|
GList *p;
|
|
|
|
merged = NAUTILUS_MERGED_DIRECTORY (directory);
|
|
|
|
for (p = merged->details->directories; p != NULL; p = p->next) {
|
|
if (nautilus_directory_is_not_empty (p->data)) {
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
static void
|
|
nautilus_merged_directory_initialize_class (gpointer klass)
|
|
{
|
|
GtkObjectClass *object_class;
|
|
NautilusDirectoryClass *directory_class;
|
|
|
|
object_class = GTK_OBJECT_CLASS (klass);
|
|
directory_class = NAUTILUS_DIRECTORY_CLASS (klass);
|
|
|
|
object_class->destroy = merged_destroy;
|
|
|
|
directory_class->contains_file = merged_contains_file;
|
|
directory_class->call_when_ready = merged_call_when_ready;
|
|
directory_class->cancel_callback = merged_cancel_callback;
|
|
directory_class->file_monitor_add = merged_file_monitor_add;
|
|
directory_class->file_monitor_remove = merged_file_monitor_remove;
|
|
directory_class->are_all_files_seen = merged_are_all_files_seen;
|
|
directory_class->is_not_empty = merged_is_not_empty;
|
|
}
|
|
|
|
static void
|
|
forward_files_added_cover (NautilusDirectory *real_directory,
|
|
GList *files,
|
|
NautilusMergedDirectory *merged)
|
|
{
|
|
nautilus_directory_emit_files_added (NAUTILUS_DIRECTORY (merged), files);
|
|
}
|
|
|
|
static void
|
|
forward_files_changed_cover (NautilusDirectory *real_directory,
|
|
GList *files,
|
|
NautilusMergedDirectory *merged)
|
|
{
|
|
nautilus_directory_emit_files_changed (NAUTILUS_DIRECTORY (merged), files);
|
|
}
|
|
|
|
static void
|
|
monitor_add_directory (gpointer key,
|
|
gpointer value,
|
|
gpointer callback_data)
|
|
{
|
|
MergedMonitor *monitor;
|
|
|
|
monitor = value;
|
|
nautilus_directory_file_monitor_add
|
|
(NAUTILUS_DIRECTORY (callback_data), monitor,
|
|
monitor->monitor_attributes,
|
|
monitor->monitor_metadata,
|
|
monitor->force_reload);
|
|
}
|
|
|
|
void
|
|
nautilus_merged_directory_add_real_directory (NautilusMergedDirectory *merged,
|
|
NautilusDirectory *real_directory)
|
|
{
|
|
g_return_if_fail (NAUTILUS_IS_MERGED_DIRECTORY (merged));
|
|
g_return_if_fail (NAUTILUS_IS_DIRECTORY (real_directory));
|
|
g_return_if_fail (!NAUTILUS_IS_MERGED_DIRECTORY (real_directory));
|
|
|
|
/* Quietly do nothing if asked to add something that's already there. */
|
|
if (g_list_find (merged->details->directories, real_directory) != NULL) {
|
|
return;
|
|
}
|
|
|
|
/* Add to our list of directories. */
|
|
nautilus_directory_ref (real_directory);
|
|
merged->details->directories = g_list_prepend
|
|
(merged->details->directories, real_directory);
|
|
|
|
/* Connect signals. */
|
|
gtk_signal_connect (GTK_OBJECT (real_directory),
|
|
"files_added",
|
|
forward_files_added_cover,
|
|
merged);
|
|
gtk_signal_connect (GTK_OBJECT (real_directory),
|
|
"files_changed",
|
|
forward_files_changed_cover,
|
|
merged);
|
|
/* FIXME: Hook up the done_loading signal too? */
|
|
|
|
/* Add the directory to any extant monitors. */
|
|
g_hash_table_foreach (merged->details->monitors,
|
|
monitor_add_directory,
|
|
real_directory);
|
|
/* FIXME: Do we need to add the directory to callbacks too? */
|
|
}
|
|
|
|
static void
|
|
merged_callback_remove_directory_cover (gpointer key,
|
|
gpointer value,
|
|
gpointer callback_data)
|
|
{
|
|
merged_callback_remove_directory
|
|
(value, NAUTILUS_DIRECTORY (callback_data));
|
|
}
|
|
|
|
static void
|
|
monitor_remove_directory (gpointer key,
|
|
gpointer value,
|
|
gpointer callback_data)
|
|
{
|
|
nautilus_directory_file_monitor_remove
|
|
(NAUTILUS_DIRECTORY (callback_data), value);
|
|
}
|
|
|
|
void
|
|
nautilus_merged_directory_remove_real_directory (NautilusMergedDirectory *merged,
|
|
NautilusDirectory *real_directory)
|
|
{
|
|
g_return_if_fail (NAUTILUS_IS_MERGED_DIRECTORY (merged));
|
|
g_return_if_fail (NAUTILUS_IS_DIRECTORY (real_directory));
|
|
|
|
/* Quietly do nothing if asked to remove something that's not there. */
|
|
if (g_list_find (merged->details->directories, real_directory) == NULL) {
|
|
return;
|
|
}
|
|
|
|
/* Remove this directory from callbacks and monitors. */
|
|
nautilus_g_hash_table_safe_for_each
|
|
(merged->details->callbacks,
|
|
merged_callback_remove_directory_cover,
|
|
real_directory);
|
|
g_hash_table_foreach
|
|
(merged->details->monitors,
|
|
monitor_remove_directory,
|
|
real_directory);
|
|
|
|
/* Disconnect all the signals. */
|
|
gtk_signal_disconnect_by_data (GTK_OBJECT (real_directory), merged);
|
|
|
|
/* Remove from our list of directories. */
|
|
merged->details->directories = g_list_remove
|
|
(merged->details->directories, real_directory);
|
|
nautilus_directory_unref (real_directory);
|
|
}
|
|
|
|
static void
|
|
remove_all_real_directories (NautilusMergedDirectory *merged)
|
|
{
|
|
while (merged->details->directories != NULL) {
|
|
nautilus_merged_directory_remove_real_directory
|
|
(merged, merged->details->directories->data);
|
|
}
|
|
}
|