void Directory::refresh() {
need_update = false;
refresh_timer.restart();
if (uri.isEmpty()) {
emit error(tr("Address is empty"));
return;
}
if (Special_uri(uri).name() == Special_uri::mounts) { //mounting of unmounted volume was requested
//uri is something like "places/mounts/42"
int id = uri.split("/").last().toInt();
QList<Gio_volume*> volumes = core->get_mount_manager()->get_volumes();
if (id < 0 || id >= volumes.count()) {
emit error(tr("Invalid volume id"));
return;
}
GVolume* volume = volumes.at(id)->get_gvolume();
interrupt_gio_operation();
gcancellable = g_cancellable_new();
async_result_type = async_result_mount_volume;
g_volume_mount(volume, GMountMountFlags(), 0, gcancellable, async_result, this);
return;
}
create_task(uri);
}
static void
xfdesktop_volume_icon_menu_mount(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) {
g_object_unref(mount);
return;
}
operation = gtk_mount_operation_new(toplevel ? GTK_WINDOW(toplevel) : NULL);
gtk_mount_operation_set_screen(GTK_MOUNT_OPERATION(operation),
icon->priv->gscreen);
g_volume_mount(volume, G_MOUNT_MOUNT_NONE, operation, NULL,
xfdesktop_volume_icon_mount_finish,
g_object_ref(icon));
g_object_unref(operation);
}
static void
panel_menu_item_mount_volume (GtkWidget *menuitem,
GVolume *volume)
{
PanelVolumeMountData *mount_data;
mount_data = g_slice_new (PanelVolumeMountData);
mount_data->screen = menuitem_to_screen (menuitem);
mount_data->mount_op = gtk_mount_operation_new (NULL);
gtk_mount_operation_set_screen (GTK_MOUNT_OPERATION (mount_data->mount_op),
mount_data->screen);
g_volume_mount (volume, G_MOUNT_MOUNT_NONE, mount_data->mount_op, NULL,
volume_mount_cb, mount_data);
}
static void
panel_menu_item_mount_volume (GtkWidget *menuitem,
GVolume *volume)
{
PanelVolumeMountData *mount_data;
mount_data = g_slice_new (PanelVolumeMountData);
mount_data->screen = menuitem_to_screen (menuitem);
/*FIXME: kill PanelMountOperation when we can depend on newer GTK+ that
* will have the same feature */
mount_data->mount_op = panel_mount_operation_new (NULL);
g_volume_mount (volume, G_MOUNT_MOUNT_NONE, mount_data->mount_op, NULL,
volume_mount_cb, mount_data);
}
void GioLister::DoMountDevice(const QString& id, int request_id) {
QMutexLocker l(&mutex_);
if (!devices_.contains(id)) {
emit DeviceMounted(id, request_id, false);
return;
}
const DeviceInfo& info = devices_[id];
if (info.mount) {
// Already mounted
emit DeviceMounted(id, request_id, true);
return;
}
g_volume_mount(info.volume, G_MOUNT_MOUNT_NONE, NULL, NULL,
VolumeMountFinished, NULL);
emit DeviceMounted(id, request_id, true);
}
static void mountVolume (ASVolume *v)
{
SHOW_CHECKPOINT;
if (ASVolume_isVolume (v)
&& !ASVolume_isRequestPending(v)
&& !ASVolume_isMounted(v)) {
GMountOperation *mount_op =NULL;
#ifdef HAVE_GTK
/*mount_op = gtk_mount_operation_new (NULL);*/
#endif
set_flags (v->flags, ASVolume_MountRequested);
ASVolume_refreshDisplay (v);
LOCAL_DEBUG_OUT ("Mounting volume %s", v == NULL ? "(none)": v->name);
g_volume_mount (v->gVolume, G_MOUNT_MOUNT_NONE, mount_op, NULL, mountVolumeAsyncCallback, v->gVolume);
if (mount_op)
g_object_unref (mount_op);
}
}
static void
mount_with_device_file (const char *device_file)
{
GVolumeMonitor *volume_monitor;
GList *volumes;
GList *l;
volume_monitor = g_volume_monitor_get();
volumes = g_volume_monitor_get_volumes (volume_monitor);
for (l = volumes; l != NULL; l = l->next)
{
GVolume *volume = G_VOLUME (l->data);
gchar *id;
id = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE);
if (g_strcmp0 (id, device_file) == 0)
{
GMountOperation *op;
op = new_mount_op ();
g_volume_mount (volume,
G_MOUNT_MOUNT_NONE,
op,
NULL,
mount_with_device_file_cb,
id);
outstanding_mounts++;
}
else
g_free (id);
}
g_list_free_full (volumes, g_object_unref);
if (outstanding_mounts == 0)
{
print_error ("%s: %s", device_file, _("No volume for device file"));
success = FALSE;
}
g_object_unref (volume_monitor);
}
static void
mount_with_device_file (const char *device_file)
{
GVolumeMonitor *volume_monitor;
GList *volumes;
GList *l;
volume_monitor = g_volume_monitor_get();
volumes = g_volume_monitor_get_volumes (volume_monitor);
for (l = volumes; l != NULL; l = l->next)
{
GVolume *volume = G_VOLUME (l->data);
if (g_strcmp0 (g_volume_get_identifier (volume,
G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE), device_file) == 0)
{
GMountOperation *op;
op = new_mount_op ();
g_volume_mount (volume,
G_MOUNT_MOUNT_NONE,
op,
NULL,
mount_with_device_file_cb,
op);
outstanding_mounts++;
}
}
g_list_foreach (volumes, (GFunc) g_object_unref, NULL);
g_list_free (volumes);
if (outstanding_mounts == 0)
{
g_print (_("No volume for device file %s\n"), device_file);
return;
}
g_object_unref (volume_monitor);
}
static void
rb_mtp_source_dispose (GObject *object)
{
RBMtpSource *source = RB_MTP_SOURCE (object);
RBMtpSourcePrivate *priv = MTP_SOURCE_GET_PRIVATE (source);
RhythmDBEntryType *entry_type;
RhythmDB *db;
if (priv->device_thread != NULL) {
g_object_unref (priv->device_thread);
priv->device_thread = NULL;
}
#if defined(HAVE_GUDEV)
if (priv->remount_volume != NULL) {
rb_debug ("remounting gvfs volume for mtp device");
/* the callback will unref remount_volume */
g_volume_mount (priv->remount_volume,
G_MOUNT_MOUNT_NONE,
NULL,
NULL,
remount_done_cb,
NULL);
priv->remount_volume = NULL;
}
#endif
if (priv->art_store != NULL) {
g_object_unref (priv->art_store);
priv->art_store = NULL;
}
db = get_db_for_source (source);
g_object_get (G_OBJECT (source), "entry-type", &entry_type, NULL);
rhythmdb_entry_delete_by_type (db, entry_type);
g_object_unref (entry_type);
rhythmdb_commit (db);
g_object_unref (db);
G_OBJECT_CLASS (rb_mtp_source_parent_class)->dispose (object);
}
static VALUE
rg_mount(int argc, VALUE *argv, VALUE self)
{
VALUE rbflags, rbmount_operation, rbcancellable, block;
GMountMountFlags flags;
GMountOperation *mount_operation;
GCancellable *cancellable;
rb_scan_args(argc, argv, "03&", &rbflags, &rbmount_operation, &rbcancellable, &block);
flags = RVAL2GMOUNTMOUNTFLAGSDEFAULT(rbflags);
mount_operation = RVAL2GMOUNTOPERATION(rbmount_operation);
cancellable = RVAL2GCANCELLABLE(rbcancellable);
SAVE_BLOCK(block);
g_volume_mount(_SELF(self),
flags,
mount_operation,
cancellable,
rbgio_async_ready_callback,
(gpointer)block);
return self;
}
static void on_volume_added(GObject* vm, GVolume* volume, GtkWidget* window) {
g_volume_mount(volume, G_MOUNT_MOUNT_NONE, NULL, NULL, NULL, NULL);
}
gboolean
brasero_gio_operation_mount (GVolume *gvolume,
GtkWindow *parent_window,
GCancellable *cancel,
gboolean wait,
GError **error)
{
GMount *mount;
gboolean result;
GMountOperation *operation = NULL;
BRASERO_MEDIA_LOG ("Mounting");
if (!gvolume) {
BRASERO_MEDIA_LOG ("No volume");
return FALSE;
}
if (!g_volume_can_mount (gvolume)) {
BRASERO_MEDIA_LOG ("Volume can't be mounted");
return FALSE;
}
mount = g_volume_get_mount (gvolume);
if (mount) {
BRASERO_MEDIA_LOG ("Existing mount");
g_object_unref (mount);
return TRUE;
}
if (parent_window && GTK_IS_WINDOW (parent_window))
operation = gtk_mount_operation_new (parent_window);
if (wait) {
BraseroGioOperation *op;
op = g_new0 (BraseroGioOperation, 1);
op->cancel = cancel;
/* Ref gvolume as it could be unreffed
* while we are in the loop */
g_object_ref (gvolume);
g_volume_mount (gvolume,
G_MOUNT_MOUNT_NONE,
operation, /* authentification */
cancel,
brasero_gio_operation_mount_finish,
op);
result = brasero_gio_operation_wait_for_operation_end (op, error);
g_object_unref (gvolume);
}
else {
g_volume_mount (gvolume,
G_MOUNT_MOUNT_NONE,
operation, /* authentification */
cancel,
NULL,
NULL);
result = TRUE;
}
if (operation)
g_object_unref (operation);
BRASERO_MEDIA_LOG ("Mount result = %d", result);
return result;
}
static gboolean fm_do_mount(GtkWindow* parent, GObject* obj, MountAction action, gboolean interactive)
{
gboolean ret;
struct MountData* data = g_new0(struct MountData, 1);
/* bug #3615234: it seems GtkMountOperations is buggy and sometimes leaves
parent window reference intact while destroys itself so it leads to
severe memory corruption, therefore we pass here NULL as parent window
to gtk_mount_operation_new() to not bind it to anything as a workaround */
GMountOperation* op = interactive ? gtk_mount_operation_new(NULL) : NULL;
GCancellable* cancellable = g_cancellable_new();
data->loop = g_main_loop_new (NULL, TRUE);
data->action = action;
switch(data->action)
{
case MOUNT_VOLUME:
g_volume_mount(G_VOLUME(obj), 0, op, cancellable, on_mount_action_finished, data);
break;
case MOUNT_GFILE:
g_file_mount_enclosing_volume(G_FILE(obj), 0, op, cancellable, on_mount_action_finished, data);
break;
case UMOUNT_MOUNT:
prepare_unmount(G_MOUNT(obj));
g_mount_unmount_with_operation(G_MOUNT(obj), G_MOUNT_UNMOUNT_NONE, op, cancellable, on_mount_action_finished, data);
break;
case EJECT_MOUNT:
prepare_unmount(G_MOUNT(obj));
g_mount_eject_with_operation(G_MOUNT(obj), G_MOUNT_UNMOUNT_NONE, op, cancellable, on_mount_action_finished, data);
break;
case EJECT_VOLUME:
{
GMount* mnt = g_volume_get_mount(G_VOLUME(obj));
if (mnt) /* it might be unmounted already */
{
prepare_unmount(mnt);
g_object_unref(mnt);
}
g_volume_eject_with_operation(G_VOLUME(obj), G_MOUNT_UNMOUNT_NONE, op, cancellable, on_mount_action_finished, data);
}
break;
}
/* FIXME: create progress window with busy cursor */
if (g_main_loop_is_running(data->loop))
{
GDK_THREADS_LEAVE();
g_main_loop_run(data->loop);
GDK_THREADS_ENTER();
}
g_main_loop_unref(data->loop);
ret = data->ret;
if(data->err)
{
if(interactive)
{
if(data->err->domain == G_IO_ERROR)
{
if(data->err->code == G_IO_ERROR_FAILED)
{
/* Generate a more human-readable error message instead of using a gvfs one. */
/* The original error message is something like:
* Error unmounting: umount exited with exit code 1:
* helper failed with: umount: only root can unmount
* UUID=18cbf00c-e65f-445a-bccc-11964bdea05d from /media/sda4 */
/* Why they pass this back to us?
* This is not human-readable for the users at all. */
if(strstr(data->err->message, "only root can "))
{
g_debug("%s", data->err->message);
g_free(data->err->message);
data->err->message = g_strdup(_("Only system administrators have the permission to do this."));
}
}
else if(data->err->code == G_IO_ERROR_FAILED_HANDLED)
interactive = FALSE;
}
if(interactive)
fm_show_error(parent, NULL, data->err->message);
}
g_error_free(data->err);
}
g_free(data);
g_object_unref(cancellable);
if(op)
g_object_unref(op);
return ret;
}
