/** * g_volume_eject_with_operation: * @volume: a #GVolume * @flags: flags affecting the unmount if required for eject * @mount_operation: (allow-none): a #GMountOperation or %NULL to * avoid user interaction * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore * @callback: (allow-none): a #GAsyncReadyCallback, or %NULL * @user_data: user data passed to @callback * * Ejects a volume. This is an asynchronous operation, and is * finished by calling g_volume_eject_with_operation_finish() with the @volume * and #GAsyncResult data returned in the @callback. * * Since: 2.22 **/ void g_volume_eject_with_operation (GVolume *volume, GMountUnmountFlags flags, GMountOperation *mount_operation, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { GVolumeIface *iface; g_return_if_fail (G_IS_VOLUME (volume)); iface = G_VOLUME_GET_IFACE (volume); if (iface->eject == NULL && iface->eject_with_operation == NULL) { g_task_report_new_error (volume, callback, user_data, g_volume_eject_with_operation, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED, /* Translators: This is an error * message for volume objects that * don't implement any of eject or eject_with_operation. */ _("volume doesn't implement eject or eject_with_operation")); return; } if (iface->eject_with_operation != NULL) (* iface->eject_with_operation) (volume, flags, mount_operation, cancellable, callback, user_data); else (* iface->eject) (volume, flags, cancellable, callback, user_data); }
/** * g_volume_mount: * @volume: a #GVolume * @flags: flags affecting the operation * @mount_operation: (allow-none): a #GMountOperation or %NULL to avoid user interaction * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore * @callback: (allow-none): a #GAsyncReadyCallback, or %NULL * @user_data: user data that gets passed to @callback * * Mounts a volume. This is an asynchronous operation, and is * finished by calling g_volume_mount_finish() with the @volume * and #GAsyncResult returned in the @callback. * * Virtual: mount_fn */ void g_volume_mount (GVolume *volume, GMountMountFlags flags, GMountOperation *mount_operation, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { GVolumeIface *iface; g_return_if_fail (G_IS_VOLUME (volume)); iface = G_VOLUME_GET_IFACE (volume); if (iface->mount_fn == NULL) { g_task_report_new_error (volume, callback, user_data, g_volume_mount, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED, _("volume doesn't implement mount")); return; } (* iface->mount_fn) (volume, flags, mount_operation, cancellable, callback, user_data); }
/** * g_drive_stop: * @drive: a #GDrive. * @flags: flags affecting the unmount if required for stopping. * @mount_operation: (allow-none): a #GMountOperation or %NULL to avoid * user interaction. * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore. * @callback: (allow-none): a #GAsyncReadyCallback, or %NULL. * @user_data: user data to pass to @callback * * Asynchronously stops a drive. * * When the operation is finished, @callback will be called. * You can then call g_drive_stop_finish() to obtain the * result of the operation. * * Since: 2.22 */ void g_drive_stop (GDrive *drive, GMountUnmountFlags flags, GMountOperation *mount_operation, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { GDriveIface *iface; g_return_if_fail (G_IS_DRIVE (drive)); iface = G_DRIVE_GET_IFACE (drive); if (iface->stop == NULL) { g_task_report_new_error (drive, callback, user_data, g_drive_start, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED, _("drive doesn't implement stop")); return; } (* iface->stop) (drive, flags, mount_operation, cancellable, callback, user_data); }
static void ide_device_provider_real_load_async (IdeDeviceProvider *self, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { g_task_report_new_error (self, callback, user_data, ide_device_provider_real_load_async, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED, "%s does not implement load_async", G_OBJECT_TYPE_NAME (self)); }
static void ide_toolchain_provider_real_load_async (IdeToolchainProvider *self, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { g_assert (IDE_IS_MAIN_THREAD ()); g_assert (IDE_IS_TOOLCHAIN_PROVIDER (self)); g_assert (!cancellable || G_IS_CANCELLABLE (cancellable)); g_task_report_new_error (self, callback, user_data, ide_toolchain_provider_real_load_async, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED, "%s does not implement load_async", G_OBJECT_TYPE_NAME (self)); }
/** * g_drive_poll_for_media: * @drive: a #GDrive. * @cancellable: (allow-none): optional #GCancellable object, %NULL to ignore. * @callback: (allow-none): a #GAsyncReadyCallback, or %NULL. * @user_data: user data to pass to @callback * * Asynchronously polls @drive to see if media has been inserted or removed. * * When the operation is finished, @callback will be called. * You can then call g_drive_poll_for_media_finish() to obtain the * result of the operation. **/ void g_drive_poll_for_media (GDrive *drive, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { GDriveIface *iface; g_return_if_fail (G_IS_DRIVE (drive)); iface = G_DRIVE_GET_IFACE (drive); if (iface->poll_for_media == NULL) { g_task_report_new_error (drive, callback, user_data, g_drive_poll_for_media, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED, _("drive doesn't implement polling for media")); return; } (* iface->poll_for_media) (drive, cancellable, callback, user_data); }