ASVolume *ASVolume_newGMount (GMount *g_m)
{
ASVolume *v;
if (g_m == NULL || g_mount_is_shadowed (g_m))
return NULL;
else {
GVolume *volume = g_mount_get_volume (g_m);
if (volume) {
g_object_unref (volume);
return NULL;
}
}
v = ASVolume_create();
v->gMount = g_m;
v->name = g_mount_get_name (v->gMount);
if (g_mount_can_eject (g_m))
set_flags (v->flags, ASVolume_Ejectable);
set_flags (v->flags, ASVolume_Mounted);
v->icon = g_mount_get_icon (g_m);
ASVolume_parseGnomeIconString (v);
{
char *mount_str = ASVolume_toString(v);
show_activity("%s\n", mount_str);
safefree(mount_str);
}
return v;
}
static void
rb_removable_media_manager_add_mount (RBRemovableMediaManager *mgr, GMount *mount)
{
RBRemovableMediaManagerPrivate *priv = GET_PRIVATE (mgr);
RBSource *source = NULL;
GVolume *volume;
GFile *mount_root;
char *mountpoint;
MPIDDevice *device_info;
g_assert (mount != NULL);
if (g_hash_table_lookup (priv->mount_mapping, mount) != NULL) {
return;
}
if (g_mount_is_shadowed (mount) != FALSE) {
return;
}
volume = g_mount_get_volume (mount);
if (volume == NULL) {
rb_debug ("Unhandled media, no volume for mount");
return;
}
/* if we've already created a source for the volume,
* don't do anything with the mount.
*/
if (g_hash_table_lookup (priv->volume_mapping, volume) != NULL) {
rb_debug ("already created a source for the volume, so ignoring the mount");
g_object_unref (volume);
return;
}
dump_volume_identifiers (volume);
g_object_unref (volume);
/* look the device up in the device info database */
mount_root = g_mount_get_root (mount);
if (mount_root == NULL) {
rb_debug ("unable to get mount root, can't create a source for this mount");
return;
}
mountpoint = g_file_get_path (mount_root);
g_object_unref (mount_root);
device_info = mpid_device_new (mountpoint);
g_free (mountpoint);
g_signal_emit (G_OBJECT (mgr), rb_removable_media_manager_signals[CREATE_SOURCE_MOUNT], 0, mount, device_info, &source);
if (source) {
g_hash_table_insert (priv->mount_mapping, mount, source);
rb_removable_media_manager_append_media_source (mgr, source);
} else {
rb_debug ("Unhandled media");
}
g_object_unref (device_info);
}
// -------------------------------------------------------------------------------- //
void guGIO_VolumeMonitor::OnMountAdded( GMount * mount )
{
guLogMessage( wxT( "Mount Added..." ) );
if( FindMount( mount ) == wxNOT_FOUND )
{
if( g_mount_is_shadowed( mount ) )
{
//g_object_unref( mount );
guLogMessage( wxT( "ignored shadowed mount" ) );
return;
}
GVolume * Volume = g_mount_get_volume( mount );
if( !Volume )
{
guLogMessage( wxT( "mount without volume?" ) );
//g_object_unref( mount );
return;
}
g_object_unref( Volume );
GFile * MountRoot = g_mount_get_root( mount );
if( MountRoot )
{
char * mount_path = g_file_get_path( MountRoot );
if( mount_path )
{
wxString MountPath = wxString( mount_path, wxConvUTF8 );
guGIO_Mount * Mount = new guGIO_Mount( mount, MountPath );
if( Mount )
{
m_MountedVolumes->Add( Mount );
wxCommandEvent event( wxEVT_COMMAND_MENU_SELECTED, ID_VOLUMEMANAGER_MOUNT_CHANGED );
event.SetInt( 1 );
wxPostEvent( m_MainFrame, event );
}
g_free( mount_path );
}
g_object_unref( MountRoot );
}
else
{
guLogMessage( wxT( "ignored mount without mount root" ) );
g_object_unref( mount );
return;
}
}
else
{
guLogMessage( wxT( "Mount already added?" ) );
}
}
static void
mount_changed_callback (GVolumeMonitor *volume_monitor,
GMount *mount,
NautilusDesktopLinkMonitor *monitor)
{
/* TODO: update the mount with other details */
/* remove a mount if it goes into the shadows */
if (g_mount_is_shadowed (mount) && has_mount (monitor, mount)) {
remove_mount_link (monitor, mount);
}}
static void
create_mount_link (NautilusDesktopLinkMonitor *monitor,
GMount *mount)
{
NautilusDesktopLink *link;
if (has_mount (monitor, mount))
return;
if ((!g_mount_is_shadowed (mount)) &&
g_settings_get_boolean (nautilus_desktop_preferences,
NAUTILUS_PREFERENCES_DESKTOP_VOLUMES_VISIBLE)) {
link = nautilus_desktop_link_new_from_mount (mount);
monitor->details->mount_links = g_list_prepend (monitor->details->mount_links, link);
}
}
static void
rb_removable_media_manager_add_volume (RBRemovableMediaManager *mgr, GVolume *volume)
{
RBRemovableMediaManagerPrivate *priv = GET_PRIVATE (mgr);
RBRemovableMediaSource *source = NULL;
GMount *mount;
g_assert (volume != NULL);
if (g_hash_table_lookup (priv->volume_mapping, volume) != NULL) {
return;
}
mount = g_volume_get_mount (volume);
if (mount != NULL) {
#if GLIB_CHECK_VERSION(2, 20, 0)
if (g_mount_is_shadowed (mount) != FALSE) {
rb_debug ("mount is shadowed, so ignoring the volume");
g_object_unref (mount);
return;
}
#endif
if (g_hash_table_lookup (priv->mount_mapping, mount) != NULL) {
/* this can probably never happen, but it's OK */
rb_debug ("already created a source for the mount, so ignoring the volume");
g_object_unref (mount);
return;
}
g_object_unref (mount);
}
dump_volume_identifiers (volume);
g_signal_emit (G_OBJECT (mgr), rb_removable_media_manager_signals[CREATE_SOURCE_VOLUME], 0, volume, &source);
if (source) {
g_hash_table_insert (priv->volume_mapping, volume, source);
rb_removable_media_manager_append_media_source (mgr, RB_SOURCE (source));
} else {
rb_debug ("Unhandled media");
}
}
GMount *
nautilus_get_mounted_mount_for_root (GFile *location)
{
GVolumeMonitor *volume_monitor;
GList *mounts;
GList *l;
GMount *mount;
GMount *result = NULL;
GFile *root = NULL;
GFile *default_location = NULL;
volume_monitor = g_volume_monitor_get ();
mounts = g_volume_monitor_get_mounts (volume_monitor);
for (l = mounts; l != NULL; l = l->next) {
mount = l->data;
if (g_mount_is_shadowed (mount)) {
continue;
}
root = g_mount_get_root (mount);
if (g_file_equal (location, root)) {
result = g_object_ref (mount);
break;
}
default_location = g_mount_get_default_location (mount);
if (!g_file_equal (default_location, root) &&
g_file_equal (location, default_location)) {
result = g_object_ref (mount);
break;
}
}
g_clear_object (&root);
g_clear_object (&default_location);
g_list_free_full (mounts, g_object_unref);
return result;
}
/* NOTE: This function needs to be synchroniced with the one used for
* notifications in gnome-settings-daemon mount plugin. */
static gboolean
_mount_is_wanted_device (GMount *mount)
{
gboolean removed;
/* shadowed mounts are not supposed to be shown to user */
if (g_mount_is_shadowed (mount)) {
return FALSE;
}
removed = GPOINTER_TO_INT (
g_object_get_data (G_OBJECT (mount), "mpd-removed-already"));
if (removed) {
/* already removed mounts sometimes emit mount-changed. must keep
* track of removals here.. */
/* TODO the right way to do this would be to just disconnect
* the mount-changed signal handler in _monitor_mount_removed_cb() */
return FALSE;
}
return TRUE;
}
static void
list_mounts (GList *mounts,
int indent,
gboolean only_with_no_volume)
{
GList *l;
int c;
GMount *mount;
GVolume *volume;
char *name, *uuid, *uri;
GFile *root, *default_location;
GIcon *icon;
char **x_content_types;
char *type_name;
const gchar *sort_key;
for (c = 0, l = mounts; l != NULL; l = l->next, c++)
{
mount = (GMount *) l->data;
if (only_with_no_volume)
{
volume = g_mount_get_volume (mount);
if (volume != NULL)
{
g_object_unref (volume);
continue;
}
}
name = g_mount_get_name (mount);
root = g_mount_get_root (mount);
uri = g_file_get_uri (root);
g_print ("%*sMount(%d): %s -> %s\n", indent, "", c, name, uri);
type_name = get_type_name (mount);
g_print ("%*sType: %s\n", indent+2, "", type_name);
g_free (type_name);
if (extra_detail)
{
uuid = g_mount_get_uuid (mount);
if (uuid)
g_print ("%*suuid=%s\n", indent + 2, "", uuid);
default_location = g_mount_get_default_location (mount);
if (default_location)
{
char *loc_uri = g_file_get_uri (default_location);
g_print ("%*sdefault_location=%s\n", indent + 2, "", loc_uri);
g_free (loc_uri);
g_object_unref (default_location);
}
icon = g_mount_get_icon (mount);
if (icon)
{
if (G_IS_THEMED_ICON (icon))
show_themed_icon_names (G_THEMED_ICON (icon), indent + 2);
g_object_unref (icon);
}
x_content_types = g_mount_guess_content_type_sync (mount, FALSE, NULL, NULL);
if (x_content_types != NULL && g_strv_length (x_content_types) > 0)
{
int n;
g_print ("%*sx_content_types:", indent + 2, "");
for (n = 0; x_content_types[n] != NULL; n++)
g_print (" %s", x_content_types[n]);
g_print ("\n");
}
g_strfreev (x_content_types);
g_print ("%*scan_unmount=%d\n", indent + 2, "", g_mount_can_unmount (mount));
g_print ("%*scan_eject=%d\n", indent + 2, "", g_mount_can_eject (mount));
g_print ("%*sis_shadowed=%d\n", indent + 2, "", g_mount_is_shadowed (mount));
sort_key = g_mount_get_sort_key (mount);
if (sort_key != NULL)
g_print ("%*ssort_key=%s\n", indent + 2, "", sort_key);
g_free (uuid);
}
g_object_unref (root);
g_free (name);
g_free (uri);
}
}
/* this is loosely based on update_places() from caja-places-sidebar.c */
static void
panel_place_menu_item_append_remote_gio (PanelPlaceMenuItem *place_item,
GtkWidget *menu)
{
GtkWidget *add_menu;
GList *mounts, *l;
GMount *mount;
GSList *add_mounts, *sl;
/* add mounts that has no volume (/etc/mtab mounts, ftp, sftp,...) */
mounts = g_volume_monitor_get_mounts (place_item->priv->volume_monitor);
add_mounts = NULL;
for (l = mounts; l; l = l->next) {
GVolume *volume;
GFile *root;
mount = l->data;
if (g_mount_is_shadowed (mount)) {
g_object_unref (mount);
continue;
}
volume = g_mount_get_volume (mount);
if (volume != NULL) {
g_object_unref (volume);
g_object_unref (mount);
continue;
}
root = g_mount_get_root (mount);
if (g_file_is_native (root)) {
g_object_unref (root);
g_object_unref (mount);
continue;
}
g_object_unref (root);
add_mounts = g_slist_prepend (add_mounts, mount);
}
add_mounts = g_slist_reverse (add_mounts);
if (g_slist_length (add_mounts) <= MAX_ITEMS_OR_SUBMENU) {
add_menu = menu;
} else {
GtkWidget *item;
item = panel_image_menu_item_new ();
setup_menu_item_with_icon (item, panel_menu_icon_get_size (),
PANEL_ICON_NETWORK_SERVER,
NULL, NULL,
_("Network Places"));
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_widget_show (item);
add_menu = create_empty_menu ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), add_menu);
}
for (sl = add_mounts; sl; sl = sl->next) {
mount = sl->data;
panel_menu_item_append_mount (add_menu, mount);
g_object_unref (mount);
}
g_slist_free (add_mounts);
g_list_free (mounts);
}
/* this is loosely based on update_places() from caja-places-sidebar.c */
static void
panel_place_menu_item_append_local_gio (PanelPlaceMenuItem *place_item,
GtkWidget *menu)
{
GList *l;
GList *ll;
GList *drives;
GDrive *drive;
GList *volumes;
GVolume *volume;
GList *mounts;
GMount *mount;
GSList *items;
GSList *sl;
PanelGioItem *item;
GtkWidget *add_menu;
items = NULL;
/* first go through all connected drives */
drives = g_volume_monitor_get_connected_drives (place_item->priv->volume_monitor);
for (l = drives; l != NULL; l = l->next) {
drive = l->data;
volumes = g_drive_get_volumes (drive);
if (volumes != NULL) {
for (ll = volumes; ll != NULL; ll = ll->next) {
volume = ll->data;
mount = g_volume_get_mount (volume);
item = g_slice_new (PanelGioItem);
if (mount != NULL) {
item->type = PANEL_GIO_MOUNT;
item->u.mount = mount;
} else {
/* Do show the unmounted volumes; this
* is so the user can mount it (in case
* automounting is off).
*
* Also, even if automounting is
* enabled, this gives a visual cue
* that the user should remember to
* yank out the media if he just
* unmounted it.
*/
item->type = PANEL_GIO_VOLUME;
item->u.volume = g_object_ref (volume);
}
items = g_slist_prepend (items, item);
g_object_unref (volume);
}
g_list_free (volumes);
} else {
if (g_drive_is_media_removable (drive) &&
!g_drive_is_media_check_automatic (drive)) {
/* If the drive has no mountable volumes and we
* cannot detect media change.. we display the
* drive so the user can manually poll the
* drive by clicking on it..."
*
* This is mainly for drives like floppies
* where media detection doesn't work.. but
* it's also for human beings who like to turn
* off media detection in the OS to save
* battery juice.
*/
item = g_slice_new (PanelGioItem);
item->type = PANEL_GIO_DRIVE;
item->u.drive = g_object_ref (drive);
items = g_slist_prepend (items, item);
}
}
g_object_unref (drive);
}
g_list_free (drives);
/* add all volumes that is not associated with a drive */
volumes = g_volume_monitor_get_volumes (place_item->priv->volume_monitor);
for (l = volumes; l != NULL; l = l->next) {
volume = l->data;
drive = g_volume_get_drive (volume);
if (drive != NULL) {
g_object_unref (volume);
g_object_unref (drive);
continue;
}
mount = g_volume_get_mount (volume);
item = g_slice_new (PanelGioItem);
if (mount != NULL) {
item->type = PANEL_GIO_MOUNT;
item->u.mount = mount;
} else {
/* see comment above in why we add an icon for an
* unmounted mountable volume */
item->type = PANEL_GIO_VOLUME;
item->u.volume = g_object_ref (volume);
}
items = g_slist_prepend (items, item);
g_object_unref (volume);
}
g_list_free (volumes);
/* add mounts that has no volume (/etc/mtab mounts, ftp, sftp,...) */
mounts = g_volume_monitor_get_mounts (place_item->priv->volume_monitor);
for (l = mounts; l != NULL; l = l->next) {
GFile *root;
mount = l->data;
if (g_mount_is_shadowed (mount)) {
g_object_unref (mount);
continue;
}
volume = g_mount_get_volume (mount);
if (volume != NULL) {
g_object_unref (volume);
g_object_unref (mount);
continue;
}
root = g_mount_get_root (mount);
if (!g_file_is_native (root)) {
g_object_unref (root);
g_object_unref (mount);
continue;
}
g_object_unref (root);
item = g_slice_new (PanelGioItem);
item->type = PANEL_GIO_MOUNT;
item->u.mount = mount;
items = g_slist_prepend (items, item);
}
g_list_free (mounts);
/* now that we have everything, add the items inline or in a submenu */
items = g_slist_reverse (items);
if (g_slist_length (items) <= MAX_ITEMS_OR_SUBMENU) {
add_menu = menu;
} else {
GtkWidget *item;
item = gtk_image_menu_item_new ();
setup_menu_item_with_icon (item, panel_menu_icon_get_size (),
PANEL_ICON_REMOVABLE_MEDIA,
NULL, NULL,
_("Removable Media"));
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_widget_show (item);
add_menu = create_empty_menu ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), add_menu);
}
for (sl = items; sl; sl = sl->next) {
item = sl->data;
switch (item->type) {
case PANEL_GIO_DRIVE:
panel_menu_item_append_drive (add_menu, item->u.drive);
g_object_unref (item->u.drive);
break;
case PANEL_GIO_VOLUME:
panel_menu_item_append_volume (add_menu, item->u.volume);
g_object_unref (item->u.volume);
break;
case PANEL_GIO_MOUNT:
panel_menu_item_append_mount (add_menu, item->u.mount);
g_object_unref (item->u.mount);
break;
default:
g_assert_not_reached ();
}
g_slice_free (PanelGioItem, item);
}
g_slist_free (items);
}
static void
mount_add (TrackerStorage *storage,
GMount *mount)
{
TrackerStoragePrivate *priv;
GFile *root;
GVolume *volume;
gchar *mount_name, *mount_path, *uuid;
gboolean is_optical = FALSE;
gboolean is_removable = FALSE;
/* Get mount name */
mount_name = g_mount_get_name (mount);
/* Get root path of the mount */
root = g_mount_get_root (mount);
mount_path = g_file_get_path (root);
g_debug ("Found '%s' mounted on path '%s'",
mount_name,
mount_path);
/* Do not process shadowed mounts! */
if (g_mount_is_shadowed (mount)) {
g_debug (" Skipping shadowed mount '%s'", mount_name);
g_object_unref (root);
g_free (mount_path);
g_free (mount_name);
return;
}
priv = TRACKER_STORAGE_GET_PRIVATE (storage);
/* fstab partitions may not have corresponding
* GVolumes, so volume may be NULL */
volume = g_mount_get_volume (mount);
if (volume) {
/* GMount with GVolume */
/* Try to get UUID from the Volume.
* Note that g_volume_get_uuid() is NOT equivalent */
uuid = g_volume_get_identifier (volume,
G_VOLUME_IDENTIFIER_KIND_UUID);
if (!uuid) {
gchar *content_type;
gboolean is_multimedia;
gboolean is_blank;
/* Optical discs usually won't have UUID in the GVolume */
content_type = mount_guess_content_type (mount, &is_optical, &is_multimedia, &is_blank);
is_removable = TRUE;
/* We don't index content which is video, music or blank */
if (!is_multimedia && !is_blank) {
uuid = g_compute_checksum_for_string (G_CHECKSUM_MD5,
mount_name,
-1);
g_debug (" No UUID, generated:'%s' (based on mount name)", uuid);
g_debug (" Assuming GVolume has removable media, if wrong report a bug! "
"content type is '%s'",
content_type);
} else {
g_debug (" Being ignored because mount with volume is music/video/blank "
"(content type:%s, optical:%s, multimedia:%s, blank:%s)",
content_type,
is_optical ? "yes" : "no",
is_multimedia ? "yes" : "no",
is_blank ? "yes" : "no");
}
g_free (content_type);
} else {
/* Any other removable media will have UUID in the
* GVolume. Note that this also may include some
* partitions in the machine which have GVolumes
* associated to the GMounts. We also check a drive
* exists to be sure the device is local. */
GDrive *drive;
drive = g_volume_get_drive (volume);
if (drive) {
/* We can't mount/unmount system volumes, so tag
* them as non removable. */
is_removable = g_volume_can_mount (volume);
g_debug (" Found mount with volume and drive which %s be mounted: "
"Assuming it's %s removable, if wrong report a bug!",
is_removable ? "can" : "cannot",
is_removable ? "" : "not");
g_object_unref (drive);
} else {
/* Note: not sure when this can happen... */
g_debug (" Mount with volume but no drive, "
"assuming not a removable device, "
"if wrong report a bug!");
is_removable = FALSE;
}
}
g_object_unref (volume);
} else {
/* GMount without GVolume.
* Note: Never found a case where this g_mount_get_uuid() returns
* non-NULL... :-) */
uuid = g_mount_get_uuid (mount);
if (!uuid) {
if (mount_path) {
gchar *content_type;
gboolean is_multimedia;
gboolean is_blank;
content_type = mount_guess_content_type (mount, &is_optical, &is_multimedia, &is_blank);
/* Note: for GMounts without GVolume, is_blank should NOT be considered,
* as it may give unwanted results... */
if (!is_multimedia) {
uuid = g_compute_checksum_for_string (G_CHECKSUM_MD5,
mount_path,
-1);
g_debug (" No UUID, generated:'%s' (based on mount path)", uuid);
} else {
g_debug (" Being ignored because mount is music/video "
"(content type:%s, optical:%s, multimedia:%s)",
content_type,
is_optical ? "yes" : "no",
is_multimedia ? "yes" : "no");
}
g_free (content_type);
} else {
g_debug (" Being ignored because mount has no GVolume (i.e. not user mountable) "
"and has no mount root path available");
}
}
}
/* If we got something to be used as UUID, then add the mount
* to the TrackerStorage */
if (uuid && mount_path && !g_hash_table_lookup (priv->mounts_by_uuid, uuid)) {
g_debug (" Adding mount point with UUID: '%s', removable: %s, optical: %s, path: '%s'",
uuid,
is_removable ? "yes" : "no",
is_optical ? "yes" : "no",
mount_path);
mount_add_new (storage, uuid, mount_path, mount_name, is_removable, is_optical);
} else {
g_debug (" Skipping mount point with UUID: '%s', path: '%s', already managed: '%s'",
uuid ? uuid : "none",
mount_path ? mount_path : "none",
(uuid && g_hash_table_lookup (priv->mounts_by_uuid, uuid)) ? "yes" : "no");
}
g_free (mount_name);
g_free (mount_path);
g_free (uuid);
g_object_unref (root);
}
static void
update_device_source_list (DialogData *data)
{
gboolean source_available = FALSE;
GList *mounts;
GList *scan;
gtk_list_store_clear (data->device_list_store);
mounts = g_volume_monitor_get_mounts (g_volume_monitor_get ());
for (scan = mounts; scan; scan = scan->next) {
GMount *mount = scan->data;
GtkTreeIter iter;
GFile *root;
GIcon *icon;
char *name;
GDrive *drive;
if (g_mount_is_shadowed (mount))
continue;
gtk_list_store_append (data->device_list_store, &iter);
root = g_mount_get_root (mount);
if (data->source == NULL)
data->source = g_file_dup (root);
icon = g_mount_get_icon (mount);
name = g_mount_get_name (mount);
drive = g_mount_get_drive (mount);
if (drive != NULL) {
char *drive_name;
char *tmp;
drive_name = g_drive_get_name (drive);
tmp = g_strconcat (drive_name, ": ", name, NULL);
g_free (name);
g_object_unref (drive);
name = tmp;
g_free (drive_name);
}
gtk_list_store_set (data->device_list_store, &iter,
SOURCE_LIST_COLUMN_MOUNT, mount,
SOURCE_LIST_COLUMN_ICON, icon,
SOURCE_LIST_COLUMN_NAME, name,
-1);
if (g_file_equal (data->source, root)) {
source_available = TRUE;
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (data->device_chooser), &iter);
}
g_free (name);
g_object_unref (icon);
g_object_unref (root);
}
if (! source_available) {
_g_object_unref (data->source);
data->source = NULL;
load_file_list (data);
}
_g_object_list_unref (mounts);
}
static VALUE
rg_shadowed_p(VALUE self)
{
return CBOOL2RVAL(g_mount_is_shadowed(_SELF(self)));
}
