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 GMountOperation * view_frame_mount_operation_factory (GeditDocument *doc, gpointer user_data) { GeditViewFrame *frame = GEDIT_VIEW_FRAME (user_data); GtkWidget *window; window = gtk_widget_get_toplevel (GTK_WIDGET (frame)); return gtk_mount_operation_new (GTK_WINDOW (window)); }
static void steadyflow_file_list_controller_set_mount_operation (SteadyflowFileListController* self, GMountOperation** mount_op) { GMountOperation* _vala_mount_op = NULL; GtkMountOperation* _tmp0_; g_return_if_fail (self != NULL); _tmp0_ = (GtkMountOperation*) gtk_mount_operation_new (NULL); _g_object_unref0 (_vala_mount_op); _vala_mount_op = (GMountOperation*) _tmp0_; if (mount_op) { *mount_op = _vala_mount_op; } else { _g_object_unref0 (_vala_mount_op); } }
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 gboolean _panel_show_handle_error (const gchar *uri, GdkScreen *screen, GError *local_error, GError **error) { if (local_error == NULL) return TRUE; else if (g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) { g_error_free (local_error); return TRUE; } else if (g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_NOT_MOUNTED)) { GFile *file; PanelShowMountOperationHandle *handle; handle = g_slice_new (PanelShowMountOperationHandle); file = g_file_new_for_uri (uri); /* If it's not mounted, try to mount it ourselves */ handle->mount_op = gtk_mount_operation_new (NULL); gtk_mount_operation_set_screen (GTK_MOUNT_OPERATION (handle->mount_op), screen); handle->screen = screen; g_file_mount_enclosing_volume (file, G_MOUNT_MOUNT_NONE, handle->mount_op, NULL, _panel_show_mount_async_callback, handle); g_object_unref (file); return TRUE; } else if (error != NULL) g_propagate_error (error, local_error); else { _panel_show_error_dialog (uri, screen, local_error->message); g_error_free (local_error); } return FALSE; }
static gboolean mount_enclosing_volume (GFile *file, GError **error) { GMountOperation *operation = gtk_mount_operation_new (NULL); g_file_mount_enclosing_volume (file, G_MOUNT_MOUNT_NONE, operation, NULL, (GAsyncReadyCallback) mount_volume_ready, error); gtk_main (); g_object_unref (operation); return (*error == NULL); }
static gboolean message_handler (GstBus * bus, GstMessage * message, gpointer user_data) { switch (GST_MESSAGE_TYPE (message)) { case GST_MESSAGE_ELEMENT:{ const GstStructure *s = gst_message_get_structure (message); const gchar *name = gst_structure_get_name (s); if (strcmp (name, "not-mounted") == 0) { GMountOperation *mop = gtk_mount_operation_new (NULL); GFile *file = G_FILE (g_value_get_object (gst_structure_get_value (s, "file"))); g_print ("not-mounted\n"); gst_element_set_state (pipeline, GST_STATE_NULL); gst_bus_set_flushing (bus, TRUE); g_file_mount_enclosing_volume (file, G_MOUNT_MOUNT_NONE, mop, NULL, mount_cb, bus); g_object_unref (mop); } break; } case GST_MESSAGE_EOS: g_print ("EOS\n"); gtk_main_quit (); break; case GST_MESSAGE_ERROR:{ GError *err = NULL; gst_message_parse_error (message, &err, NULL); g_print ("error: %s\n", err->message); g_clear_error (&err); gtk_main_quit (); break; } default: break; } return TRUE; }
static void do_unmount (GMount *mount, gboolean should_eject, GtkWindow *window) { GMountOperation *mount_op; mount_op = gtk_mount_operation_new (window); if (should_eject) { g_mount_eject_with_operation (mount, 0, mount_op, NULL, unmount_mount_callback, (gpointer) 1); } else { g_mount_unmount_with_operation (mount, 0, mount_op, NULL, unmount_mount_callback, (gpointer) 0); } g_object_unref (mount_op); }
static void get_folder_content_done_cb (GError *error, gpointer user_data) { LoadData *load_data = user_data; FrFileSelectorDialog *self = load_data->dialog; GtkListStore *list_store; GList *scan; GtkTreeIter iter; GDateTime *today; int sort_column_id; GtkSortType sort_order; GHashTable *selected_files; if (error != NULL) { if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_NOT_MOUNTED)) { GMountOperation *operation; operation = gtk_mount_operation_new (GTK_WINDOW (self)); g_file_mount_enclosing_volume (load_data->folder, G_MOUNT_MOUNT_NONE, operation, load_data->cancellable, folder_mount_enclosing_volume_ready_cb, load_data); g_object_unref (operation); return; } if (! g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) _gtk_error_dialog_run (GTK_WINDOW (self), _("Could not load the location"), "%s", error->message); if (load_data->dialog->priv->current_operation == load_data) load_data->dialog->priv->current_operation = NULL; load_data_free (load_data); return; } load_data->files = g_list_reverse (load_data->files); today = g_date_time_new_now_local (); gtk_tree_sortable_get_sort_column_id (GTK_TREE_SORTABLE (GET_WIDGET ("files_liststore")), &sort_column_id, &sort_order); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (GET_WIDGET ("files_liststore")), GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID, 0); selected_files = g_hash_table_new (g_file_hash, (GEqualFunc) g_file_equal); for (scan = load_data->files_to_select; scan; scan = scan->next) g_hash_table_insert(selected_files, scan->data, GINT_TO_POINTER (1)); list_store = GTK_LIST_STORE (GET_WIDGET ("files_liststore")); gtk_list_store_clear (list_store); for (scan = load_data->files; scan; scan = scan->next) { FileInfo *file_info = scan->data; GdkPixbuf *icon_pixbuf; char *size; GTimeVal timeval; GDateTime *datetime; char *modified; char *collate_key; gboolean is_folder; if (! self->priv->show_hidden && g_file_info_get_is_hidden (file_info->info)) continue; gtk_list_store_append (list_store, &iter); icon_pixbuf = gth_icon_cache_get_pixbuf (self->priv->icon_cache, g_file_info_get_icon (file_info->info)); size = g_format_size (g_file_info_get_size (file_info->info)); g_file_info_get_modification_time (file_info->info, &timeval); datetime = g_date_time_new_from_timeval_local (&timeval); modified = g_date_time_format (datetime, _g_date_time_same_day (datetime, today) ? "%X" : "%x"); collate_key = g_utf8_collate_key_for_filename (g_file_info_get_display_name (file_info->info), -1); is_folder = (g_file_info_get_file_type (file_info->info) == G_FILE_TYPE_DIRECTORY); gtk_list_store_set (list_store, &iter, FILE_LIST_COLUMN_ICON, icon_pixbuf, FILE_LIST_COLUMN_NAME, g_file_info_get_display_name (file_info->info), FILE_LIST_COLUMN_SIZE, (is_folder ? "" : size), FILE_LIST_COLUMN_MODIFIED, modified, FILE_LIST_COLUMN_FILE, file_info->file, FILE_LIST_COLUMN_NAME_ORDER, collate_key, FILE_LIST_COLUMN_SIZE_ORDER, g_file_info_get_size (file_info->info), FILE_LIST_COLUMN_MODIFIED_ORDER, timeval.tv_sec, FILE_LIST_COLUMN_IS_FOLDER, is_folder, FILE_LIST_COLUMN_IS_SELECTED, (g_hash_table_lookup (selected_files, file_info->file) != NULL), -1); g_free (collate_key); g_free (modified); g_date_time_unref (datetime); g_free (size); _g_object_unref (icon_pixbuf); } gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (GET_WIDGET ("files_liststore")), sort_column_id, sort_order); set_current_folder (self, load_data->folder); if (load_data->dialog->priv->current_operation == load_data) load_data->dialog->priv->current_operation = NULL; g_hash_table_unref (selected_files); g_date_time_unref (today); load_data_free (load_data); }
int main (int argc, char *argv[]) { int ret; GError *error; MduPool *pool; MduDevice *device; MduDevice *device_to_unmount; MduDevice *device_to_mount; MduPresentable *volume; gchar *volume_name; gchar *confirmation_secondary; GtkWidget *dialog; gint response; gchar *fs_type; gchar *fs_label; gboolean encrypt; gchar *passphrase; gboolean save_passphrase_in_keyring; gboolean save_passphrase_in_keyring_session; GMainLoop *loop; GVolumeMonitor *gvolume_monitor; GList *l; GList *gvolumes; GVolume *gvolume; GMount *gmount; gboolean take_ownership; FormatData *format_data; MduPresentable *toplevel; gchar *drive_name; gchar *format_desc; gchar *formatting_desc; gchar *size_str; gint grace_timeout_id; ret = 1; pool = NULL; device = NULL; device_to_unmount = NULL; device_to_mount = NULL; volume = NULL; volume_name = NULL; confirmation_secondary = NULL; dialog = NULL; fs_type = NULL; fs_label = NULL; passphrase = NULL; loop = NULL; volume = NULL; gmount = NULL; gvolume_monitor = NULL; gvolumes = NULL; gvolume = NULL; gmount = NULL; format_data = NULL; toplevel = NULL; drive_name = NULL; format_desc = NULL; formatting_desc = NULL; size_str = NULL; #if !GLIB_CHECK_VERSION (2, 32, 0) g_thread_init (NULL); #endif /* Initialize gettext support */ bindtextdomain (GETTEXT_PACKAGE, MATELOCALEDIR); bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); textdomain (GETTEXT_PACKAGE); /* Initialize gtk */ error = NULL; if (! gtk_init_with_args (&argc, &argv, NULL, entries, GETTEXT_PACKAGE, &error)) { g_printerr ("Could not parse arguments: %s\n", error->message); g_error_free (error); goto out; } loop = g_main_loop_new (NULL, FALSE); g_set_prgname ("mdu-format-tool"); g_set_application_name (_("Mate Disk Utility formatting tool")); if (device_file == NULL) { g_printerr ("Incorrect usage. Try --help.\n"); goto out; } pool = mdu_pool_new (); if (pool == NULL) { g_warning ("Unable to get device pool"); goto out; } device = mdu_pool_get_by_device_file (pool, device_file); if (device == NULL) { g_printerr ("No device for %s\n", device_file); goto out; } /* if the user specified a luks device, find the slave backing device */ if (mdu_device_is_luks_cleartext (device)) { const gchar *slave; slave = mdu_device_luks_cleartext_get_slave (device); g_object_ref (device); device = mdu_pool_get_by_object_path (pool, slave); /* don't support LUKS in LUKS... */ g_assert (!mdu_device_is_luks_cleartext (device)); } volume = mdu_pool_get_volume_by_device (pool, device); if (volume == NULL) { g_printerr ("%s is not a volume\n", device_file); goto out; } volume_name = mdu_presentable_get_name (volume); toplevel = mdu_presentable_get_toplevel (MDU_PRESENTABLE (volume)); if (toplevel != NULL && MDU_IS_DRIVE (toplevel)) { drive_name = mdu_presentable_get_name (toplevel); } size_str = mdu_util_get_size_for_display (mdu_device_get_size (device), FALSE, FALSE); if (drive_name != NULL) { if (mdu_device_is_partition (device)) { /* Translators: First argument is the partition number, second argument is the drive name, * third argument is the size (e.g. 10 GB) */ format_desc = g_strdup_printf (_("Format partition %d of %s (%s)"), mdu_device_partition_get_number (device), drive_name, size_str); /* Translators: First argument is the partition number, second argument is the drive name, * third argument is the size (e.g. 10 GB) */ formatting_desc = g_strdup_printf (_("Formatting partition %d of %s (%s)"), mdu_device_partition_get_number (device), drive_name, size_str); } else { /* Translators: First argument is the drive name, second argument is the size (e.g. 10 GB) */ format_desc = g_strdup_printf (_("Format %s (%s)"), drive_name, size_str); /* Translators: First argument is the drive name, second argument is the size (e.g. 10 GB) */ formatting_desc = g_strdup_printf (_("Formatting %s (%s)"), drive_name, size_str); } } else { /* Translators: First argument is the size (e.g. 10 GB), second is the device (e.g. /dev/md0) */ format_desc = g_strdup_printf (_("Format %s Volume (%s)"), size_str, mdu_device_get_device_file (device)); /* Translators: First argument is the size (e.g. 10 GB), second is the device (e.g. /dev/md0) */ formatting_desc = g_strdup_printf (_("Formatting %s Volume (%s)"), size_str, mdu_device_get_device_file (device)); } dialog = mdu_format_dialog_new (NULL, /* no parent window */ volume, MDU_FORMAT_DIALOG_FLAGS_SIMPLE | MDU_FORMAT_DIALOG_FLAGS_DISK_UTILITY_BUTTON); gtk_window_set_title (GTK_WINDOW (dialog), format_desc); gtk_window_set_icon_name (GTK_WINDOW (dialog), "caja-mdu"); gtk_widget_show_all (dialog); response = gtk_dialog_run (GTK_DIALOG (dialog)); switch (response) { case GTK_RESPONSE_OK: break; case GTK_RESPONSE_ACCEPT: gtk_widget_destroy (dialog); dialog = NULL; launch_mate_disk (device_file); goto out; default: /* explicit fallthrough */ case GTK_RESPONSE_CANCEL: goto out; } fs_type = mdu_format_dialog_get_fs_type (MDU_FORMAT_DIALOG (dialog)); fs_label = mdu_format_dialog_get_fs_label (MDU_FORMAT_DIALOG (dialog)); encrypt = mdu_format_dialog_get_encrypt (MDU_FORMAT_DIALOG (dialog)); gtk_widget_destroy (dialog); dialog = NULL; /* Ask for passphrase if needed */ passphrase = NULL; save_passphrase_in_keyring = FALSE; save_passphrase_in_keyring_session = FALSE; if (encrypt) { passphrase = mdu_util_dialog_ask_for_new_secret (NULL, &save_passphrase_in_keyring, &save_passphrase_in_keyring_session); if (passphrase == NULL) goto out; } take_ownership = (g_strcmp0 (fs_type, "vfat") != 0); format_data = g_new0 (FormatData, 1); format_data->loop = loop; format_data->error = NULL; dialog = mdu_format_progress_dialog_new (NULL, device, _("Preparing...")); gtk_window_set_title (GTK_WINDOW (dialog), formatting_desc); gtk_widget_show_all (dialog); g_signal_connect (dialog, "response", G_CALLBACK (on_progress_dialog_response), format_data); /* first a small 2.5 sec window to allow the user to cancel before initiating */ grace_timeout_id = g_timeout_add (2500, on_grace_timeout, format_data); g_main_loop_run (loop); g_source_remove (grace_timeout_id); if (format_data->error != NULL && format_data->error->domain == G_IO_ERROR && format_data->error->code == G_IO_ERROR_CANCELLED) { /* cancelled already, we are done */ goto out; } /* then unmount the mount if needed; we use GIO for this to handle tearing * down LUKS; first determine the device to unmount */ if (mdu_device_is_luks (device)) { const gchar *holder; holder = mdu_device_luks_get_holder (device); device_to_unmount = mdu_pool_get_by_object_path (pool, holder); } else { device_to_unmount = g_object_ref (device); } g_assert (device_to_unmount != NULL); gvolume_monitor = g_volume_monitor_get (); gvolumes = g_volume_monitor_get_volumes (gvolume_monitor); for (l = gvolumes; l != NULL; l = l->next) { GVolume *v = G_VOLUME (l->data); if (g_strcmp0 (g_volume_get_identifier (v, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE), mdu_device_get_device_file (device_to_unmount)) == 0) { gvolume = g_object_ref (v); break; } } if (gvolume != NULL) { gmount = g_volume_get_mount (gvolume); if (gmount != NULL) { GMountOperation *mount_op; mdu_format_progress_dialog_set_text (MDU_FORMAT_PROGRESS_DIALOG (dialog), _("Unmounting...")); mount_op = gtk_mount_operation_new (GTK_WINDOW (dialog)); g_mount_unmount_with_operation (gmount, G_MOUNT_UNMOUNT_NONE, mount_op, NULL, unmount_cb, format_data); g_object_unref (mount_op); g_main_loop_run (format_data->loop); if (format_data->error != NULL) { if (!(format_data->error->domain == G_IO_ERROR && format_data->error->code == G_IO_ERROR_FAILED_HANDLED)) { gchar *primary; primary = g_strdup_printf (_("Unable to format '%s'"), volume_name); show_error_dialog (NULL, primary, format_data->error->message); g_free (primary); } g_error_free (format_data->error); goto out; } } } /* and now, kick off the operation */ mdu_format_progress_dialog_set_text (MDU_FORMAT_PROGRESS_DIALOG (dialog), _("Formatting...")); mdu_device_op_filesystem_create (device, fs_type, fs_label, passphrase, take_ownership, fs_create_cb, format_data); again: g_main_loop_run (loop); if (format_data->error != NULL) { gtk_widget_destroy (dialog); dialog = NULL; if (format_data->error->domain == G_IO_ERROR && format_data->error->code == G_IO_ERROR_CANCELLED) { mdu_format_progress_dialog_set_text (MDU_FORMAT_PROGRESS_DIALOG (dialog), _("Cancelling...")); /* cancel the job; no callback since op_filesystem_create will return an error */ mdu_device_op_cancel_job (device, NULL, NULL); goto again; } else { show_error_dialog (NULL, _("Error formatting volume"), format_data->error->message); g_error_free (format_data->error); } goto out; } /* ugh, DeviceKit-disks bug - spin around in the mainloop for some time to ensure we * have gotten all changes */ mdu_format_progress_dialog_set_text (MDU_FORMAT_PROGRESS_DIALOG (dialog), _("Mounting volume...")); g_timeout_add (1500, on_hack_timeout, loop); g_main_loop_run (loop); /* OK, peachy, now mount the volume and open a window */ if (passphrase != NULL) { const gchar *cleartext_objpath; g_assert (mdu_device_is_luks (device)); cleartext_objpath = mdu_device_luks_get_holder (device); device_to_mount = mdu_pool_get_by_object_path (pool, cleartext_objpath); } else { device_to_mount = g_object_ref (device); } mdu_device_op_filesystem_mount (device_to_mount, NULL, fs_mount_cb, format_data); g_main_loop_run (loop); gtk_widget_destroy (dialog); dialog = NULL; if (format_data->error != NULL) { show_error_dialog (NULL, _("Error mounting device"), format_data->error->message); g_error_free (format_data->error); goto out; } /* open file manager */ launch_file_manager (format_data->mount_point); g_free (format_data->mount_point); /* save passphrase in keyring if requested */ if (passphrase != NULL && (save_passphrase_in_keyring || save_passphrase_in_keyring_session)) { if (!mdu_util_save_secret (device, passphrase, save_passphrase_in_keyring_session)) { show_error_dialog (NULL, _("Error storing passphrase in keyring"), ""); goto out; } } ret = 0; out: if (toplevel != NULL) g_object_unref (toplevel); g_free (drive_name); g_free (size_str); g_free (format_desc); g_free (formatting_desc); if (gmount != NULL) g_object_unref (gmount); if (gvolume != NULL) g_object_unref (gvolume); g_list_foreach (gvolumes, (GFunc) g_object_unref, NULL); if (gvolume_monitor != NULL) g_object_unref (gvolume_monitor); g_free (confirmation_secondary); g_free (volume_name); g_free (passphrase); g_free (fs_type); g_free (fs_label); g_free (device_file); if (loop != NULL) g_main_loop_unref (loop); if (dialog != NULL) gtk_widget_destroy (dialog); if (volume != NULL) g_object_unref (volume); if (device != NULL) g_object_unref (device); if (device_to_unmount != NULL) g_object_unref (device_to_unmount); if (device_to_mount != NULL) g_object_unref (device_to_mount); if (pool != NULL) g_object_unref (pool); if (format_data != NULL) g_free (format_data); return ret; }
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; }