inline static gboolean automount_volume(GVolume* vol, gboolean silent)
{
GMount* mount;
if(!g_volume_should_automount(vol) || !g_volume_can_mount(vol))
return FALSE;
mount = g_volume_get_mount(vol);
if(!mount) /* not mounted, automount is needed */
{
g_debug("try automount");
if(!fm_mount_volume(NULL, vol, !silent))
return FALSE;
if(silent)
return TRUE;
mount = g_volume_get_mount(vol);
g_debug("mount = %p", mount);
}
if(mount)
{
if(!silent && app_config->autorun) /* show autorun dialog */
show_autorun_dlg(vol, mount);
g_object_unref(mount);
}
return TRUE;
}
void activate_row(FmPlacesView* view, guint button, GtkTreePath* tree_path)
{
GtkTreeIter it;
if(gtk_tree_model_get_iter(GTK_TREE_MODEL(model), &it, tree_path))
{
FmPlaceItem* item;
FmPath* path;
gtk_tree_model_get(GTK_TREE_MODEL(model), &it, FM_PLACES_MODEL_COL_INFO, &item, -1);
if(!item)
return;
switch(item->type)
{
case FM_PLACES_ITEM_PATH:
path = fm_path_ref(item->fi->path);
break;
case FM_PLACES_ITEM_VOL:
{
GFile* gf;
GMount* mnt = g_volume_get_mount(item->vol);
if(!mnt)
{
GtkWindow* parent = GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(view)));
if(!fm_mount_volume(parent, item->vol, TRUE))
return;
mnt = g_volume_get_mount(item->vol);
if(!mnt)
{
g_debug("GMount is invalid after successful g_volume_mount().\nThis is quite possibly a gvfs bug.\nSee https://bugzilla.gnome.org/show_bug.cgi?id=552168");
return;
}
}
gf = g_mount_get_root(mnt);
g_object_unref(mnt);
if(gf)
{
path = fm_path_new_for_gfile(gf);
g_object_unref(gf);
}
else
path = NULL;
break;
}
default:
return;
}
if(path)
{
g_signal_emit(view, signals[CHDIR], 0, button, path);
fm_path_unref(path);
}
}
}
static void
xfdesktop_volume_icon_menu_unmount(GtkWidget *widget, gpointer user_data)
{
XfdesktopVolumeIcon *icon = XFDESKTOP_VOLUME_ICON(user_data);
GtkWidget *icon_view = xfdesktop_icon_peek_icon_view(XFDESKTOP_ICON(icon));
GtkWidget *toplevel = gtk_widget_get_toplevel(icon_view);
GVolume *volume;
GMount *mount;
GMountOperation *operation;
volume = xfdesktop_volume_icon_peek_volume(icon);
mount = g_volume_get_mount(volume);
if(!mount)
return;
#ifdef HAVE_LIBNOTIFY
xfdesktop_notify_unmount(mount);
#endif
operation = gtk_mount_operation_new(toplevel ? GTK_WINDOW(toplevel) : NULL);
gtk_mount_operation_set_screen(GTK_MOUNT_OPERATION(operation),
icon->priv->gscreen);
g_mount_unmount_with_operation(mount,
G_MOUNT_UNMOUNT_NONE,
operation,
NULL,
xfdesktop_volume_icon_unmount_finish,
g_object_ref(icon));
g_object_unref(mount);
g_object_unref(operation);
}
static gboolean
check_audio_cd (GVolume *volume)
{
GFile *file;
char *activation_uri;
GMount *mount;
if (!volume)
return FALSE;
mount = g_volume_get_mount (volume);
if (!mount)
return FALSE;
file = g_mount_get_root (mount);
g_object_unref (mount);
if (!file)
return FALSE;
activation_uri = g_file_get_uri (file);
g_object_unref (file);
/* we have an audioCD if the activation URI starts by 'cdda://' */
gboolean result = (strncmp ("cdda://", activation_uri, 7) == 0);
g_free (activation_uri);
return result;
}
static void on_vol_changed(GVolumeMonitor* vm, GVolume* vol, gpointer user_data)
{
GMount* mount = g_volume_get_mount(vol);
g_debug("vol: %p is changed, mount = %p", vol, mount);
if(mount)
g_object_unref(mount);
}
static guint
impl_want_uri (RBSource *source, const char *uri)
{
GVolume *volume;
GMount *mount;
GFile *file;
int retval;
retval = 0;
file = g_file_new_for_uri (uri);
if (g_file_has_uri_scheme (file, "cdda") == FALSE) {
g_object_unref (file);
return 0;
}
g_object_get (G_OBJECT (source),
"volume", &volume,
NULL);
if (volume == NULL)
return 0;
mount = g_volume_get_mount (volume);
if (mount) {
GFile *root;
root = g_mount_get_root (mount);
retval = g_file_equal (root, file) ? 100 : 0;
g_object_unref (mount);
g_object_unref (root);
}
g_object_unref (file);
return retval;
}
static void
do_volume_tests (GDrive *drive, GVolume *volume)
{
GDrive *d;
gchar *name;
GMount *mount;
gchar *uuid;
name = g_volume_get_name (volume);
g_assert (name != NULL);
g_free (name);
d = g_volume_get_drive (volume);
g_assert (d == drive);
if (d != NULL)
g_object_unref (d);
mount = g_volume_get_mount (volume);
if (mount != NULL)
{
do_mount_tests (drive, volume, mount);
g_object_unref (mount);
}
uuid = g_volume_get_uuid (volume);
if (uuid)
{
GVolume *v;
v = g_volume_monitor_get_volume_for_uuid (monitor, uuid);
g_assert (v == volume);
g_object_unref (v);
g_free (uuid);
}
}
static gboolean
xfdesktop_volume_icon_activated(XfdesktopIcon *icon_p)
{
XfdesktopVolumeIcon *icon = XFDESKTOP_VOLUME_ICON(icon_p);
GVolume *volume = xfdesktop_volume_icon_peek_volume(icon);
GMount *mount;
TRACE("entering");
mount = g_volume_get_mount(volume);
if(!mount) {
/* set the activated flag so we can chain the event up to the
* parent class in the mount finish callback */
g_object_set_qdata(G_OBJECT(icon), xfdesktop_volume_icon_activated_quark,
GUINT_TO_POINTER(TRUE));
/* mount the volume and open the folder in the mount finish callback */
xfdesktop_volume_icon_menu_mount(NULL, icon);
return TRUE;
} else {
g_object_unref(mount);
/* chain up to the parent class (where the mount point folder is
* opened in the file manager) */
return XFDESKTOP_ICON_CLASS(xfdesktop_volume_icon_parent_class)->activated(icon_p);
}
}
static GList *
add_volume (GList *media_list,
GVolume *volume,
GDrive *drive,
GrlOpticalMediaSource *source)
{
char *name, *icon_uri;
GIcon *icon;
char *device_path, *id;
GrlMedia * media;
GMount *mount;
device_path = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE);
if (device_path == NULL)
return media_list;
/* Is it an audio CD or a blank media */
mount = g_volume_get_mount (volume);
if (mount != NULL) {
GFile *root;
root = g_mount_get_root (mount);
g_object_unref (mount);
if (g_file_has_uri_scheme (root, "burn") != FALSE || g_file_has_uri_scheme (root, "cdda") != FALSE) {
/* We don't add Audio CDs, or blank media */
g_object_unref (root);
g_free (device_path);
return media_list;
}
g_object_unref (root);
}
media = grl_media_video_new ();
id = g_filename_to_uri (device_path, NULL, NULL);
g_free (device_path);
grl_media_set_id (media, id);
g_free (id);
/* Work out an icon to display */
icon = g_volume_get_icon (volume);
icon_uri = get_uri_for_gicon (icon);
g_object_unref (icon);
grl_media_set_thumbnail (media, icon_uri);
g_free (icon_uri);
/* Get the volume's pretty name for the menu label */
name = g_volume_get_name (volume);
g_strstrip (name);
grl_media_set_title (media, name);
g_free (name);
grl_media_set_mime (media, "x-special/device-block");
return g_list_prepend (media_list, media);
}
static GFile* get_volume_root(GVolume* volume) {
GFile* root = NULL;
if (is_sdb(volume)) {
GMount* mount = g_volume_get_mount(volume);
root = g_mount_get_root(mount);
g_object_unref(mount);
}
return root;
}
/**
* fm_unmount_volume
* @parent: a window to place dialog over it
* @vol: the mounted volume
* @interactive: %TRUE to open dialog window
*
* Unmounts a volume.
*
* Returns: %TRUE in case of success.
*
* Since: 0.1.0
*/
gboolean fm_unmount_volume(GtkWindow* parent, GVolume* vol, gboolean interactive)
{
GMount* mount = g_volume_get_mount(vol);
gboolean ret;
if(!mount)
return FALSE;
ret = fm_do_mount(parent, G_OBJECT(vol), UMOUNT_MOUNT, interactive);
g_object_unref(mount);
return ret;
}
void on_umount(GtkAction* act, gpointer user_data)
{
PlaceItem* item = (PlaceItem*)user_data;
GMount* mnt = g_volume_get_mount(item->vol);
if(mnt)
{
fm_unmount_mount(NULL, mnt);
g_object_unref(mnt);
}
}
static void update_vol(FmPlacesModel* model, FmPlaceItem* item, GtkTreeIter* it, FmFileInfoJob* job)
{
FmIcon* icon;
GIcon* gicon;
char* name;
GdkPixbuf* pix;
GMount* mount;
FmPath* path;
name = g_volume_get_name(item->vol);
if(item->fi->icon)
fm_icon_unref(item->fi->icon);
gicon = g_volume_get_icon(item->vol);
icon = fm_icon_from_gicon(gicon);
item->fi->icon = icon;
g_object_unref(gicon);
mount = g_volume_get_mount(item->vol);
if(mount)
{
GFile* gf = g_mount_get_root(mount);
path = fm_path_new_for_gfile(gf);
g_object_unref(gf);
g_object_unref(mount);
item->vol_mounted = TRUE;
}
else
{
path = NULL;
item->vol_mounted = FALSE;
}
if(!fm_path_equal(item->fi->path, path))
{
fm_file_info_set_path(item->fi, path);
if(path)
{
if(job)
fm_file_info_job_add(job, path);
else
{
job = fm_file_info_job_new(NULL, FM_FILE_INFO_JOB_FOLLOW_SYMLINK);
model->jobs = g_slist_prepend(model->jobs, job);
g_signal_connect(job, "finished", G_CALLBACK(on_file_info_job_finished), model);
fm_job_run_async(FM_JOB(job));
}
fm_path_unref(path);
}
}
pix = fm_icon_get_pixbuf(item->fi->icon, fm_config->pane_icon_size);
gtk_list_store_set(GTK_LIST_STORE(model), it, FM_PLACES_MODEL_COL_ICON, pix, FM_PLACES_MODEL_COL_LABEL, name, -1);
g_object_unref(pix);
g_free(name);
}
void on_mount(GtkAction* act, gpointer user_data)
{
PlaceItem* item = (PlaceItem*)user_data;
GMount* mnt = g_volume_get_mount(item->vol);
if(!mnt)
{
if(!fm_mount_volume(NULL, item->vol))
return;
}
else
g_object_unref(mnt);
}
GMount *get_mount_for_uuid(GVolumeMonitor *mon, const char *uuid)
{
GUDisksVolumeMonitor* umon = G_UDISKS_VOLUME_MONITOR(mon);
GList* l;
for(l = umon->volumes; l; l=l->next)
{
GUDisksVolume* vol = G_UDISKS_VOLUME(l->data);
if(g_strcmp0(vol->dev->uuid, uuid) == 0)
return g_volume_get_mount(G_VOLUME(vol));
}
return NULL;
}
void on_row_activated(GtkTreeView* view, GtkTreePath* tree_path, GtkTreeViewColumn *col)
{
GtkTreeIter it;
if(gtk_tree_model_get_iter(GTK_TREE_MODEL(model), &it, tree_path))
{
PlaceItem* item;
FmPath* path;
gtk_tree_model_get(GTK_TREE_MODEL(model), &it, COL_INFO, &item, -1);
if(!item)
return;
switch(item->type)
{
case PLACE_PATH:
path = fm_path_ref(item->path);
break;
case PLACE_VOL:
{
GFile* gf;
GMount* mnt = g_volume_get_mount(item->vol);
if(!mnt)
{
if(!fm_mount_volume(NULL, item->vol))
return;
mnt = g_volume_get_mount(item->vol);
}
gf = g_mount_get_root(mnt);
g_object_unref(mnt);
path = fm_path_new_for_gfile(gf);
g_object_unref(gf);
break;
}
default:
return;
}
g_signal_emit(view, signals[CHDIR], 0, path);
fm_path_unref(path);
}
}
static void unmountVolume (ASVolume *v)
{
SHOW_CHECKPOINT;
if (ASVolume_isVolume (v)
&& !ASVolume_isRequestPending(v)
&& ASVolume_isMounted(v)){
GMount *mount = g_volume_get_mount (v->gVolume);
LOCAL_DEBUG_OUT ("Unmounting volume %s", v == NULL ? "(none)": v->name);
if (mount) {
set_flags (v->flags, ASVolume_UnmountRequested);
ASVolume_refreshDisplay (v);
g_mount_unmount_with_operation (mount, G_MOUNT_UNMOUNT_NONE, NULL, NULL, unmountVolumeAsyncCallback, v->gVolume);
/* g_object_unref (mount) will be called in AsyncResult function above */
}
}
}
static void g_udisks_drive_eject_with_operation (GDrive* base, GMountUnmountFlags flags, GMountOperation* mount_operation, GCancellable* cancellable, GAsyncReadyCallback callback, gpointer user_data)
{
GUDisksDrive* drv = G_UDISKS_DRIVE(base);
GList* vols = g_udisks_drive_get_volumes(base);
GList* mounts = NULL;
EjectData* data;
/* umount all volumes/mounts first */
if(vols)
{
GList* l;
for(l = vols; l; l=l->next)
{
GVolume* vol = G_VOLUME(l->data);
GMount* mnt = g_volume_get_mount(vol);
if(mnt)
mounts = g_list_prepend(mounts, mnt);
g_object_unref(vol);
}
g_list_free(vols);
}
data = g_slice_new0(EjectData);
data->drv = g_object_ref(drv);
data->callback = callback;
data->cancellable = cancellable ? g_object_ref(cancellable) : NULL;
data->flags = flags;
data->op = mount_operation ? g_object_ref(mount_operation) : NULL;
data->user_data = user_data;
if(cancellable)
g_signal_connect(cancellable, "cancelled", G_CALLBACK(on_eject_cancelled), data);
if(mounts) /* unmount all GMounts first, and do eject in ready callback */
{
/* NOTE: is this really needed?
* I read the source code of UDisks and found it calling "eject"
* command internally. According to manpage of "eject", it unmounts
* partitions before ejecting the device. So I don't think that we
* need to unmount ourselves. However, without this, we won't have
* correct "mount-pre-unmount" signals. So, let's do it. */
data->mounts = mounts;
unmount_before_eject(data);
}
else /* no volume is mounted. it's safe to do eject directly. */
do_eject(data);
}
void Directory::async_result(GObject *source_object, GAsyncResult *res, gpointer p_this) {
Directory* _this = static_cast<Directory*>(p_this);
g_object_unref(_this->gcancellable);
_this->gcancellable = 0;
Async_result_type t = _this->async_result_type;
_this->async_result_type = async_result_unexpected;
GError* e = 0;
if (t == _this->async_result_mount_volume) {
GVolume* volume = reinterpret_cast<GVolume*>(source_object);
g_volume_mount_finish(volume, res, &e);
if (e) {
if (e->code == G_IO_ERROR_CANCELLED) {
qDebug() << "Operation was cancelled";
} else {
emit _this->error( tr("Error %1: %2").arg(e->message)
.arg(QString::fromLocal8Bit(e->message)) );
}
g_error_free(e);
return;
}
GMount* mount = g_volume_get_mount(volume);
if (!mount) {
qWarning("mount == null");
emit _this->error(tr("Unexpected failure while mounting a volume."));
return;
}
GFile* f = g_mount_get_root(mount);
if (!f) {
qWarning("f == null");
emit _this->error(tr("Unexpected failure while mounting a volume."));
return;
}
char* path = g_file_get_path(f);
_this->uri = QString::fromLocal8Bit(path);
g_free(path);
g_object_unref(f);
g_object_unref(mount);
_this->refresh();
} else {
qWarning("Directory::async_result: unexpected call");
qDebug() << "type: " << t;
#ifdef TESTS_MODE
throw std::runtime_error("Directory::async_result: unexpected call");
#endif
}
}
static void
mount_with_device_file_cb (GObject *object,
GAsyncResult *res,
gpointer user_data)
{
GVolume *volume;
gboolean succeeded;
GError *error = NULL;
volume = G_VOLUME (object);
succeeded = g_volume_mount_finish (volume, res, &error);
if (!succeeded)
{
g_printerr (_("Error mounting %s: %s\n"),
g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE),
error->message);
g_error_free (error);
success = FALSE;
}
else
{
GMount *mount;
GFile *root;
char *mount_path;
mount = g_volume_get_mount (volume);
root = g_mount_get_root (mount);
mount_path = g_file_get_path (root);
g_print (_("Mounted %s at %s\n"),
g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE),
mount_path);
g_object_unref (mount);
g_object_unref (root);
g_free (mount_path);
}
outstanding_mounts--;
if (outstanding_mounts == 0)
g_main_loop_quit (main_loop);
}
static void
mount_with_device_file_cb (GObject *object,
GAsyncResult *res,
gpointer user_data)
{
GVolume *volume;
gboolean succeeded;
GError *error = NULL;
gchar *device_path = (gchar *)user_data;
volume = G_VOLUME (object);
succeeded = g_volume_mount_finish (volume, res, &error);
if (!succeeded)
{
print_error ("%s: %s", device_path, error->message);
g_error_free (error);
success = FALSE;
}
else
{
GMount *mount;
GFile *root;
char *mount_path;
mount = g_volume_get_mount (volume);
root = g_mount_get_root (mount);
mount_path = g_file_get_path (root);
g_print (_("Mounted %s at %s\n"), device_path, mount_path);
g_object_unref (mount);
g_object_unref (root);
g_free (mount_path);
}
g_free (device_path);
outstanding_mounts--;
if (outstanding_mounts == 0)
g_main_loop_quit (main_loop);
}
/**
* rb_device_source_set_display_details:
* @source: a #RBDeviceSource
*
* Sets the icon and display name for a device-based source.
* The details come from the mount and/or volume. This should
* be called in the source's constructed method.
*/
void
rb_device_source_set_display_details (RBDeviceSource *source)
{
GMount *mount = NULL;
GVolume *volume = NULL;
GIcon *icon = NULL;
char *display_name;
if (g_object_class_find_property (G_OBJECT_GET_CLASS (source), "volume")) {
g_object_get (source, "volume", &volume, NULL);
}
if (g_object_class_find_property (G_OBJECT_GET_CLASS (source), "mount")) {
g_object_get (source, "mount", &mount, NULL);
}
/* prefer mount details to volume details, as the nautilus sidebar does */
if (mount != NULL) {
mount = g_object_ref (mount);
} else if (volume != NULL) {
mount = g_volume_get_mount (volume);
} else {
mount = NULL;
}
if (mount != NULL) {
display_name = g_mount_get_name (mount);
icon = g_mount_get_symbolic_icon (mount);
rb_debug ("details from mount: display name = %s, icon = %p", display_name, icon);
} else if (volume != NULL) {
display_name = g_volume_get_name (volume);
icon = g_volume_get_symbolic_icon (volume);
rb_debug ("details from volume: display name = %s, icon = %p", display_name, icon);
} else {
display_name = g_strdup ("Unknown Device");
icon = g_themed_icon_new ("multimedia-player-symbolic");
}
g_object_set (source, "name", display_name, "icon", icon, NULL);
g_free (display_name);
g_clear_object (&mount);
g_clear_object (&volume);
g_clear_object (&icon);
}
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");
}
}
static Icon *_cd_get_icon_for_volume (GVolume *pVolume, GMount *pMount)
{
Icon *pNewIcon = NULL;
GIcon *pIcon;
GFile *pRootDir;
if (pVolume != NULL)
pMount = g_volume_get_mount (pVolume);
else if (pMount == NULL)
return NULL;
if (pMount != NULL) // ce volume est monte.
{
pNewIcon = g_new0 (Icon, 1);
pNewIcon->acName = g_mount_get_name (pMount);
pRootDir = g_mount_get_root (pMount);
pNewIcon->acCommand = g_file_get_uri (pRootDir);
//g_object_unref (pRootDir);
pIcon = g_mount_get_icon (pMount);
pNewIcon->acFileName = _cd_get_icon_path (pIcon);
//g_object_unref (pIcon);
//g_object_unref (pMount);
}
else // ce volume est demonte, on le montre quand meme (l'automount peut etre off).
{
pNewIcon = g_new0 (Icon, 1);
pNewIcon->acName = g_volume_get_name (pVolume);
pIcon = g_volume_get_icon (pVolume);
pNewIcon->acFileName = _cd_get_icon_path (pIcon);
//g_object_unref (pIcon);
pNewIcon->acCommand = g_strdup (pNewIcon->acName);
}
pNewIcon->iVolumeID = 1;
pNewIcon->cBaseURI = g_strdup (pNewIcon->acCommand);
cd_message (" => %s", pNewIcon->acCommand);
return pNewIcon;
}
static void
volume_mount_cb (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
PanelVolumeMountData *mount_data = user_data;
GError *error;
error = NULL;
if (!g_volume_mount_finish (G_VOLUME (source_object), res, &error)) {
char *primary;
char *name;
if (error->code != G_IO_ERROR_FAILED_HANDLED) {
name = g_volume_get_name (G_VOLUME (source_object));
primary = g_strdup_printf (_("Unable to mount %s"),
name);
g_free (name);
panel_error_dialog (NULL, mount_data->screen,
"cannot_mount_volume", TRUE,
primary, error->message);
g_free (primary);
}
g_error_free (error);
} else {
GMount *mount;
GFile *root;
char *rooturi;
mount = g_volume_get_mount (G_VOLUME (source_object));
root = g_mount_get_root (mount);
rooturi = g_file_get_uri (root);
activate_uri_on_screen (rooturi, mount_data->screen);
g_object_unref (mount);
g_object_unref (root);
g_free (rooturi);
}
g_object_unref (mount_data->mount_op);
g_slice_free (PanelVolumeMountData, mount_data);
}
void GioLister::VolumeAdded(GVolume* volume) {
g_object_ref(volume);
DeviceInfo info;
info.ReadVolumeInfo(volume);
#ifdef HAVE_AUDIOCD
if (info.volume_root_uri.startsWith("cdda"))
// Audio CD devices are already handled by CDDA lister
return;
#endif
info.ReadDriveInfo(g_volume_get_drive(volume));
info.ReadMountInfo(g_volume_get_mount(volume));
if (!info.is_suitable())
return;
{
QMutexLocker l(&mutex_);
devices_[info.unique_id()] = info;
}
emit DeviceAdded(info.unique_id());
}
static GMount *
totem_get_mount_for_dvd (const char *uri)
{
GMount *mount;
char *path;
mount = NULL;
path = g_strdup (uri + strlen ("dvd://"));
/* If it's a device, we need to find the volume that corresponds to it,
* and then the mount for the volume */
if (g_str_has_prefix (path, "/dev/")) {
GVolumeMonitor *volume_monitor;
GList *volumes, *l;
volume_monitor = g_volume_monitor_get ();
volumes = g_volume_monitor_get_volumes (volume_monitor);
g_object_unref (volume_monitor);
for (l = volumes; l != NULL; l = l->next) {
char *id;
id = g_volume_get_identifier (l->data, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE);
if (g_strcmp0 (id, path) == 0) {
g_free (id);
mount = g_volume_get_mount (l->data);
break;
}
g_free (id);
}
g_list_foreach (volumes, (GFunc) g_object_unref, NULL);
g_list_free (volumes);
} else {
mount = totem_get_mount_for_uri (path);
g_free (path);
}
/* We have a path to the file itself */
return mount;
}
void GVolume2ASVolume (ASVolume *v, GVolume *g_v)
{
GMount *mount = g_volume_get_mount (g_v);
v->gVolume = g_v;
ASVolume_freeData (v);
set_string (&(v->name), g_volume_get_name (v->gVolume));
LOCAL_DEBUG_OUT ("mount = %p", mount);
v->flags = 0;
if (g_volume_can_eject (g_v))
set_flags (v->flags, ASVolume_Ejectable);
if (mount) {
set_flags (v->flags, ASVolume_Mounted);
g_object_unref (mount);
}
if (check_audio_cd (g_v))
set_flags (v->flags, ASVolume_Audio);
else if (check_dvd_video (g_v))
set_flags (v->flags, ASVolume_Video);
v->icon = g_volume_get_icon (g_v);
ASVolume_parseGnomeIconString (v);
}
static gboolean
check_dvd_video (GVolume *volume)
{
GFile *file;
char *udi, *device_path, *mount_path;
gboolean result;
GMount *mount;
if (!volume)
return FALSE;
mount = g_volume_get_mount (volume);
if (!mount)
return FALSE;
file = g_mount_get_root (mount);
g_object_unref (mount);
if (!file)
return FALSE;
mount_path = g_file_get_path (file);
g_object_unref (file);
device_path = g_volume_get_identifier (volume,
G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE);
udi = g_volume_get_identifier (volume,
G_VOLUME_IDENTIFIER_KIND_HAL_UDI);
result = gvm_check_dvd_only (udi, device_path, mount_path);
g_free (device_path);
g_free (udi);
g_free (mount_path);
return result;
}
XfdesktopVolumeIcon *
xfdesktop_volume_icon_new(GVolume *volume,
GdkScreen *screen)
{
XfdesktopVolumeIcon *volume_icon;
GMount *mount;
g_return_val_if_fail(G_IS_VOLUME(volume), NULL);
volume_icon = g_object_new(XFDESKTOP_TYPE_VOLUME_ICON, NULL);
volume_icon->priv->volume = g_object_ref(G_OBJECT(volume));
volume_icon->priv->gscreen = screen;
mount = g_volume_get_mount(volume);
if(mount) {
volume_icon->priv->file = g_mount_get_root(mount);
volume_icon->priv->file_info = g_file_query_info(volume_icon->priv->file,
XFDESKTOP_FILE_INFO_NAMESPACE,
G_FILE_QUERY_INFO_NONE,
NULL, NULL);
volume_icon->priv->filesystem_info = g_file_query_filesystem_info(volume_icon->priv->file,
XFDESKTOP_FILESYSTEM_INFO_NAMESPACE,
NULL, NULL);
g_object_unref(mount);
}
g_signal_connect_swapped(G_OBJECT(gtk_icon_theme_get_for_screen(screen)),
"changed",
G_CALLBACK(xfdesktop_icon_invalidate_pixbuf),
volume_icon);
g_signal_connect(volume, "changed",
G_CALLBACK(xfdesktop_volume_icon_changed),
volume_icon);
return volume_icon;
}
