static void
mpd_devices_tile_init (MpdDevicesTile *self)
{
MpdDevicesTilePrivate *priv = GET_PRIVATE (self);
ClutterActor *tile;
GList *mounts;
priv->tiles = g_hash_table_new (g_direct_hash, g_direct_equal);
priv->vbox = mx_box_layout_new ();
mx_box_layout_set_enable_animations (MX_BOX_LAYOUT (priv->vbox),
TRUE);
mx_box_layout_set_orientation (MX_BOX_LAYOUT (priv->vbox),
MX_ORIENTATION_VERTICAL);
clutter_container_add_actor (CLUTTER_CONTAINER (self), priv->vbox);
tile = mpd_default_device_tile_new ();
clutter_container_add_actor (CLUTTER_CONTAINER (priv->vbox), tile);
priv->monitor = g_volume_monitor_get ();
g_signal_connect (priv->monitor, "mount-added",
G_CALLBACK (_monitor_mount_added_cb), self);
g_signal_connect (priv->monitor, "mount-changed",
G_CALLBACK (_monitor_mount_changed_cb), self);
g_signal_connect (priv->monitor, "mount-removed",
G_CALLBACK (_monitor_mount_removed_cb), self);
mounts = g_volume_monitor_get_mounts (priv->monitor);
g_list_foreach (mounts, (GFunc) _add_mount_cb, self);
g_list_free (mounts);
}
static GList *
get_mounts (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_mounts (child_monitor));
}
g_rec_mutex_unlock (&the_volume_monitor_mutex);
return res;
}
void fileops_empty_trash ()
{
if (pool == NULL) {
pool = g_thread_pool_new(_empty_trash_job, NULL, -1, FALSE, NULL);
atexit(destroy_thread_pool);
}
GList* trash_list = NULL;
GVolumeMonitor* vol_monitor = g_volume_monitor_get ();
GList* mount_list = g_volume_monitor_get_mounts (vol_monitor);
g_object_unref (vol_monitor);
//iterate through all mounts
GList* l;
for (l = mount_list; l != NULL; l = l->next)
{
trash_list = g_list_concat (trash_list,
_get_trash_dirs_for_mount (l->data));
}
g_list_free_full (mount_list, g_object_unref);
//add 'trash:' prefix
trash_list = g_list_prepend (trash_list,
g_file_new_for_uri ("trash:"));
g_thread_pool_push(pool, trash_list, NULL);
}
static gboolean
mounts_setup (TrackerStorage *storage)
{
TrackerStoragePrivate *priv;
GList *mounts, *lm;
priv = TRACKER_STORAGE_GET_PRIVATE (storage);
mounts = g_volume_monitor_get_mounts (priv->volume_monitor);
if (!mounts) {
g_message ("No mounts found to iterate");
return TRUE;
}
/* Iterate over all available mounts and add them.
* Note that GVolumeMonitor shows only those mounts which are
* actually mounted. */
for (lm = mounts; lm; lm = g_list_next (lm)) {
mount_add (storage, lm->data);
g_object_unref (lm->data);
}
g_list_free (mounts);
return TRUE;
}
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);
}
void GioLister::Init() {
monitor_.reset_without_add(g_volume_monitor_get());
// Get existing volumes
GList* const volumes = g_volume_monitor_get_volumes(monitor_);
for (GList* p=volumes; p; p=p->next) {
GVolume* volume = static_cast<GVolume*>(p->data);
VolumeAdded(volume);
g_object_unref(volume);
}
g_list_free(volumes);
// Get existing mounts
GList* const mounts = g_volume_monitor_get_mounts(monitor_);
for (GList* p=mounts; p; p=p->next) {
GMount* mount = static_cast<GMount*>(p->data);
MountAdded(mount);
g_object_unref(mount);
}
g_list_free(mounts);
// Connect signals from the monitor
CHECKED_GCONNECT(monitor_, "volume-added", &VolumeAddedCallback, this);
CHECKED_GCONNECT(monitor_, "volume-removed", &VolumeRemovedCallback, this);
CHECKED_GCONNECT(monitor_, "mount-added", &MountAddedCallback, this);
CHECKED_GCONNECT(monitor_, "mount-changed", &MountChangedCallback, this);
CHECKED_GCONNECT(monitor_, "mount-removed", &MountRemovedCallback, this);
}
static void
test_mounts (void)
{
GList *mounts, *l;
mounts = g_volume_monitor_get_mounts (monitor);
for (l = mounts; l; l = l->next)
{
GMount *mount = l->data;
GVolume *volume;
GDrive *drive;
drive = g_mount_get_drive (mount);
volume = g_mount_get_volume (mount);
do_mount_tests (drive, volume, mount);
if (drive != NULL)
g_object_unref (drive);
if (volume != NULL)
g_object_unref (volume);
}
g_list_free_full (mounts, g_object_unref);
}
static void
unmount_all_with_scheme (const char *scheme)
{
GVolumeMonitor *volume_monitor;
GList *mounts;
GList *l;
volume_monitor = g_volume_monitor_get();
/* populate gvfs network mounts */
iterate_gmain();
mounts = g_volume_monitor_get_mounts (volume_monitor);
for (l = mounts; l != NULL; l = l->next) {
GMount *mount = G_MOUNT (l->data);
GFile *root;
root = g_mount_get_root (mount);
if (g_file_has_uri_scheme (root, scheme)) {
unmount (root);
}
g_object_unref (root);
}
g_list_foreach (mounts, (GFunc)g_object_unref, NULL);
g_list_free (mounts);
g_object_unref (volume_monitor);
}
static void
print_mounts (const char *prefix)
{
GList *l;
GList *mounts;
GVolumeMonitor *volume_monitor;
volume_monitor = g_volume_monitor_get ();
mounts = g_volume_monitor_get_mounts (volume_monitor);
if (mounts != NULL)
{
for (l = mounts; l != NULL; l = l->next)
{
GMount *mount = l->data;
GFile *mount_root;
char *uri;
mount_root = g_mount_get_root (mount);
uri = g_file_get_uri (mount_root);
if (prefix == NULL ||
g_str_has_prefix (uri, prefix))
g_print ("%s\n", uri);
g_free (uri);
g_object_unref (mount_root);
g_object_unref (mount);
}
g_list_free (mounts);
}
g_object_unref (volume_monitor);
if (prefix == NULL || g_str_has_prefix ("file:///", prefix))
g_print ("file:///\n");
}
void fileops_empty_trash ()
{
GList* trash_list = NULL;
GVolumeMonitor* vol_monitor = g_volume_monitor_get ();
GList* mount_list = g_volume_monitor_get_mounts (vol_monitor);
g_object_unref (vol_monitor);
//iterate through all mounts
GList* l;
for (l = mount_list; l != NULL; l = l->next)
{
trash_list = g_list_concat (trash_list,
_get_trash_dirs_for_mount (l->data));
}
g_list_free_full (mount_list, g_object_unref);
//add 'trash:' prefix
trash_list = g_list_prepend (trash_list,
g_file_new_for_uri ("trash:"));
g_io_scheduler_push_job (_empty_trash_job,
trash_list,
NULL,
0,
NULL);
}
static const char* get_icon_for_path(const char* path)
{
GVolumeMonitor *monitor;
GList *mounts;
uint i;
GMount *mount;
GIcon *icon;
const char* name = "";
monitor = g_volume_monitor_get ();
mounts = g_volume_monitor_get_mounts (monitor);
for (i = 0; i < g_list_length (mounts); i++) {
mount = G_MOUNT (g_list_nth_data(mounts, i));
if (strcmp(g_mount_get_name(mount), path))
continue;
icon = g_mount_get_icon (mount);
if (!icon)
continue;
name = g_icon_to_string (icon);
g_object_unref (icon);
}
g_list_free_full (mounts, g_object_unref);
return name;
}
static gboolean
bookmark_location_mounted_callback (NemoBookmark *bookmark,
GFile *location,
NemoBookmarkList *bookmarks)
{
gboolean ret = FALSE;
GList *volumes = g_volume_monitor_get_mounts (bookmarks->volume_monitor);
GList *iter = volumes;
while (iter != NULL) {
GMount *mount = G_MOUNT (iter->data);
GFile *mount_location = g_mount_get_root (mount);
gchar *mount_root_uri = g_file_get_uri (mount_location);
gchar *location_uri = g_file_get_uri (location);
ret = g_str_has_prefix (location_uri, mount_root_uri);
g_free (mount_root_uri);
g_free (location_uri);
g_object_unref (mount_location);
if (ret == TRUE)
break;
iter = iter->next;
}
g_list_free_full (volumes, (GDestroyNotify) g_object_unref);
return ret;
}
static char *
shell_util_get_file_display_name_if_mount (GFile *file)
{
GFile *compare;
GVolumeMonitor *monitor;
GList *mounts, *l;
char *ret;
ret = NULL;
/* compare with all mounts */
monitor = g_volume_monitor_get ();
mounts = g_volume_monitor_get_mounts (monitor);
for (l = mounts; l != NULL; l = l->next)
{
GMount *mount;
mount = G_MOUNT(l->data);
compare = g_mount_get_root (mount);
if (!ret && g_file_equal (file, compare))
ret = g_mount_get_name (mount);
g_object_unref (mount);
}
g_list_free (mounts);
g_object_unref (monitor);
return ret;
}
/**
* pk_backend_initialize:
* This should only be run once per backend load, i.e. not every transaction
*/
void
pk_backend_initialize (GKeyFile *conf, PkBackend *backend)
{
gboolean ret;
GFile *file = NULL;
GError *error = NULL;
GKeyFile *key_file = NULL;
gchar *config_file = NULL;
GList *mounts;
/* use logging */
pk_debug_add_log_domain (G_LOG_DOMAIN);
pk_debug_add_log_domain ("Yum");
/* create private area */
priv = g_new0 (PkBackendYumPrivate, 1);
g_debug ("backend: initialize");
priv->spawn = pk_backend_spawn_new (conf);
pk_backend_spawn_set_filter_stderr (priv->spawn, pk_backend_stderr_cb);
pk_backend_spawn_set_filter_stdout (priv->spawn, pk_backend_stdout_cb);
pk_backend_spawn_set_name (priv->spawn, "yum");
pk_backend_spawn_set_allow_sigkill (priv->spawn, FALSE);
/* coldplug the mounts */
priv->volume_monitor = g_volume_monitor_get ();
mounts = g_volume_monitor_get_mounts (priv->volume_monitor);
g_list_foreach (mounts, (GFunc) pk_backend_mount_add, NULL);
g_list_foreach (mounts, (GFunc) g_object_unref, NULL);
g_list_free (mounts);
/* setup a file monitor on the repos directory */
file = g_file_new_for_path (YUM_REPOS_DIRECTORY);
priv->monitor = g_file_monitor_directory (file, G_FILE_MONITOR_NONE, NULL, &error);
if (priv->monitor != NULL) {
g_signal_connect (priv->monitor, "changed", G_CALLBACK (pk_backend_yum_repos_changed_cb), backend);
} else {
g_warning ("failed to setup monitor: %s", error->message);
g_error_free (error);
}
/* read the config file */
key_file = g_key_file_new ();
config_file = g_build_filename (SYSCONFDIR, "PackageKit", "Yum.conf", NULL);
g_debug ("loading configuration from %s", config_file);
ret = g_key_file_load_from_file (key_file, config_file, G_KEY_FILE_NONE, &error);
if (!ret) {
g_warning ("failed to load Yum.conf: %s", error->message);
g_error_free (error);
goto out;
}
out:
g_free (config_file);
if (key_file != NULL)
g_key_file_free (key_file);
if (file != NULL)
g_object_unref (file);
}
// -------------------------------------------------------------------------------- //
void guGIO_VolumeMonitor::GetCurrentMounts( void )
{
GList * Mounts = g_volume_monitor_get_mounts( m_VolumeMonitor );
if( Mounts )
{
g_list_foreach( Mounts, GFunc( append_mount ), this );
g_list_free( Mounts );
}
}
int32_t dt_camera_import_backup_job_run(dt_job_t *job)
{
// copy sourcefile to each found destination
dt_camera_import_backup_t *t = (dt_camera_import_backup_t *)job->param;
GVolumeMonitor *vmgr= g_volume_monitor_get();
GList *mounts=g_volume_monitor_get_mounts(vmgr);
GMount *mount=NULL;
GFile *root=NULL;
if( mounts !=NULL )
do
{
mount=G_MOUNT(mounts->data);
if( ( root=g_mount_get_root( mount ) ) != NULL )
{
// Got the mount point lets check for backup folder
gchar *backuppath=NULL;
gchar *rootpath=g_file_get_path(root);
backuppath=g_build_path(G_DIR_SEPARATOR_S,rootpath,dt_conf_get_string("plugins/capture/backup/foldername"),(char *)NULL);
g_free(rootpath);
if( g_file_test(backuppath,G_FILE_TEST_EXISTS)==TRUE)
{
// Found a backup storage, lets copy file here..
gchar *destinationfile=g_build_filename(G_DIR_SEPARATOR_S,backuppath,t->destinationfile,(char *)NULL);
if( g_mkdir_with_parents(g_path_get_dirname(destinationfile),0755) >= 0 )
{
gchar *content;
gsize size;
if( g_file_get_contents(t->sourcefile,&content,&size,NULL) == TRUE )
{
GError *err=NULL;
if( g_file_set_contents(destinationfile,content,size,&err) != TRUE)
{
fprintf(stderr,"Failed to set content of file with reason: %s\n",err->message);
g_error_free(err);
}
g_free(content);
}
}
g_free(destinationfile);
}
g_free(backuppath);
}
}
while( (mounts=g_list_next(mounts)) !=NULL);
// Release volume manager
g_object_unref(vmgr);
return 0;
}
void init_ASMount(ASFlagType flags, const char *cmd)
{
memset( &AppState, 0x00, sizeof(AppState));
AppState.flags = flags ;
AppState.tileWidth = DEFAULT_TILE_WIDTH;
AppState.tileHeight = DEFAULT_TILE_HEIGHT;
createMainWindow();
reloadButtons();
AppState.volumes = create_asbidirlist (ASVolume_destroy);
g_type_init();
GVolumeMonitor * monitor = g_volume_monitor_get();
g_signal_connect_object (monitor, "mount-added", G_CALLBACK (mount_added), NULL, 0);
g_signal_connect_object (monitor, "mount-changed", G_CALLBACK (mount_changed), NULL, 0);
g_signal_connect_object (monitor, "mount-removed", G_CALLBACK (mount_removed), NULL, 0);
g_signal_connect_object (monitor, "volume-added", G_CALLBACK (volume_added), NULL, 0);
g_signal_connect_object (monitor, "volume-changed", G_CALLBACK (volume_changed), NULL, 0);
g_signal_connect_object (monitor, "volume-removed", G_CALLBACK (volume_removed), NULL, 0);
GList *tmp;
GList *list = g_volume_monitor_get_volumes(G_VOLUME_MONITOR(monitor));
show_activity ("Adding volumes...");
for (tmp = list; tmp != NULL; tmp = tmp->next) {
ASVolume *v = ASVolume_newGVolume (tmp->data);
if (v)
append_bidirelem (AppState.volumes, v);
else
g_object_unref (tmp->data);
}
g_list_free (list);
#if 1
show_activity ("Adding mounts...");
list = g_volume_monitor_get_mounts(G_VOLUME_MONITOR(monitor));
for (tmp = list; tmp != NULL; tmp = tmp->next) {
ASVolume *v = ASVolume_newGMount (tmp->data);
if (v)
append_bidirelem (AppState.volumes, v);
else
g_object_unref (tmp->data);
}
g_list_free (list);
#endif
AppState.volumeMonitor = monitor;
redecorateVolumes ();
}
static GMount *
find_mount_for_device (GUdevDevice *device)
{
GMount *mount = NULL;
const char *device_file;
GVolumeMonitor *volmon;
GList *mounts;
GList *i;
device_file = g_udev_device_get_device_file (device);
if (device_file == NULL) {
return NULL;
}
volmon = g_volume_monitor_get ();
mounts = g_volume_monitor_get_mounts (volmon);
g_object_unref (volmon);
for (i = mounts; i != NULL; i = i->next) {
GVolume *v;
v = g_mount_get_volume (G_MOUNT (i->data));
if (v != NULL) {
char *devname = NULL;
gboolean match;
devname = g_volume_get_identifier (v, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE);
g_object_unref (v);
if (devname == NULL)
continue;
match = g_str_equal (devname, device_file);
g_free (devname);
if (match) {
mount = G_MOUNT (i->data);
g_object_ref (G_OBJECT (mount));
break;
}
}
}
g_list_foreach (mounts, (GFunc)g_object_unref, NULL);
g_list_free (mounts);
return mount;
}
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;
}
/**
* mcm_profile_store_add_profiles_from_mounted_volumes:
**/
static gboolean
mcm_profile_store_add_profiles_from_mounted_volumes (McmProfileStore *profile_store)
{
gboolean ret;
gboolean success = FALSE;
GList *mounts, *l;
GMount *mount;
McmProfileStorePrivate *priv = profile_store->priv;
/* get all current mounts */
mounts = g_volume_monitor_get_mounts (priv->volume_monitor);
for (l = mounts; l != NULL; l = l->next) {
mount = l->data;
ret = mcm_profile_store_add_profiles_from_mounted_volume (profile_store, mount);
if (ret)
success = TRUE;
g_object_unref (mount);
}
g_list_free (mounts);
return success;
}
GList *
rhythmdb_get_active_mounts (RhythmDB *db)
{
GList *mounts;
GList *mountpoints = NULL;
GList *i;
mounts = g_volume_monitor_get_mounts (db->priv->volume_monitor);
for (i = mounts; i != NULL; i = i->next) {
GFile *root;
char *mountpoint;
GMount *mount = i->data;
root = g_mount_get_root (mount);
mountpoint = g_file_get_uri (root);
mountpoints = g_list_prepend (mountpoints, mountpoint);
g_object_unref (root);
}
rb_list_destroy_free (mounts, (GDestroyNotify) g_object_unref);
return mountpoints;
}
static gchar *
get_tracker_volume_name (const gchar *uri,
const gchar *datasource)
{
gchar *source_name = NULL;
GVolumeMonitor *volume_monitor;
GList *mounts, *mount;
GFile *file;
if (uri != NULL && *uri != '\0') {
volume_monitor = g_volume_monitor_get ();
mounts = g_volume_monitor_get_mounts (volume_monitor);
file = g_file_new_for_uri (uri);
mount = mounts;
while (mount != NULL) {
GFile *m_file = g_mount_get_root (G_MOUNT (mount->data));
if (g_file_equal (m_file, file)) {
gchar *m_name = g_mount_get_name (G_MOUNT (mount->data));
g_object_unref (G_OBJECT (m_file));
source_name = g_strdup_printf (_("Removable - %s"), m_name);
g_free (m_name);
break;
}
g_object_unref (G_OBJECT (m_file));
mount = mount->next;
}
g_list_free_full (mounts, g_object_unref);
g_object_unref (G_OBJECT (file));
g_object_unref (G_OBJECT (volume_monitor));
} else {
source_name = g_strdup (_("Local files"));
}
return source_name;
}
static void
desktop_volumes_visible_changed (gpointer callback_data)
{
NautilusDesktopLinkMonitor *monitor;
GList *l, *mounts;
monitor = NAUTILUS_DESKTOP_LINK_MONITOR (callback_data);
if (g_settings_get_boolean (nautilus_desktop_preferences,
NAUTILUS_PREFERENCES_DESKTOP_VOLUMES_VISIBLE)) {
if (monitor->details->mount_links == NULL) {
mounts = g_volume_monitor_get_mounts (monitor->details->volume_monitor);
for (l = mounts; l != NULL; l = l->next) {
create_mount_link (monitor, l->data);
g_object_unref (l->data);
}
g_list_free (mounts);
}
} else {
g_list_foreach (monitor->details->mount_links, (GFunc)g_object_unref, NULL);
g_list_free (monitor->details->mount_links);
monitor->details->mount_links = NULL;
}
}
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;
}
/**
* rb_removable_media_manager_scan:
* @manager: the #RBRemovableMediaManager
*
* Initiates a new scan of all attached media. Newly activated plugins that use
* the create-source-volume or create-source-mount signals should call this if
* the 'scanned' property is %TRUE. Otherwise, the first scan will catch any
* existing volumes or mounts that the plugin is interested in.
*/
void
rb_removable_media_manager_scan (RBRemovableMediaManager *manager)
{
RBRemovableMediaManagerPrivate *priv = GET_PRIVATE (manager);
GHashTableIter iter;
GList *list, *it;
gpointer hkey, hvalue;
priv->scanned = TRUE;
/* check volumes first */
list = g_volume_monitor_get_volumes (priv->volume_monitor);
/* - check for volumes that have disappeared */
g_hash_table_iter_init (&iter, priv->volume_mapping);
while (g_hash_table_iter_next (&iter, &hkey, &hvalue)) {
GVolume *volume = G_VOLUME (hkey);
if (g_list_index (list, volume) == -1) {
/* volume has vanished */
rb_removable_media_manager_remove_volume (manager, volume);
}
}
/* - check for newly added volumes */
for (it = list; it != NULL; it = g_list_next (it)) {
GVolume *volume = G_VOLUME (it->data);
rb_removable_media_manager_add_volume (manager, volume);
g_object_unref (volume);
}
g_list_free (list);
/* check mounts */
list = g_volume_monitor_get_mounts (priv->volume_monitor);
/* - check for mounts that have disappeared */
g_hash_table_iter_init (&iter, priv->mount_mapping);
while (g_hash_table_iter_next (&iter, &hkey, &hvalue)) {
GMount *mount = G_MOUNT (hkey);
if (g_list_index (list, mount) == -1) {
rb_removable_media_manager_remove_mount (manager, mount);
}
}
/* - check for newly added mounts */
for (it = list; it != NULL; it = g_list_next (it)) {
GMount *mount = G_MOUNT (it->data);
rb_removable_media_manager_add_mount (manager, mount);
g_object_unref (mount);
}
g_list_free (list);
/* - check devices */
#if defined(HAVE_GUDEV)
list = g_udev_client_query_by_subsystem (priv->gudev_client, "usb");
for (it = list; it != NULL; it = g_list_next (it)) {
/* pretend the device was just added */
uevent_cb (priv->gudev_client, "add", G_UDEV_DEVICE (it->data), manager);
}
g_list_free (list);
#endif
}
static void
nautilus_desktop_link_monitor_init (NautilusDesktopLinkMonitor *monitor)
{
GList *l, *mounts;
GMount *mount;
monitor->details = G_TYPE_INSTANCE_GET_PRIVATE (monitor, NAUTILUS_TYPE_DESKTOP_LINK_MONITOR,
NautilusDesktopLinkMonitorDetails);
the_link_monitor = monitor;
monitor->details->volume_monitor = g_volume_monitor_get ();
/* We keep around a ref to the desktop dir */
monitor->details->desktop_dir = nautilus_directory_get_by_uri (EEL_DESKTOP_URI);
/* Default links */
create_link_and_add_preference (&monitor->details->home_link,
NAUTILUS_DESKTOP_LINK_HOME,
NAUTILUS_PREFERENCES_DESKTOP_HOME_VISIBLE,
G_CALLBACK (desktop_home_visible_changed),
monitor);
create_link_and_add_preference (&monitor->details->trash_link,
NAUTILUS_DESKTOP_LINK_TRASH,
NAUTILUS_PREFERENCES_DESKTOP_TRASH_VISIBLE,
G_CALLBACK (desktop_trash_visible_changed),
monitor);
create_link_and_add_preference (&monitor->details->network_link,
NAUTILUS_DESKTOP_LINK_NETWORK,
NAUTILUS_PREFERENCES_DESKTOP_NETWORK_VISIBLE,
G_CALLBACK (desktop_network_visible_changed),
monitor);
/* Mount links */
mounts = g_volume_monitor_get_mounts (monitor->details->volume_monitor);
for (l = mounts; l != NULL; l = l->next) {
mount = l->data;
create_mount_link (monitor, mount);
g_object_unref (mount);
}
g_list_free (mounts);
g_signal_connect_swapped (nautilus_desktop_preferences,
"changed::" NAUTILUS_PREFERENCES_DESKTOP_VOLUMES_VISIBLE,
G_CALLBACK (desktop_volumes_visible_changed),
monitor);
monitor->details->mount_id =
g_signal_connect_object (monitor->details->volume_monitor, "mount-added",
G_CALLBACK (mount_added_callback), monitor, 0);
monitor->details->unmount_id =
g_signal_connect_object (monitor->details->volume_monitor, "mount-removed",
G_CALLBACK (mount_removed_callback), monitor, 0);
monitor->details->changed_id =
g_signal_connect_object (monitor->details->volume_monitor, "mount-changed",
G_CALLBACK (mount_changed_callback), monitor, 0);
}
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);
}
/* 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
grl_optical_media_source_browse (GrlSource *source,
GrlSourceBrowseSpec *bs)
{
GList *mounts, *l;
GrlOpticalMediaSourcePrivate *priv = GRL_OPTICAL_MEDIA_SOURCE (source)->priv;
BrowseData *data;
GList *media_list;
GRL_DEBUG ("%s", __FUNCTION__);
g_list_free_full (priv->list, g_object_unref);
media_list = NULL;
/* Look for loopback-mounted ISO images and discs */
mounts = g_volume_monitor_get_mounts (priv->monitor);
for (l = mounts; l != NULL; l = l->next) {
GMount *mount = l->data;
if (!ignore_mount (mount)) {
GrlMedia *media;
media = create_media_from_mount (mount);
if (media)
media_list = g_list_prepend (media_list, media);
}
g_object_unref (mount);
}
g_list_free (mounts);
/* 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->media);
resolve_disc_urls (data);
}
