static void
list_monitor_items(void)
{
GVolumeMonitor *volume_monitor;
GList *drives, *volumes, *mounts;
volume_monitor = g_volume_monitor_get();
/* populate gvfs network mounts */
iterate_gmain();
drives = g_volume_monitor_get_connected_drives (volume_monitor);
list_drives (drives, 0);
g_list_foreach (drives, (GFunc)g_object_unref, NULL);
g_list_free (drives);
volumes = g_volume_monitor_get_volumes (volume_monitor);
list_volumes (volumes, 0, TRUE);
g_list_foreach (volumes, (GFunc)g_object_unref, NULL);
g_list_free (volumes);
mounts = g_volume_monitor_get_mounts (volume_monitor);
list_mounts (mounts, 0, TRUE);
g_list_foreach (mounts, (GFunc)g_object_unref, NULL);
g_list_free (mounts);
g_object_unref (volume_monitor);
}
static GDrive *_cd_find_drive_from_name (const gchar *cName)
{
g_return_val_if_fail (cName != NULL, NULL);
cd_message ("%s (%s)", __func__, cName);
GVolumeMonitor *pVolumeMonitor = g_volume_monitor_get ();
GDrive *pFoundDrive = NULL;
//\___________________ On chope les disques connectes (lecteur de CD/disquette/etc) et on liste leurs volumes.
GList *pDrivesList = g_volume_monitor_get_connected_drives (pVolumeMonitor);
GList *dl;
GDrive *pDrive;
gchar *cDriveName;
for (dl = pDrivesList; dl != NULL; dl = dl->next)
{
pDrive = dl->data;
if (pFoundDrive == NULL)
{
cDriveName = g_drive_get_name (pDrive);
cd_message (" drive '%s'", cDriveName);
if (cDriveName != NULL && strcmp (cDriveName, cName) == 0)
pFoundDrive = pDrive;
else
g_object_unref (pDrive);
//g_free (cDriveName);
}
else
g_object_unref (pDrive);
}
g_list_free (pDrivesList);
return pFoundDrive;
}
static GList *
get_connected_drives (GVolumeMonitor *volume_monitor)
{
GUnionVolumeMonitor *monitor;
GVolumeMonitor *child_monitor;
GList *res;
GList *l;
monitor = G_UNION_VOLUME_MONITOR (volume_monitor);
res = NULL;
g_rec_mutex_lock (&the_volume_monitor_mutex);
for (l = monitor->monitors; l != NULL; l = l->next)
{
child_monitor = l->data;
res = g_list_concat (res, g_volume_monitor_get_connected_drives (child_monitor));
}
g_rec_mutex_unlock (&the_volume_monitor_mutex);
return res;
}
static void
test_connected_drives (void)
{
GList *drives;
GList *l;
drives = g_volume_monitor_get_connected_drives (monitor);
for (l = drives; l; l = l->next)
{
GDrive *drive = l->data;
do_drive_tests (drive);
}
g_list_free_full (drives, g_object_unref);
}
static void
test_connected_drives (void)
{
GList *drives;
GList *l;
drives = g_volume_monitor_get_connected_drives (monitor);
for (l = drives; l; l = l->next)
{
GDrive *drive = l->data;
do_drive_tests (drive);
}
g_list_foreach (drives, (GFunc)g_object_unref, NULL);
g_list_free (drives);
}
/* 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
grl_optical_media_source_browse (GrlSource *source,
GrlSourceBrowseSpec *bs)
{
GList *drives;
GList *volumes;
GList *l;
GrlOpticalMediaSourcePrivate *priv = GRL_OPTICAL_MEDIA_SOURCE (source)->priv;
BrowseData *data;
GList *media_list;
GRL_DEBUG ("%s", __FUNCTION__);
media_list = NULL;
/* Get the drives */
drives = g_volume_monitor_get_connected_drives (priv->monitor);
for (l = drives; l != NULL; l = l->next) {
GDrive *drive = l->data;
media_list = add_drive (media_list, drive, GRL_OPTICAL_MEDIA_SOURCE (source));
g_object_unref (drive);
}
g_list_free (drives);
/* Look for mounted ISO images */
volumes = g_volume_monitor_get_volumes (priv->monitor);
for (l = volumes; l != NULL; l = l->next) {
GVolume *volume = l->data;
char *path;
path = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE);
if (path != NULL && g_str_has_prefix (path, "/dev/loop"))
media_list = add_volume (media_list, volume, NULL, GRL_OPTICAL_MEDIA_SOURCE (source));
g_free (path);
g_object_unref (volume);
}
g_list_free (volumes);
/* Got nothing? */
if (media_list == NULL) {
/* Tell the caller we're done */
bs->callback (bs->source,
bs->operation_id,
NULL,
0,
bs->user_data,
NULL);
return;
}
media_list = g_list_reverse (media_list);
/* And go to resolve all those devices */
data = g_new0 (BrowseData, 1);
data->source = source;
data->bs = bs;
data->media_list = media_list;
data->cancellable = g_cancellable_new ();
grl_operation_set_data (bs->operation_id, data->cancellable);
data->parser = totem_pl_parser_new ();
g_object_set (data->parser, "recurse", FALSE, NULL);
g_signal_connect (G_OBJECT (data->parser), "entry-parsed",
G_CALLBACK (entry_parsed_cb), data);
resolve_disc_urls (data);
}
static void
test_disc (gconstpointer data)
{
TotemDiscMediaType type;
GError *error = NULL;
char *mrl = NULL;
const char *device = (const char*) data;
type = totem_cd_detect_type_with_url (device, &mrl, &error);
if (type == MEDIA_TYPE_ERROR) {
GList *or, *list;
GVolumeMonitor *mon;
g_message ("Error getting media type: %s", error ? error->message : "unknown reason");
g_message ("List of connected drives:");
mon = g_volume_monitor_get ();
for (or = list = g_volume_monitor_get_connected_drives (mon); list != NULL; list = list->next) {
char *device_id;
device_id = g_drive_get_identifier ((GDrive *) list->data, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE);
g_message ("\t%s", device_id);
g_free (device_id);
g_object_unref (list->data);
}
if (or == NULL)
g_message ("\tNo connected drives!");
else
g_list_free (or);
g_message ("List of volumes:");
for (or = list = g_volume_monitor_get_volumes (mon); list != NULL; list = list->next) {
char *device_id;
device_id = g_volume_get_identifier ((GVolume *) list->data, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE);
if (g_volume_get_mount ((GVolume *) list->data) == NULL)
g_message ("\t%s", device_id);
else
g_message ("\t%s (mounted)", device_id);
g_free (device_id);
g_object_unref (list->data);
}
if (or == NULL)
g_message ("\tNo volumes!");
else
g_list_free (or);
return;
}
if (type != MEDIA_TYPE_DATA)
g_message ("%s contains a %s.", device, totem_cd_get_human_readable_name (type));
else
g_message ("%s contains a data disc", device);
g_assert (mrl != NULL);
g_message ("MRL for directory is \"%s\".", mrl);
g_free (mrl);
return;
}
GList *vfs_backend_list_volumes (void)
{
GVolumeMonitor *pVolumeMonitor = g_volume_monitor_get ();
GList *pIconsList = NULL;
Icon *pNewIcon;
//\___________________ On chope les disques connectes (lecteur de CD/disquette/etc) et on liste leurs volumes.
GList *pDrivesList = g_volume_monitor_get_connected_drives (pVolumeMonitor);
GList *pAssociatedVolumes;
GList *dl, *av;
GDrive *pDrive;
GVolume *pVolume;
for (dl = pDrivesList; dl != NULL; dl = dl->next)
{
pDrive = dl->data;
cd_message ("drive '%s'", g_drive_get_name (pDrive));
pAssociatedVolumes = g_drive_get_volumes (pDrive);
if (pAssociatedVolumes != NULL)
{
for (av = pAssociatedVolumes; av != NULL; av = av->next)
{
pVolume = av->data;
cd_message (" + volume '%s'", g_volume_get_name (pVolume));
pNewIcon = _cd_get_icon_for_volume (pVolume, NULL);
if (pNewIcon != NULL)
pIconsList = g_list_prepend (pIconsList, pNewIcon);
//g_object_unref (pVolume);
}
g_list_free (pAssociatedVolumes);
}
else // le disque n'a aucun volume montable
{
cd_message (" le disque n'a aucun volume montable");
/*if (g_drive_is_media_removable (pDrive) && ! g_drive_is_media_check_automatic (pDrive))
{
g_drive_get_icon (pDrive);
g_drive_get_name (pDrive);
}*/
}
//g_object_unref (pDrive);
}
g_list_free (pDrivesList);
//\___________________ On chope les volumes qui ne sont pas associes a un disque.
GList *pVolumesList = g_volume_monitor_get_volumes (pVolumeMonitor);
GList *v;
for (v = pVolumesList; v != NULL; v = v->next)
{
pVolume = v->data;
cd_message ("volume '%s'", g_volume_get_name (pVolume));
pDrive = g_volume_get_drive (pVolume);
if (pDrive != NULL) // on l'a deja liste dans la 1ere boucle.
{
cd_message (" drive '%s' est deja liste", g_drive_get_name (pDrive));
//g_object_unref (pDrive);
}
else
{
cd_message (" + volume '%s'\n", g_volume_get_name (pVolume));
if (pNewIcon != NULL)
pNewIcon = _cd_get_icon_for_volume (pVolume, NULL);
pIconsList = g_list_prepend (pIconsList, pNewIcon);
}
//g_object_unref (pVolume);
}
g_list_free (pVolumesList);
//\___________________ On chope les points de montage qui n'ont pas de volumes. (montage de mtab, ftp, etc)
GList *pMountsList = g_volume_monitor_get_mounts (pVolumeMonitor);
GMount *pMount;
GList *m;
for (m = pMountsList; m != NULL; m = m->next)
{
pMount = m->data;
cd_message ("mount '%s'", g_mount_get_name (pMount));
pVolume = g_mount_get_volume (pMount);
if (pVolume != NULL) // on l'a deja liste precedemment.
{
cd_message ("volume '%s' est deja liste", g_volume_get_name (pVolume));
//g_object_unref (pVolume);
}
else
{
cd_message ("+ volume '%s'", g_volume_get_name (pVolume));
if (pNewIcon != NULL)
pNewIcon = _cd_get_icon_for_volume (NULL, pMount);
pIconsList = g_list_prepend (pIconsList, pNewIcon);
}
//g_object_unref (pMount);
}
g_list_free (pMountsList);
return pIconsList;
}
static VALUE
rg_connected_drives(VALUE self)
{
return GLIST2ARY_FREE(g_volume_monitor_get_connected_drives(_SELF(self)));
}
