File nautilus-drives-and-volumes-on-desktop.diff of Package nautilus
2007-10-24 Federico Mena Quintero <federico@novell.com>
Finish fixing https://bugzilla.novell.com/show_bug.cgi?id=335411 -
Nautilus crashes when it gets a "volume-mounted" signal for a
volume that is already mounted.
* libnautilus-private/nautilus-desktop-link-monitor.c
(link_corresponds_to_drive): Oops, check that the link_drive is
not NULL before comparing it. We may get a NULL link_drive if the
link corresponds to a volume without a drive (e.g. a network volume).
2007-10-23 Federico Mena Quintero <federico@novell.com>
* libnautilus-private/nautilus-desktop-link-monitor.c
(link_corresponds_to_drive): Use gnome_vfs_drive_compare(), not
pointer equality, to see if drives are the same. Apparently
gnome-vfs can feed us with different GnomeVFSDrive* objects that
really refer to the same drive.
(find_link_for_volume): Likewise, for volumes.
* libnautilus-private/nautilus-desktop-link.c
(nautilus_desktop_link_update_from_volume): Likewise.
2007-10-22 Federico Mena Quintero <federico@novell.com>
* libnautilus-private/nautilus-debug-log.h
(NAUTILUS_DEBUG_LOG_DRIVES_VOLUMES): Add a "drives-volumes" log domain.
* libnautilus-private/nautilus-desktop-link-monitor.c
(refresh_volume_links): Log the drives/volumes we find (milestone
or not milestone depending on whether we are initializing
Nautilus).
(create_drive_link): Log when we create a desktop link for a
drive.
(create_volume_link): Likewise, for a volume.
(drive_connected_callback): Log when a drive gets connected (not
milestone).
(drive_disconnected_callback): Likewise, when a drive gets disconnected.
(volume_mounted_callback): Likewise, when a volume gets mounted.
(volume_unmounted_callback): Likewise, when a volume gets unmounted.
2007-10-22 Federico Mena Quintero <federico@novell.com>
* libnautilus-private/nautilus-debug-log.h
(NAUTILUS_DEBUG_LOG_DESKTOP_LINKS): Add a "desktop-links" log
domain.
* libnautilus-private/nautilus-desktop-link-monitor.c
(nautilus_desktop_link_monitor_init): Log initialization of the
desktop link monitor (milestone).
(create_link_and_add_preference): Log initialization of each link
type (milestone).
(update_link_visibility): Log changes in link visibility (non-milestone).
2007-05-24 Hans Petter Jansson <hpj@novell.com>
Fix https://bugzilla.novell.com/show_bug.cgi?id=276193, unable
to right-click after accessing files on CD via GUI. The problem
was that Nautilus was crashing under some circumstances when
unmounting/ejecting a CD. It was caused by some of the code
previously introduced by this patch.
The fix consists of ignoring the desktop link we are currently
repopulating when scanning the list of desktop links to uniquefy
the new filename for this link.
* libnautilus-private/nautilus-desktop-link-monitor.[ch]
(nautilus_desktop_link_monitor_make_filename_unique): Add a
"skip_link" argument that will make the algorithm skip the
provided desktop link when considering non-unique filenames.
(volume_file_name_used): Skip the link passed from caller,
if any.
2006-11-08 Federico Mena Quintero <federico@novell.com>
Fix https://bugzilla.novell.com/show_bug.cgi?id=215351, the icon
for a floppy drive disappears after unmounting the floppy. Also,
unmounting an NFS volume makes the icon disappear.
Fix the little bug where a recently-unmounted drive still
shows an "Unmount Volume" menu item.
* libnautilus-private/nautilus-desktop-link-monitor.c
(drive_has_volumes_apart_from): New function; checks whether a
drive has any mounted volumes apart from a given one. We need
this to check that corresponds to a volume that is being
unmounted, since within the volume_unmounted callback, the drive
still thinks it is mounted (as the volume in question has not been
removed from it yet).
(should_show_drive): Check whether the drive has any volumes left
over aside from the volume being unmounted.
(volume_unmounted_callback): Pass the volume to should_show_drive().
* libnautilus-private/nautilus-desktop-icon-file.c
(update_info_from_link): If the link acquires a volume, remove the
drive from the corresponding NautilusFile. And the converse: if
the link acquires a drive, remove the volume from the
corresponding NautilusFile. Files can have volumes XOR drives, or
none. This fixes the bug where you mount a drive, then umount the
corresponding volume, and the menu on the drive icon still shows
"unmount volume".
* libnautilus-private/nautilus-desktop-link.c
(nautilus_desktop_link_update_from_volume): Removed spurious
comment.
2006-11-07 Federico Mena Quintero <federico@novell.com>
Deal with a race condition when mounting drives. The callback
from gnome_vfs_drive_mount() can be called before the
GnomeVFSVolumeMonitor is notified that the drive is actually
mounted.
* src/file-manager/fm-directory-view.c (ActivateParameters):
Replace the "pending_mounts" counter with a list of
drives_being_mounted.
(DriveBeingMounted): New struct used as a closure for a drive
being mounted, or a drive waiting for its corresponding
NautilusFile to be notified of changes from the volume monitor.
(cancel_activate): Replace pending_mounts with
drives_being_mounted.
(activate_activation_uris_ready_callback): Don't use the
not_yet_mounted list. Instead, build the list of
parameters->drives_being_mounted out of DriveBeingMounted
structures. Mount the drives directly here (instead of using
g_list_foreach()) so that we can pass a DriveBeingMounted closure
to gnome_vfs_drive_mount().
(fm_directory_view_activate_files): Replace pending_mounts with
drives_being_mounted.
(try_to_finish_drive_activation): New function. Moved the code to
finish activation of drives from
activation_drive_mounted_callback() to here.
(activation_drive_mounted_callback): This is our "drive was
mounted" callback, but the GnomeVFSDrive itself may not think that
it is mounted yet. This is a race condition where the
GnomeVFSVolumeMonitor has not been notified yet. In this case,
wait until the corresponding NautilusFile changes; we'll check
again that the drive is mounted in the "changed" callback.
(activation_file_changed_after_drive_mounted): New callback for
NautilusFile::changed. This gets called when a NautilusFile
changes after a drive was reported as being mounted. Here, we try
to finish the drive activation.
2006-10-05 Federico Mena Quintero <federico@novell.com>
Support displaying drive icons in the desktop, even if the drives
are not mounted. Do this only for drives which are supposed to be
user-visible (i.e. those that do not support media checks and so
we cannot know when the user inserts media in them).
Also, support drives with multiple partitions, which will lead to
multiple volumes for the same drive.
To do this, we add several things:
1. The ability for NautilusDesktopLink to represent a drive as
well as a volume.
2. The ability to "transform" a NautilusDesktopLink which
represented a drive, into one that represents a volume. This
happens when a drive is mounted.
3. Keep the invariant that drives are only displayed if they are
unmounted and user visible. If they are mounted, they get
replaced with volume links.
* libnautilus-private/nautilus-desktop-link-monitor.c (struct
NautilusDesktopLinkMonitorDetails): Added "connected_id" and
"disconnected_id" fields for the signal IDs of GnomeVFSDrive.
(volume_delete_dialog): Added message about not being able to move
a drive to the trash. Support drives or volumes.
(should_show_drive): New utility function. Drives are shown if
they are user-visible, they are not mounted, and the preference to
show desktop volumes is turned on.
(should_show_volume): New utility function. Volumes are shown if
they are user visible and the preference to show desktop volumes
is turned on.
(create_drive_link): New utility function; creates a
NautilusDesktopLink for a GnomeVFSDrive.
(create_volume_link): Use should_show_volume().
(link_corresponds_to_drive): New function. A NautilusDesktopLink
corresponds to a drive if it represents the drive itself, or if it
represents a volume relative to that drive.
(find_unique_link_for_drive): New function. Returns the
NautilusDesktopLink in the desktop that corresponds uniquely to a
given drive; if there is more than one volume link for a drive
(e.g. a drive with multiple partitions), returns NULL.
(drive_connected_callback): New callback. When a drive is
connected, we create a link for it if appropriate.
(drive_disconnected_callback): New callback. When a drive is
disconnected, we remove all the links that correspond to it: a
single drive link for an unmounted drive, or one or more volume
links for a mounted drive.
(volume_mounted_callback): If the volume has a drive, and there is
an existing link for that drive, update the link to represent the
volume instead. Otherwise, create volume link as usual.
(find_link_for_volume): New utility function; returns the link on
the desktop which corresponds to a particular volume.
(volume_unmounted_callback): If unmounting a volume would yield a
drive that is user visible, transform the corresponding link from
representing the volume, into one that represents the drive.
Otherwise, remove the link as usual.
(refresh_volume_links): New function; does the initial population
of the links for drives and volumes.
(desktop_volumes_visible_changed): New callback; use
refresh_volume_links().
(nautilus_desktop_link_monitor_init): Use refresh_volume_links()
instead of doing things by hand here. Also, connect to
"drive_connected" and "drive_disconnected" on the volume monitor.
* libnautilus-private/nautilus-desktop-icon-file.c
(update_info_from_link): Accept a drive or a volume, not just
volumes.
* libnautilus-private/nautilus-desktop-link.h
(nautilus_desktop_link_new_from_drive_or_volume): New prototype.
Replaces nautilus_desktop_link_new_from_volume().
(nautilus_desktop_link_get_drive_or_volume): New prototype.
Replaces nautilus_desktop_link_get_volume().
(nautilus_desktop_link_update_from_volume): New prototype.
* libnautilus-private/nautilus-desktop-link.c (struct
NautilusDesktopLinkDetails): Replaced the "volume" field with
"drive_or_volume".
(reread_drive_or_volume): Refresh the link as appropriate from a
drive or a volume.
(desktop_link_finalize): Unref the drive or volume appropriately.
(nautilus_desktop_link_new_from_drive_or_volume): Replacement for
nautilus_desktop_link_new_from_volume().
(nautilus_desktop_link_get_drive_or_volume): Replacement for
nautilus_desktop_link_get_volume().
(nautilus_desktop_link_update_from_volume): New public function;
replaces nautilus_desktop_link_new_from_volume(). Updates the
link's information from a volume. This does the actual
transformation of a link from a drive to volume when an unmounted
drive gets first mounted, and vice-versa.
diff --git a/libnautilus-private/nautilus-debug-log.h b/libnautilus-private/nautilus-debug-log.h
index 801610d..85a0253 100644
--- a/libnautilus-private/nautilus-debug-log.h
+++ b/libnautilus-private/nautilus-debug-log.h
@@ -29,6 +29,8 @@
#define NAUTILUS_DEBUG_LOG_DOMAIN_USER "USER" /* always enabled */
#define NAUTILUS_DEBUG_LOG_DOMAIN_ASYNC "async" /* when asynchronous notifications come in */
+#define NAUTILUS_DEBUG_LOG_DESKTOP_LINKS "desktop-links" /* Desktop links in general */
+#define NAUTILUS_DEBUG_LOG_DRIVES_VOLUMES "drives-volumes" /* desktop link monitoring of drives/volumes */
#define NAUTILUS_DEBUG_LOG_DOMAIN_GLOG "GLog" /* used for GLog messages; don't use it yourself */
void nautilus_debug_log (gboolean is_milestone, const char *domain, const char *format, ...);
diff --git a/libnautilus-private/nautilus-desktop-icon-file.c b/libnautilus-private/nautilus-desktop-icon-file.c
index 733be41..9e00f5a 100644
--- a/libnautilus-private/nautilus-desktop-icon-file.c
+++ b/libnautilus-private/nautilus-desktop-icon-file.c
@@ -179,7 +179,7 @@ update_info_from_link (NautilusDesktopIconFile *icon_file)
NautilusFile *file;
GnomeVFSFileInfo *file_info;
NautilusDesktopLink *link;
- GnomeVFSVolume *volume;
+ GObject *drive_or_volume;
file = NAUTILUS_FILE (icon_file);
@@ -216,9 +216,25 @@ update_info_from_link (NautilusDesktopIconFile *icon_file)
GNOME_VFS_FILE_INFO_FIELDS_ACCESS |
GNOME_VFS_FILE_INFO_FIELDS_LINK_COUNT;
- volume = nautilus_desktop_link_get_volume (link);
- nautilus_file_set_volume (file, volume);
- gnome_vfs_volume_unref (volume);
+ drive_or_volume = nautilus_desktop_link_get_drive_or_volume (link);
+
+ if (GNOME_IS_VFS_VOLUME (drive_or_volume)) {
+ GnomeVFSVolume *volume;
+
+ volume = GNOME_VFS_VOLUME (drive_or_volume);
+ nautilus_file_set_volume (file, volume);
+ gnome_vfs_volume_unref (volume);
+
+ nautilus_file_set_drive (file, NULL);
+ } else {
+ GnomeVFSDrive *drive;
+
+ drive = GNOME_VFS_DRIVE (drive_or_volume);
+ nautilus_file_set_drive (file, drive);
+ gnome_vfs_drive_unref (drive);
+
+ nautilus_file_set_volume (file, NULL);
+ }
file->details->file_info_is_up_to_date = TRUE;
diff --git a/libnautilus-private/nautilus-desktop-link-monitor.c b/libnautilus-private/nautilus-desktop-link-monitor.c
index 6469c6a..b636983 100644
--- a/libnautilus-private/nautilus-desktop-link-monitor.c
+++ b/libnautilus-private/nautilus-desktop-link-monitor.c
@@ -27,6 +27,7 @@
#include "nautilus-desktop-link.h"
#include "nautilus-desktop-icon-file.h"
#include "nautilus-directory.h"
+#include "nautilus-debug-log.h"
#include "nautilus-desktop-directory.h"
#include "nautilus-global-preferences.h"
@@ -52,13 +53,14 @@ struct NautilusDesktopLinkMonitorDetails {
NautilusDesktopLink *trash_link;
NautilusDesktopLink *network_link;
+ gulong connected_id;
+ gulong disconnected_id;
gulong mount_id;
gulong unmount_id;
GList *volume_links;
};
-
static void nautilus_desktop_link_monitor_init (gpointer object,
gpointer klass);
static void nautilus_desktop_link_monitor_class_init (gpointer klass);
@@ -69,6 +71,8 @@ EEL_CLASS_BOILERPLATE (NautilusDesktopLinkMonitor,
static NautilusDesktopLinkMonitor *the_link_monitor = NULL;
+static void refresh_volume_links (NautilusDesktopLinkMonitor *monitor, gboolean is_initialization);
+
static void
destroy_desktop_link_monitor (void)
{
@@ -104,41 +108,48 @@ static void
volume_delete_dialog (GtkWidget *parent_view,
NautilusDesktopLink *link)
{
- GnomeVFSVolume *volume;
+ GObject *drive_or_volume;
char *dialog_str;
+ char *detail_str;
char *display_name;
- volume = nautilus_desktop_link_get_volume (link);
+ drive_or_volume = nautilus_desktop_link_get_drive_or_volume (link);
+ if (drive_or_volume == NULL)
+ return;
+
+ display_name = nautilus_desktop_link_get_display_name (link);
- if (volume != NULL) {
- display_name = nautilus_desktop_link_get_display_name (link);
+ if (GNOME_IS_VFS_VOLUME (drive_or_volume)) {
dialog_str = g_strdup_printf (_("You cannot move the volume \"%s\" to the trash."),
display_name);
- g_free (display_name);
-
- if (eject_for_type (gnome_vfs_volume_get_device_type (volume))) {
- eel_run_simple_dialog
- (parent_view,
- FALSE,
- GTK_MESSAGE_ERROR,
- dialog_str,
- _("If you want to eject the volume, please use \"Eject\" in the "
- "popup menu of the volume."),
- GTK_STOCK_OK, NULL);
+
+ if (eject_for_type (gnome_vfs_volume_get_device_type (GNOME_VFS_VOLUME (drive_or_volume)))) {
+ detail_str = _("If you want to eject the volume, please use \"Eject\" in the "
+ "popup menu of the volume.");
} else {
- eel_run_simple_dialog
- (parent_view,
- FALSE,
- GTK_MESSAGE_ERROR,
- dialog_str,
- _("If you want to unmount the volume, please use \"Unmount Volume\" in the "
- "popup menu of the volume."),
- GTK_STOCK_OK, NULL);
+ detail_str = _("If you want to unmount the volume, please use \"Unmount Volume\" in the "
+ "popup menu of the volume.");
}
+ } else {
+ dialog_str = g_strdup_printf (_("You cannot move the drive \"%s\" to the trash."),
+ display_name);
- gnome_vfs_volume_unref (volume);
- g_free (dialog_str);
+ detail_str = NULL;
}
+
+ eel_run_simple_dialog (parent_view, FALSE, GTK_MESSAGE_ERROR,
+ dialog_str,
+ detail_str,
+ NULL, GTK_STOCK_OK, NULL);
+
+ if (GNOME_IS_VFS_VOLUME (drive_or_volume)) {
+ gnome_vfs_volume_unref (GNOME_VFS_VOLUME (drive_or_volume));
+ } else {
+ gnome_vfs_drive_unref (GNOME_VFS_DRIVE (drive_or_volume));
+ }
+
+ g_free (display_name);
+ g_free (dialog_str);
}
void
@@ -161,6 +172,7 @@ nautilus_desktop_link_monitor_delete_link (NautilusDesktopLinkMonitor *monitor,
static gboolean
volume_file_name_used (NautilusDesktopLinkMonitor *monitor,
+ NautilusDesktopLink *skip_link,
const char *name)
{
GList *l;
@@ -168,6 +180,9 @@ volume_file_name_used (NautilusDesktopLinkMonitor *monitor,
gboolean same;
for (l = monitor->details->volume_links; l != NULL; l = l->next) {
+ if (l->data == skip_link)
+ continue;
+
other_name = nautilus_desktop_link_get_file_name (l->data);
same = strcmp (name, other_name) == 0;
g_free (other_name);
@@ -182,6 +197,7 @@ volume_file_name_used (NautilusDesktopLinkMonitor *monitor,
char *
nautilus_desktop_link_monitor_make_filename_unique (NautilusDesktopLinkMonitor *monitor,
+ NautilusDesktopLink *skip_link,
const char *filename)
{
char *unique_name;
@@ -189,39 +205,398 @@ nautilus_desktop_link_monitor_make_filename_unique (NautilusDesktopLinkMonitor *
i = 2;
unique_name = g_strdup (filename);
- while (volume_file_name_used (monitor, unique_name)) {
+ while (volume_file_name_used (monitor, skip_link, unique_name)) {
g_free (unique_name);
unique_name = g_strdup_printf ("%s.%d", filename, i++);
}
return unique_name;
}
+static gboolean
+drive_has_volumes_apart_from (GnomeVFSDrive *drive, GnomeVFSVolume *possibly_last_volume)
+{
+ GList *volumes;
+ GList *l;
+ gboolean has_other_volumes;
+
+ has_other_volumes = FALSE;
+
+ volumes = gnome_vfs_drive_get_mounted_volumes (drive);
+
+ for (l = volumes; l; l = l->next) {
+ GnomeVFSVolume *volume;
+
+ volume = GNOME_VFS_VOLUME (l->data);
+ if (volume != possibly_last_volume)
+ has_other_volumes = TRUE;
+
+ gnome_vfs_volume_unref (volume);
+ }
+
+ g_list_free (volumes);
+
+ return has_other_volumes;
+}
+
+static gboolean
+should_show_drive (GnomeVFSDrive *drive, GnomeVFSVolume *possibly_last_volume)
+{
+ gboolean should_show;
+
+ if (possibly_last_volume)
+ should_show = !drive_has_volumes_apart_from (drive, possibly_last_volume);
+ else
+ should_show = !gnome_vfs_drive_is_mounted (drive);
+
+ return (gnome_vfs_drive_is_user_visible (drive)
+ && should_show
+ && eel_preferences_get_boolean (NAUTILUS_PREFERENCES_DESKTOP_VOLUMES_VISIBLE));
+}
+
+static gboolean
+should_show_volume (GnomeVFSVolume *volume)
+{
+ return (gnome_vfs_volume_is_user_visible (volume)
+ && eel_preferences_get_boolean (NAUTILUS_PREFERENCES_DESKTOP_VOLUMES_VISIBLE));
+}
+
+static char *
+get_human_readable_drive_id (GnomeVFSDrive *drive)
+{
+ char *id;
+
+ id = gnome_vfs_drive_get_hal_udi (drive);
+ if (!id) {
+ id = gnome_vfs_drive_get_device_path (drive);
+
+ if (!id) {
+ id = gnome_vfs_drive_get_activation_uri (drive);
+
+ if (!id) {
+ id = "\"unknown\""; /* goddamnit */
+ }
+ }
+ }
+
+ return id;
+}
+
+static void
+create_drive_link (NautilusDesktopLinkMonitor *monitor,
+ GnomeVFSDrive *drive,
+ gboolean is_initialization)
+{
+ NautilusDesktopLink *link;
+ char *id;
+
+ if (!should_show_drive (drive, NULL)) {
+ id = get_human_readable_drive_id (drive);
+ nautilus_debug_log (is_initialization, NAUTILUS_DEBUG_LOG_DRIVES_VOLUMES,
+ " * Not creating desktop link for drive %s (%p)",
+ id,
+ drive);
+ g_free (id);
+
+ return;
+ }
+
+ link = nautilus_desktop_link_new_from_drive_or_volume (G_OBJECT (drive));
+ monitor->details->volume_links = g_list_prepend (monitor->details->volume_links, link);
+
+ id = get_human_readable_drive_id (drive);
+ nautilus_debug_log (is_initialization, NAUTILUS_DEBUG_LOG_DRIVES_VOLUMES,
+ " * Creating desktop link for drive %s (%p)",
+ id,
+ drive);
+ g_free (id);
+}
+
+static char *
+get_human_readable_volume_id (GnomeVFSVolume *volume)
+{
+ char *id;
+
+ id = gnome_vfs_volume_get_hal_udi (volume);
+ if (!id) {
+ id = gnome_vfs_volume_get_device_path (volume);
+
+ if (!id) {
+ id = gnome_vfs_volume_get_activation_uri (volume);
+
+ if (!id) {
+ id = "\"unknown\""; /* goddamnit */
+ }
+ }
+ }
+
+ return id;
+}
+
static void
create_volume_link (NautilusDesktopLinkMonitor *monitor,
- GnomeVFSVolume *volume)
+ GnomeVFSVolume *volume,
+ gboolean is_initialization)
{
NautilusDesktopLink *link;
+ char *id;
+ char *link_name;
link = NULL;
- if (!gnome_vfs_volume_is_user_visible (volume)) {
+ if (!should_show_volume (volume)) {
+ id = get_human_readable_volume_id (volume);
+ nautilus_debug_log (is_initialization, NAUTILUS_DEBUG_LOG_DRIVES_VOLUMES,
+ " * Not creating desktop link for volume %s (%p)",
+ id,
+ volume);
+ g_free (id);
return;
}
- if (eel_preferences_get_boolean (NAUTILUS_PREFERENCES_DESKTOP_VOLUMES_VISIBLE)) {
- link = nautilus_desktop_link_new_from_volume (volume);
- monitor->details->volume_links = g_list_prepend (monitor->details->volume_links, link);
+ link = nautilus_desktop_link_new_from_drive_or_volume (G_OBJECT (volume));
+ monitor->details->volume_links = g_list_prepend (monitor->details->volume_links, link);
+
+ id = get_human_readable_volume_id (volume);
+ link_name = nautilus_desktop_link_get_display_name (link);
+ nautilus_debug_log (is_initialization, NAUTILUS_DEBUG_LOG_DRIVES_VOLUMES,
+ " * Creating desktop link \"%s\" for volume %s (%p)",
+ link_name,
+ id,
+ volume);
+ g_free (id);
+ g_free (link_name);
+}
+
+static gboolean
+link_corresponds_to_drive (NautilusDesktopLink *link,
+ GnomeVFSDrive *drive)
+{
+ GObject *drive_or_volume;
+ gboolean same;
+
+ drive_or_volume = nautilus_desktop_link_get_drive_or_volume (link);
+ same = FALSE;
+
+ if (GNOME_IS_VFS_DRIVE (drive_or_volume)) {
+ GnomeVFSDrive *link_drive;
+
+ link_drive = GNOME_VFS_DRIVE (drive_or_volume);
+
+ if (gnome_vfs_drive_compare (link_drive, drive) == 0) {
+ same = TRUE;
+ }
+
+ gnome_vfs_drive_unref (link_drive);
+ } else {
+ GnomeVFSVolume *link_volume;
+ GnomeVFSDrive *link_drive;
+
+ link_volume = GNOME_VFS_VOLUME (drive_or_volume);
+ link_drive = gnome_vfs_volume_get_drive (link_volume);
+
+ if (link_drive && gnome_vfs_drive_compare (link_drive, drive) == 0) {
+ same = TRUE;
+ }
+
+ if (link_drive) {
+ gnome_vfs_drive_unref (link_drive);
+ }
+
+ gnome_vfs_volume_unref (link_volume);
+ }
+
+ return same;
+}
+
+static NautilusDesktopLink *
+find_unique_link_for_drive (NautilusDesktopLinkMonitor *monitor,
+ GnomeVFSDrive *drive)
+{
+ GList *l;
+ NautilusDesktopLink *first_volume_link_for_drive;
+
+ first_volume_link_for_drive = NULL;
+
+ for (l = monitor->details->volume_links; l; l = l->next) {
+ NautilusDesktopLink *link;
+
+ link = NAUTILUS_DESKTOP_LINK (l->data);
+
+ if (link_corresponds_to_drive (link, drive)) {
+ if (first_volume_link_for_drive == NULL) {
+ first_volume_link_for_drive = link;
+ } else {
+ return NULL; /* We know that we have more than
+ * one link for volumes that belong
+ * to the same drive, so there is
+ * no unique link for the drive.
+ */
+ }
+ }
+ }
+
+ return first_volume_link_for_drive;
+}
+
+static void
+drive_connected_callback (GnomeVFSVolumeMonitor *volume_monitor,
+ GnomeVFSDrive *drive,
+ NautilusDesktopLinkMonitor *monitor)
+{
+ NautilusDesktopLink *link;
+ char *id;
+
+ id = get_human_readable_drive_id (drive);
+ nautilus_debug_log (FALSE, NAUTILUS_DEBUG_LOG_DRIVES_VOLUMES,
+ "Drive %s (%p) got connected",
+ id,
+ drive);
+ g_free (id);
+
+ link = find_unique_link_for_drive (monitor, drive);
+
+ if (link) {
+ id = get_human_readable_drive_id (drive);
+ nautilus_debug_log (FALSE, NAUTILUS_DEBUG_LOG_DRIVES_VOLUMES,
+ "Not creating a desktop link for drive %s (%p) since there is already a link for it",
+ id,
+ drive);
+ g_free (id);
+
+ return; /* huh, we already have a link for that drive... */
}
+
+ create_drive_link (monitor, drive, FALSE);
}
+static void
+drive_disconnected_callback (GnomeVFSVolumeMonitor *volume_monitor,
+ GnomeVFSDrive *drive,
+ NautilusDesktopLinkMonitor *monitor)
+{
+ GList *l;
+ char *id;
+
+ id = get_human_readable_drive_id (drive);
+ nautilus_debug_log (FALSE, NAUTILUS_DEBUG_LOG_DRIVES_VOLUMES,
+ "Drive %s (%p) got disconnected",
+ id,
+ drive);
+
+ /* Remove all the links that correspond to that drive, even if they have
+ * mounted volumes.
+ */
+ l = monitor->details->volume_links;
+
+ while (l) {
+ GList *next;
+ NautilusDesktopLink *link;
+
+ next = l->next;
+ link = NAUTILUS_DESKTOP_LINK (l->data);
+
+ if (link_corresponds_to_drive (link, drive)) {
+ char *link_name;
+
+ link_name = nautilus_desktop_link_get_display_name (link);
+
+ g_object_unref (link);
+ monitor->details->volume_links = g_list_remove_link (monitor->details->volume_links, l);
+ g_list_free_1 (l);
+
+ nautilus_debug_log (FALSE, NAUTILUS_DEBUG_LOG_DRIVES_VOLUMES,
+ "Removing desktop link \"%s\" corresponding to drive %s (%p)",
+ link_name,
+ id,
+ drive);
+ g_free (link_name);
+ }
+
+ l = next;
+ }
+
+ g_free (id);
+}
static void
volume_mounted_callback (GnomeVFSVolumeMonitor *volume_monitor,
GnomeVFSVolume *volume,
NautilusDesktopLinkMonitor *monitor)
{
- create_volume_link (monitor, volume);
+ GnomeVFSDrive *drive;
+ char *id;
+
+ id = get_human_readable_volume_id (volume);
+ nautilus_debug_log (FALSE, NAUTILUS_DEBUG_LOG_DRIVES_VOLUMES,
+ "Volume %s (%p) got mounted",
+ id,
+ volume);
+
+ drive = gnome_vfs_volume_get_drive (volume);
+
+ if (drive) {
+ NautilusDesktopLink *link;
+
+ /* We may have an existing link for the drive, which needs to be
+ * updated for the volume. Or we may have several volumes
+ * within the same drive; in this case, we need to create a
+ * completely new link.
+ */
+
+ link = find_unique_link_for_drive (monitor, drive);
+ gnome_vfs_drive_unref (drive);
+
+ if (link) {
+ char *link_name;
+
+ link_name = nautilus_desktop_link_get_display_name (link);
+ nautilus_debug_log (FALSE, NAUTILUS_DEBUG_LOG_DRIVES_VOLUMES,
+ " * Updating existing desktop link \"%s\" for mounted volume %s (%p)",
+ link_name,
+ id,
+ volume);
+ g_free (link_name);
+
+ nautilus_desktop_link_update_from_volume (link, volume);
+ } else {
+ create_volume_link (monitor, volume, FALSE);
+ }
+ } else {
+ create_volume_link (monitor, volume, FALSE);
+ }
+
+ g_free (id);
+}
+
+static NautilusDesktopLink *
+find_link_for_volume (NautilusDesktopLinkMonitor *monitor,
+ GnomeVFSVolume *volume)
+{
+ GList *l;
+
+ for (l = monitor->details->volume_links; l != NULL; l = l->next) {
+ NautilusDesktopLink *link;
+ GObject *drive_or_volume;
+ gboolean same;
+
+ link = NAUTILUS_DESKTOP_LINK (l->data);
+ drive_or_volume = nautilus_desktop_link_get_drive_or_volume (link);
+
+ same = FALSE;
+
+ if (GNOME_IS_VFS_VOLUME (drive_or_volume)) {
+ same = (gnome_vfs_volume_compare (GNOME_VFS_VOLUME (drive_or_volume), volume) == 0);
+ gnome_vfs_volume_unref (GNOME_VFS_VOLUME (drive_or_volume));
+ } else {
+ gnome_vfs_drive_unref (GNOME_VFS_DRIVE (drive_or_volume));
+ }
+
+ if (same)
+ return link;
+ }
+
+ return NULL;
}
@@ -230,25 +605,63 @@ volume_unmounted_callback (GnomeVFSVolumeMonitor *volume_monitor,
GnomeVFSVolume *volume,
NautilusDesktopLinkMonitor *monitor)
{
- GList *l;
NautilusDesktopLink *link;
- GnomeVFSVolume *other_volume;
+ GnomeVFSDrive *drive;
+ gboolean remove_link;
+ char *id;
+ char *link_name = NULL;
+
+ id = get_human_readable_volume_id (volume);
+ nautilus_debug_log (FALSE, NAUTILUS_DEBUG_LOG_DRIVES_VOLUMES,
+ "Volume %s (%p) got unmounted",
+ id,
+ volume);
+
+ link = find_link_for_volume (monitor, volume);
+ if (!link) {
+ nautilus_debug_log (FALSE, NAUTILUS_DEBUG_LOG_DRIVES_VOLUMES,
+ " * No desktop link for volume %s (%p); not doing anything",
+ id,
+ volume);
+ goto out;
+ }
- link = NULL;
- for (l = monitor->details->volume_links; l != NULL; l = l->next) {
- other_volume = nautilus_desktop_link_get_volume (l->data);
- if (volume == other_volume) {
- gnome_vfs_volume_unref (other_volume);
- link = l->data;
- break;
+ link_name = nautilus_desktop_link_get_display_name (link);
+
+ remove_link = FALSE;
+
+ drive = gnome_vfs_volume_get_drive (volume);
+ if (drive) {
+ if (should_show_drive (drive, volume)) {
+ nautilus_debug_log (FALSE, NAUTILUS_DEBUG_LOG_DRIVES_VOLUMES,
+ "Updating desktop link \"%s\" from unmounted volume %s (%p)",
+ link_name,
+ id,
+ volume);
+
+ nautilus_desktop_link_update_from_volume (link, volume);
+ } else {
+ remove_link = TRUE;
}
- gnome_vfs_volume_unref (other_volume);
+ } else {
+ remove_link = TRUE;
}
- if (link) {
+ if (remove_link) {
+ nautilus_debug_log (FALSE, NAUTILUS_DEBUG_LOG_DRIVES_VOLUMES,
+ "Removing desktop link \"%s\" corresponding to unmounted volume %s (%p)",
+ link_name,
+ id,
+ volume);
+
monitor->details->volume_links = g_list_remove (monitor->details->volume_links, link);
g_object_unref (link);
}
+
+ g_free (link_name);
+
+out:
+ g_free (id);
}
static void
@@ -257,7 +670,11 @@ update_link_visibility (NautilusDesktopLinkMonitor *monitor,
NautilusDesktopLinkType link_type,
const char *preference_key)
{
- if (eel_preferences_get_boolean (preference_key)) {
+ gboolean enabled;
+
+ enabled = eel_preferences_get_boolean (preference_key);
+
+ if (enabled) {
if (*link_ref == NULL) {
*link_ref = nautilus_desktop_link_new (link_type);
}
@@ -267,6 +684,11 @@ update_link_visibility (NautilusDesktopLinkMonitor *monitor,
*link_ref = NULL;
}
}
+
+ nautilus_debug_log (FALSE, NAUTILUS_DEBUG_LOG_DESKTOP_LINKS,
+ "Desktop link %s got %s",
+ preference_key,
+ enabled ? "enabled" : "disabled");
}
static void
@@ -322,53 +744,98 @@ desktop_network_visible_changed (gpointer callback_data)
}
static void
-desktop_volumes_visible_changed (gpointer callback_data)
+refresh_volume_links (NautilusDesktopLinkMonitor *monitor, gboolean is_initialization)
{
GnomeVFSVolumeMonitor *volume_monitor;
- NautilusDesktopLinkMonitor *monitor;
- GList *l, *volumes;
volume_monitor = gnome_vfs_get_volume_monitor ();
- monitor = NAUTILUS_DESKTOP_LINK_MONITOR (callback_data);
+
+ nautilus_debug_log (is_initialization, NAUTILUS_DEBUG_LOG_DRIVES_VOLUMES,
+ "Refreshing drive and volume links");
+
+ /* Free existing links */
+
+ g_list_foreach (monitor->details->volume_links, (GFunc)g_object_unref, NULL);
+ g_list_free (monitor->details->volume_links);
+ monitor->details->volume_links = NULL;
+
+ /* Scan the links again */
if (eel_preferences_get_boolean (NAUTILUS_PREFERENCES_DESKTOP_VOLUMES_VISIBLE)) {
- if (monitor->details->volume_links == NULL) {
- volumes = gnome_vfs_volume_monitor_get_mounted_volumes (volume_monitor);
- for (l = volumes; l != NULL; l = l->next) {
- create_volume_link (monitor, l->data);
- gnome_vfs_volume_unref (l->data);
- }
- g_list_free (volumes);
+ GList *l;
+ GList *volumes, *drives;
+
+ /* Unmounted drives */
+
+ drives = gnome_vfs_volume_monitor_get_connected_drives (volume_monitor);
+ for (l = drives; l != NULL; l = l->next) {
+ GnomeVFSDrive *drive;
+
+ drive = GNOME_VFS_DRIVE (l->data);
+ create_drive_link (monitor, drive, is_initialization);
+ gnome_vfs_drive_unref (drive);
+ }
+ g_list_free (drives);
+
+ /* Volumes */
+
+ volumes = gnome_vfs_volume_monitor_get_mounted_volumes (volume_monitor);
+ for (l = volumes; l != NULL; l = l->next) {
+ GnomeVFSVolume *volume;
+
+ volume = GNOME_VFS_VOLUME (l->data);
+ create_volume_link (monitor, volume, is_initialization);
+ gnome_vfs_volume_unref (volume);
}
+ g_list_free (volumes);
} else {
- g_list_foreach (monitor->details->volume_links, (GFunc)g_object_unref, NULL);
- g_list_free (monitor->details->volume_links);
- monitor->details->volume_links = NULL;
+ nautilus_debug_log (is_initialization, NAUTILUS_DEBUG_LOG_DRIVES_VOLUMES,
+ "%s is disabled; not creating desktop links for drives/volumes",
+ NAUTILUS_PREFERENCES_DESKTOP_VOLUMES_VISIBLE);
}
}
static void
+desktop_volumes_visible_changed (gpointer callback_data)
+{
+ NautilusDesktopLinkMonitor *monitor;
+
+ monitor = NAUTILUS_DESKTOP_LINK_MONITOR (callback_data);
+ refresh_volume_links (monitor, FALSE);
+}
+
+static void
create_link_and_add_preference (NautilusDesktopLink **link_ref,
NautilusDesktopLinkType link_type,
const char *preference_key,
EelPreferencesCallback callback,
gpointer callback_data)
{
- if (eel_preferences_get_boolean (preference_key)) {
+ gboolean enabled;
+
+ enabled = eel_preferences_get_boolean (preference_key);
+
+ if (enabled) {
*link_ref = nautilus_desktop_link_new (link_type);
}
eel_preferences_add_callback (preference_key, callback, callback_data);
+
+ nautilus_debug_log (TRUE, NAUTILUS_DEBUG_LOG_DESKTOP_LINKS,
+ "Desktop link %s is %s",
+ preference_key,
+ enabled ? "enabled" : "disabled");
}
static void
nautilus_desktop_link_monitor_init (gpointer object, gpointer klass)
{
NautilusDesktopLinkMonitor *monitor;
- GList *l, *volumes;
- GnomeVFSVolume *volume;
GnomeVFSVolumeMonitor *volume_monitor;
+ nautilus_debug_log (TRUE, NAUTILUS_DEBUG_LOG_DESKTOP_LINKS,
+ "Initializing desktop link monitor");
+
monitor = NAUTILUS_DESKTOP_LINK_MONITOR (object);
the_link_monitor = monitor;
@@ -404,22 +871,22 @@ nautilus_desktop_link_monitor_init (gpointer object, gpointer klass)
desktop_network_visible_changed,
monitor);
- /* Volume links */
+ /* Drives and volumes */
- volume_monitor = gnome_vfs_get_volume_monitor ();
-
- volumes = gnome_vfs_volume_monitor_get_mounted_volumes (volume_monitor);
- for (l = volumes; l != NULL; l = l->next) {
- volume = l->data;
- create_volume_link (monitor, volume);
- gnome_vfs_volume_unref (volume);
- }
- g_list_free (volumes);
+ refresh_volume_links (monitor, TRUE);
eel_preferences_add_callback (NAUTILUS_PREFERENCES_DESKTOP_VOLUMES_VISIBLE,
desktop_volumes_visible_changed,
monitor);
+ volume_monitor = gnome_vfs_get_volume_monitor ();
+
+ monitor->details->connected_id = g_signal_connect_object (volume_monitor, "drive_connected",
+ G_CALLBACK (drive_connected_callback),
+ monitor, 0);
+ monitor->details->disconnected_id = g_signal_connect_object (volume_monitor, "drive_disconnected",
+ G_CALLBACK (drive_disconnected_callback),
+ monitor, 0);
monitor->details->mount_id = g_signal_connect_object (volume_monitor, "volume_mounted",
G_CALLBACK (volume_mounted_callback), monitor, 0);
monitor->details->unmount_id = g_signal_connect_object (volume_monitor, "volume_unmounted",
diff --git a/libnautilus-private/nautilus-desktop-link-monitor.h b/libnautilus-private/nautilus-desktop-link-monitor.h
index 2c3c23d..1622ced 100644
--- a/libnautilus-private/nautilus-desktop-link-monitor.h
+++ b/libnautilus-private/nautilus-desktop-link-monitor.h
@@ -59,6 +59,7 @@ void nautilus_desktop_link_monitor_delete_link (NautilusDesktopLinkMonitor *moni
/* Used by nautilus-desktop-link.c */
char * nautilus_desktop_link_monitor_make_filename_unique (NautilusDesktopLinkMonitor *monitor,
+ NautilusDesktopLink *skip_link,
const char *filename);
#endif /* NAUTILUS_DESKTOP_LINK_MONITOR_H */
diff --git a/libnautilus-private/nautilus-desktop-link.c b/libnautilus-private/nautilus-desktop-link.c
index e27bac4..9ce77c6 100644
--- a/libnautilus-private/nautilus-desktop-link.c
+++ b/libnautilus-private/nautilus-desktop-link.c
@@ -54,8 +54,8 @@ struct NautilusDesktopLinkDetails {
/* Just for trash icons: */
gulong trash_state_handler;
- /* Just for volume icons: */
- GnomeVFSVolume *volume;
+ /* Just for drive/volume icons */
+ GObject *drive_or_volume;
};
static void nautilus_desktop_link_init (gpointer object,
@@ -208,50 +208,105 @@ nautilus_desktop_link_new (NautilusDesktopLinkType type)
return link;
}
-NautilusDesktopLink *
-nautilus_desktop_link_new_from_volume (GnomeVFSVolume *volume)
+static void
+reread_drive_or_volume (NautilusDesktopLink *link)
{
- NautilusDesktopLink *link;
- GnomeVFSDrive *drive;
char *name, *filename;
+ char *display_name, *activation_uri, *icon;
- link = NAUTILUS_DESKTOP_LINK (g_object_new (NAUTILUS_TYPE_DESKTOP_LINK, NULL));
-
- link->details->type = NAUTILUS_DESKTOP_LINK_VOLUME;
+ g_assert (link->details->type == NAUTILUS_DESKTOP_LINK_VOLUME);
+ g_assert (link->details->drive_or_volume != NULL);
+
+ g_free (link->details->filename);
+ g_free (link->details->display_name);
+ g_free (link->details->activation_uri);
+ g_free (link->details->icon);
- link->details->volume = gnome_vfs_volume_ref (volume);
+ if (GNOME_IS_VFS_VOLUME (link->details->drive_or_volume)) {
+ GnomeVFSVolume *volume;
+ GnomeVFSDrive *drive;
- /* We try to use the drive name to get somewhat stable filenames
- for metadata */
- drive = gnome_vfs_volume_get_drive (volume);
- if (drive != NULL) {
- name = gnome_vfs_drive_get_display_name (drive);
+ volume = GNOME_VFS_VOLUME (link->details->drive_or_volume);
+
+ /* We try to use the drive name to get somewhat stable filenames
+ for metadata */
+ drive = gnome_vfs_volume_get_drive (volume);
+ if (drive != NULL) {
+ name = gnome_vfs_drive_get_display_name (drive);
+ } else {
+ name = gnome_vfs_volume_get_display_name (volume);
+ }
+ gnome_vfs_drive_unref (drive);
+
+ display_name = gnome_vfs_volume_get_display_name (volume);
+ activation_uri = gnome_vfs_volume_get_activation_uri (volume);
+ icon = gnome_vfs_volume_get_icon (volume);
} else {
- name = gnome_vfs_volume_get_display_name (volume);
+ GnomeVFSDrive *drive;
+
+ g_assert (GNOME_IS_VFS_DRIVE (link->details->drive_or_volume));
+
+ drive = GNOME_VFS_DRIVE (link->details->drive_or_volume);
+
+ name = gnome_vfs_drive_get_display_name (drive);
+
+ display_name = gnome_vfs_drive_get_display_name (drive);
+ activation_uri = NULL; /* We don't know the activation URI until the drive gets mounted */
+ icon = gnome_vfs_drive_get_icon (drive);
}
- gnome_vfs_drive_unref (drive);
filename = g_strconcat (name, ".volume", NULL);
link->details->filename =
nautilus_desktop_link_monitor_make_filename_unique (nautilus_desktop_link_monitor_get (),
+ link,
filename);
g_free (filename);
g_free (name);
+
+ link->details->display_name = display_name;
+ link->details->activation_uri = activation_uri;
+ link->details->icon = icon;
+}
+
+NautilusDesktopLink *
+nautilus_desktop_link_new_from_drive_or_volume (GObject *object)
+{
+ NautilusDesktopLink *link;
+ gboolean is_volume;
+
+ is_volume = GNOME_IS_VFS_VOLUME (object);
+
+ g_return_val_if_fail (GNOME_IS_VFS_DRIVE (object) || is_volume, NULL);
+
+ link = NAUTILUS_DESKTOP_LINK (g_object_new (NAUTILUS_TYPE_DESKTOP_LINK, NULL));
- link->details->display_name = gnome_vfs_volume_get_display_name (volume);
-
- link->details->activation_uri = gnome_vfs_volume_get_activation_uri (volume);
- link->details->icon = gnome_vfs_volume_get_icon (volume);
+ link->details->type = NAUTILUS_DESKTOP_LINK_VOLUME;
+
+ if (is_volume) {
+ GnomeVFSVolume *volume;
+
+ volume = gnome_vfs_volume_ref (GNOME_VFS_VOLUME (object));
+ link->details->drive_or_volume = G_OBJECT (volume);
+ } else {
+ GnomeVFSDrive *drive;
+ drive = gnome_vfs_drive_ref (GNOME_VFS_DRIVE (object));
+ link->details->drive_or_volume = G_OBJECT (drive);
+ }
+
+ reread_drive_or_volume (link);
create_icon_file (link);
return link;
}
-GnomeVFSVolume *
-nautilus_desktop_link_get_volume (NautilusDesktopLink *link)
+GObject *
+nautilus_desktop_link_get_drive_or_volume (NautilusDesktopLink *link)
{
- return gnome_vfs_volume_ref (link->details->volume);
+ if (GNOME_IS_VFS_VOLUME (link->details->drive_or_volume))
+ return G_OBJECT (gnome_vfs_volume_ref (GNOME_VFS_VOLUME (link->details->drive_or_volume)));
+ else
+ return G_OBJECT (gnome_vfs_drive_ref (GNOME_VFS_DRIVE (link->details->drive_or_volume)));
}
@@ -416,7 +471,11 @@ desktop_link_finalize (GObject *object)
}
if (link->details->type == NAUTILUS_DESKTOP_LINK_VOLUME) {
- gnome_vfs_volume_unref (link->details->volume);
+ if (GNOME_IS_VFS_VOLUME (link->details->drive_or_volume)) {
+ gnome_vfs_volume_unref (GNOME_VFS_VOLUME (link->details->drive_or_volume));
+ } else {
+ gnome_vfs_drive_unref (GNOME_VFS_DRIVE (link->details->drive_or_volume));
+ }
}
g_free (link->details->filename);
@@ -438,3 +497,61 @@ nautilus_desktop_link_class_init (gpointer klass)
object_class->finalize = desktop_link_finalize;
}
+
+void
+nautilus_desktop_link_update_from_volume (NautilusDesktopLink *link,
+ GnomeVFSVolume *volume)
+{
+ g_return_if_fail (NAUTILUS_IS_DESKTOP_LINK (link));
+ g_return_if_fail (GNOME_IS_VFS_VOLUME (volume));
+
+ g_assert (link->details->type == NAUTILUS_DESKTOP_LINK_VOLUME);
+ g_assert (link->details->drive_or_volume != NULL);
+
+ if (GNOME_IS_VFS_DRIVE (link->details->drive_or_volume)) {
+ GnomeVFSDrive *drive;
+
+ drive = gnome_vfs_volume_get_drive (volume);
+
+ g_assert (gnome_vfs_drive_compare (drive, GNOME_VFS_DRIVE (link->details->drive_or_volume)) == 0);
+ gnome_vfs_drive_unref (drive);
+
+ /* The link is for a drive. If the new volume is mounted,
+ * replace the link's object with the volume. If the new volume
+ * is unmounted, just refresh the link (who knows why we didn't
+ * get the mount notification before).
+ */
+
+ if (gnome_vfs_volume_is_mounted (volume)) {
+ gnome_vfs_drive_unref (GNOME_VFS_DRIVE (link->details->drive_or_volume));
+
+ gnome_vfs_volume_ref (volume);
+ link->details->drive_or_volume = G_OBJECT (volume);
+ }
+
+ /* The link will get updated below */
+ } else {
+ g_assert (GNOME_IS_VFS_VOLUME (link->details->drive_or_volume));
+ g_assert (gnome_vfs_volume_compare (volume, GNOME_VFS_VOLUME (link->details->drive_or_volume)) == 0);
+
+ /* If the volume got unmounted, restore the link's object to the
+ * corresponding drive. Otherwise, we shouldn't need to be
+ * called, but just update the link in that case.
+ */
+
+ if (!gnome_vfs_volume_is_mounted (volume)) {
+ GnomeVFSDrive *drive;
+
+ drive = gnome_vfs_volume_get_drive (volume);
+
+ gnome_vfs_volume_unref (GNOME_VFS_VOLUME (link->details->drive_or_volume));
+
+ link->details->drive_or_volume = G_OBJECT (drive);
+ }
+
+ /* The link will get updated below */
+ }
+
+ reread_drive_or_volume (link);
+ nautilus_desktop_link_changed (link);
+}
diff --git a/libnautilus-private/nautilus-desktop-link.h b/libnautilus-private/nautilus-desktop-link.h
index 578e592..e127500 100644
--- a/libnautilus-private/nautilus-desktop-link.h
+++ b/libnautilus-private/nautilus-desktop-link.h
@@ -26,6 +26,7 @@
#define NAUTILUS_DESKTOP_LINK_H
#include <libnautilus-private/nautilus-file.h>
+#include <libgnomevfs/gnome-vfs-drive.h>
#include <libgnomevfs/gnome-vfs-volume.h>
#define NAUTILUS_TYPE_DESKTOP_LINK \
@@ -61,7 +62,7 @@ typedef enum {
GType nautilus_desktop_link_get_type (void);
NautilusDesktopLink * nautilus_desktop_link_new (NautilusDesktopLinkType type);
-NautilusDesktopLink * nautilus_desktop_link_new_from_volume (GnomeVFSVolume *volume);
+NautilusDesktopLink * nautilus_desktop_link_new_from_drive_or_volume (GObject *object);
NautilusDesktopLinkType nautilus_desktop_link_get_link_type (NautilusDesktopLink *link);
char * nautilus_desktop_link_get_file_name (NautilusDesktopLink *link);
char * nautilus_desktop_link_get_display_name (NautilusDesktopLink *link);
@@ -70,10 +71,12 @@ char * nautilus_desktop_link_get_activation_uri (NautilusDeskto
gboolean nautilus_desktop_link_get_date (NautilusDesktopLink *link,
NautilusDateType date_type,
time_t *date);
-GnomeVFSVolume * nautilus_desktop_link_get_volume (NautilusDesktopLink *link);
+GObject * nautilus_desktop_link_get_drive_or_volume (NautilusDesktopLink *link);
gboolean nautilus_desktop_link_can_rename (NautilusDesktopLink *link);
gboolean nautilus_desktop_link_rename (NautilusDesktopLink *link,
const char *name);
+void nautilus_desktop_link_update_from_volume (NautilusDesktopLink *link,
+ GnomeVFSVolume *volume);
#endif /* NAUTILUS_DESKTOP_LINK_H */
diff --git a/src/file-manager/fm-directory-view.c b/src/file-manager/fm-directory-view.c
index 1300d1d..5279c37 100644
--- a/src/file-manager/fm-directory-view.c
+++ b/src/file-manager/fm-directory-view.c
@@ -301,11 +301,19 @@ typedef struct {
NautilusWindowOpenMode mode;
NautilusWindowOpenFlags flags;
gboolean mount_success;
- unsigned int pending_mounts;
+ GList *drives_being_mounted;
gboolean cancelled;
} ActivateParameters;
typedef struct {
+ ActivateParameters *parameters;
+
+ GnomeVFSDrive *drive;
+ NautilusFile *file;
+ guint file_changed_id;
+} DriveBeingMounted;
+
+typedef struct {
NautilusFile *file;
NautilusDirectory *directory;
} FileAndDirectory;
@@ -8277,7 +8285,7 @@ cancel_activate (gpointer callback_data)
parameters->cancelled = TRUE;
- if (parameters->pending_mounts == 0) {
+ if (parameters->drives_being_mounted == NULL) {
nautilus_file_list_cancel_call_when_ready (parameters->files_handle);
nautilus_file_list_free (parameters->files);
g_free (parameters);
@@ -8649,16 +8657,81 @@ activate_callback (GList *files, gpointer callback_data)
}
static void
+try_to_finish_drive_activation (ActivateParameters *parameters)
+{
+ if (parameters->drives_being_mounted != NULL) {
+ /* wait for other mounts to finish... */
+ return;
+ }
+
+ if (parameters->cancelled || !parameters->mount_success) {
+ stop_activate (parameters);
+
+ nautilus_file_list_free (parameters->files);
+ g_free (parameters);
+ return;
+ }
+
+ /* all drives were mounted successfully */
+ activate_activation_uris_ready_callback (parameters->files,
+ parameters);
+}
+
+static void
+remove_drive_being_mounted (DriveBeingMounted *drive_being_mounted)
+{
+ ActivateParameters *parameters;
+
+ parameters = drive_being_mounted->parameters;
+
+ if (drive_being_mounted->file_changed_id != 0) {
+ g_signal_handler_disconnect (drive_being_mounted->file, drive_being_mounted->file_changed_id);
+ }
+
+ nautilus_file_unref (drive_being_mounted->file);
+ gnome_vfs_drive_unref (drive_being_mounted->drive);
+
+ parameters->drives_being_mounted = g_list_remove (parameters->drives_being_mounted,
+ drive_being_mounted);
+ g_free (drive_being_mounted);
+}
+
+static void
+activation_file_changed_after_drive_mounted (NautilusFile *file,
+ gpointer data)
+{
+ DriveBeingMounted *drive_being_mounted;
+ ActivateParameters *parameters;
+
+ drive_being_mounted = data;
+ parameters = drive_being_mounted->parameters;
+
+ if (!gnome_vfs_drive_is_mounted (drive_being_mounted->drive)) {
+ /* Huh? The NautilusFile changed, but the drive is not mounted
+ * yet. So, wait some more until the file gets another change
+ * and the drive gets mounted.
+ */
+ return;
+ }
+
+ remove_drive_being_mounted (drive_being_mounted);
+
+ try_to_finish_drive_activation (parameters);
+}
+
+static void
activation_drive_mounted_callback (gboolean succeeded,
char *error,
char *detailed_error,
gpointer callback_data)
{
+ DriveBeingMounted *drive_being_mounted;
ActivateParameters *parameters;
- parameters = callback_data;
+ drive_being_mounted = callback_data;
+ parameters = drive_being_mounted->parameters;
- parameters->mount_success &= succeeded;
+ parameters->mount_success = parameters->mount_success && succeeded;
if (!succeeded && !parameters->cancelled) {
if (*error == 0 &&
@@ -8671,29 +8744,25 @@ activation_drive_mounted_callback (gboolean succeeded,
}
}
- if (--parameters->pending_mounts > 0) {
- /* wait for other mounts to finish... */
- return;
- }
-
- if (parameters->cancelled || !parameters->mount_success) {
- stop_activate (parameters);
+ if (gnome_vfs_drive_is_mounted (drive_being_mounted->drive)) {
+ remove_drive_being_mounted (drive_being_mounted);
+ } else {
+ /* Here, the drive is already mounted, but
+ * gnome-vfs-volume-monitor thinks that it is not. This is
+ * because gnome-vfs-daemon has not yet notified it. So we'll
+ * wait for the NautilusFile to change: this will happen
+ * when gnome-vfs-volume-monitor actually picks up and emits the
+ * volume_mounted notification, and the NautilusDesktopLink
+ * modifies the NautilusFile.
+ */
- nautilus_file_list_free (parameters->files);
- g_free (parameters);
- return;
+ drive_being_mounted->file_changed_id = g_signal_connect (
+ drive_being_mounted->file, "changed",
+ G_CALLBACK (activation_file_changed_after_drive_mounted),
+ drive_being_mounted);
}
- /* all drives were mounted successfully */
- activate_activation_uris_ready_callback (parameters->files,
- parameters);
-}
-
-static void
-mount_foreach (gpointer drive,
- gpointer callback_data)
-{
- gnome_vfs_drive_mount (drive, activation_drive_mounted_callback, callback_data);
+ try_to_finish_drive_activation (parameters);
}
static void
@@ -8701,7 +8770,6 @@ activate_activation_uris_ready_callback (GList *files_ignore,
gpointer callback_data)
{
ActivateParameters *parameters;
- GList *not_yet_mounted;
GList *l, *next;
NautilusFile *file;
NautilusFile *actual_file;
@@ -8710,7 +8778,6 @@ activate_activation_uris_ready_callback (GList *files_ignore,
char *uri;
parameters = callback_data;
- not_yet_mounted = NULL;
for (l = parameters->files; l != NULL; l = next) {
file = NAUTILUS_FILE (l->data);
@@ -8733,24 +8800,46 @@ activate_activation_uris_ready_callback (GList *files_ignore,
drive = nautilus_file_get_drive (file);
if (drive != NULL &&
!gnome_vfs_drive_is_mounted (drive)) {
- not_yet_mounted = g_list_prepend (not_yet_mounted, drive);
- parameters->pending_mounts++;
+ DriveBeingMounted *drive_being_mounted;
+
+ drive_being_mounted = g_new (DriveBeingMounted, 1);
+ drive_being_mounted->parameters = parameters;
+ drive_being_mounted->drive = gnome_vfs_drive_ref (drive);
+ drive_being_mounted->file = nautilus_file_ref (file);
+ drive_being_mounted->file_changed_id = 0;
+
+ parameters->drives_being_mounted = g_list_prepend (parameters->drives_being_mounted,
+ drive_being_mounted);
}
}
}
if (parameters->files == NULL) {
- g_assert (not_yet_mounted == NULL);
+ g_assert (parameters->drives_being_mounted == NULL);
stop_activate (parameters);
g_free (parameters);
return;
}
- if (not_yet_mounted != NULL) {
- not_yet_mounted = g_list_reverse (not_yet_mounted);
- g_list_foreach (not_yet_mounted, mount_foreach, callback_data);
- g_list_free (not_yet_mounted);
+ if (parameters->drives_being_mounted != NULL) {
+ GList *l;
+
+ parameters->drives_being_mounted = g_list_reverse (parameters->drives_being_mounted);
+
+ for (l = parameters->drives_being_mounted; l; l = l->next) {
+ DriveBeingMounted *drive_being_mounted;
+
+ drive_being_mounted = l->data;
+
+ /* @#$% gnome_vfs_drive_mount() doesn't tell the
+ * callback *which* drive was mounted. So, we pass the
+ * drive as part of the drive_being_mounted closure.
+ */
+ gnome_vfs_drive_mount (drive_being_mounted->drive,
+ activation_drive_mounted_callback,
+ drive_being_mounted);
+ }
/* activation_drive_mounted_callback will reveal whether all mounts were successful */
parameters->mount_success = TRUE;
@@ -8874,7 +8963,7 @@ fm_directory_view_activate_files (FMDirectoryView *view,
parameters->mode = mode;
parameters->flags = flags;
parameters->mount_success = FALSE;
- parameters->pending_mounts = 0;
+ parameters->drives_being_mounted = NULL;
parameters->cancelled = FALSE;
if (file_count == 1) {
