/* * This file is generated by gdbus-codegen, do not modify it. * * The license of this code is the same as for the D-Bus interface description * it was derived from. Note that it links to GLib, so must comply with the * LGPL linking clauses. */ #ifndef __UDISKS_GENERATED_H__ #define __UDISKS_GENERATED_H__ #include G_BEGIN_DECLS /* ------------------------------------------------------------------------ */ /* Declarations for org.freedesktop.UDisks2.Manager */ #define UDISKS_TYPE_MANAGER (udisks_manager_get_type ()) #define UDISKS_MANAGER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_MANAGER, UDisksManager)) #define UDISKS_IS_MANAGER(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_MANAGER)) #define UDISKS_MANAGER_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), UDISKS_TYPE_MANAGER, UDisksManagerIface)) struct _UDisksManager; typedef struct _UDisksManager UDisksManager; typedef struct _UDisksManagerIface UDisksManagerIface; struct _UDisksManagerIface { GTypeInterface parent_iface; gboolean (*handle_enable_modules) ( UDisksManager *object, GDBusMethodInvocation *invocation, gboolean arg_enable); gboolean (*handle_loop_setup) ( UDisksManager *object, GDBusMethodInvocation *invocation, GUnixFDList *fd_list, GVariant *arg_fd, GVariant *arg_options); const gchar *const * (*get_supported_filesystems) (UDisksManager *object); const gchar * (*get_version) (UDisksManager *object); gboolean (*handle_mdraid_create) ( UDisksManager *object, GDBusMethodInvocation *invocation, const gchar *const *arg_blocks, const gchar *arg_level, const gchar *arg_name, guint64 arg_chunk, GVariant *arg_options); gboolean (*handle_can_check) ( UDisksManager *object, GDBusMethodInvocation *invocation, const gchar *arg_type); gboolean (*handle_can_format) ( UDisksManager *object, GDBusMethodInvocation *invocation, const gchar *arg_type); gboolean (*handle_can_repair) ( UDisksManager *object, GDBusMethodInvocation *invocation, const gchar *arg_type); gboolean (*handle_can_resize) ( UDisksManager *object, GDBusMethodInvocation *invocation, const gchar *arg_type); gboolean (*handle_get_block_devices) ( UDisksManager *object, GDBusMethodInvocation *invocation, GVariant *arg_options); gboolean (*handle_resolve_device) ( UDisksManager *object, GDBusMethodInvocation *invocation, GVariant *arg_devspec, GVariant *arg_options); const gchar * (*get_default_encryption_type) (UDisksManager *object); const gchar *const * (*get_supported_encryption_types) (UDisksManager *object); gboolean (*handle_enable_module) ( UDisksManager *object, GDBusMethodInvocation *invocation, const gchar *arg_name, gboolean arg_enable); gboolean (*handle_get_drives) ( UDisksManager *object, GDBusMethodInvocation *invocation, GVariant *arg_options); }; #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksManager, g_object_unref) #endif GType udisks_manager_get_type (void); GDBusInterfaceInfo *udisks_manager_interface_info (void); guint udisks_manager_override_properties (GObjectClass *klass, guint property_id_begin); /* D-Bus method call completion functions: */ void udisks_manager_complete_can_format ( UDisksManager *object, GDBusMethodInvocation *invocation, GVariant *available); void udisks_manager_complete_can_resize ( UDisksManager *object, GDBusMethodInvocation *invocation, GVariant *available); void udisks_manager_complete_can_check ( UDisksManager *object, GDBusMethodInvocation *invocation, GVariant *available); void udisks_manager_complete_can_repair ( UDisksManager *object, GDBusMethodInvocation *invocation, GVariant *available); void udisks_manager_complete_loop_setup ( UDisksManager *object, GDBusMethodInvocation *invocation, GUnixFDList *fd_list, const gchar *resulting_device); void udisks_manager_complete_mdraid_create ( UDisksManager *object, GDBusMethodInvocation *invocation, const gchar *resulting_array); G_GNUC_DEPRECATED void udisks_manager_complete_enable_modules ( UDisksManager *object, GDBusMethodInvocation *invocation); void udisks_manager_complete_enable_module ( UDisksManager *object, GDBusMethodInvocation *invocation); void udisks_manager_complete_get_block_devices ( UDisksManager *object, GDBusMethodInvocation *invocation, const gchar *const *block_objects); void udisks_manager_complete_get_drives ( UDisksManager *object, GDBusMethodInvocation *invocation, const gchar *const *drive_objects); void udisks_manager_complete_resolve_device ( UDisksManager *object, GDBusMethodInvocation *invocation, const gchar *const *devices); /* D-Bus method calls: */ void udisks_manager_call_can_format ( UDisksManager *proxy, const gchar *arg_type, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_manager_call_can_format_finish ( UDisksManager *proxy, GVariant ** out_available, GAsyncResult *res, GError **error); gboolean udisks_manager_call_can_format_sync ( UDisksManager *proxy, const gchar *arg_type, GVariant ** out_available, GCancellable *cancellable, GError **error); void udisks_manager_call_can_resize ( UDisksManager *proxy, const gchar *arg_type, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_manager_call_can_resize_finish ( UDisksManager *proxy, GVariant ** out_available, GAsyncResult *res, GError **error); gboolean udisks_manager_call_can_resize_sync ( UDisksManager *proxy, const gchar *arg_type, GVariant ** out_available, GCancellable *cancellable, GError **error); void udisks_manager_call_can_check ( UDisksManager *proxy, const gchar *arg_type, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_manager_call_can_check_finish ( UDisksManager *proxy, GVariant ** out_available, GAsyncResult *res, GError **error); gboolean udisks_manager_call_can_check_sync ( UDisksManager *proxy, const gchar *arg_type, GVariant ** out_available, GCancellable *cancellable, GError **error); void udisks_manager_call_can_repair ( UDisksManager *proxy, const gchar *arg_type, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_manager_call_can_repair_finish ( UDisksManager *proxy, GVariant ** out_available, GAsyncResult *res, GError **error); gboolean udisks_manager_call_can_repair_sync ( UDisksManager *proxy, const gchar *arg_type, GVariant ** out_available, GCancellable *cancellable, GError **error); void udisks_manager_call_loop_setup ( UDisksManager *proxy, GVariant *arg_fd, GVariant *arg_options, GUnixFDList *fd_list, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_manager_call_loop_setup_finish ( UDisksManager *proxy, gchar ** out_resulting_device, GUnixFDList **out_fd_list, GAsyncResult *res, GError **error); gboolean udisks_manager_call_loop_setup_sync ( UDisksManager *proxy, GVariant *arg_fd, GVariant *arg_options, GUnixFDList *fd_list, gchar ** out_resulting_device, GUnixFDList **out_fd_list, GCancellable *cancellable, GError **error); void udisks_manager_call_mdraid_create ( UDisksManager *proxy, const gchar *const *arg_blocks, const gchar *arg_level, const gchar *arg_name, guint64 arg_chunk, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_manager_call_mdraid_create_finish ( UDisksManager *proxy, gchar ** out_resulting_array, GAsyncResult *res, GError **error); gboolean udisks_manager_call_mdraid_create_sync ( UDisksManager *proxy, const gchar *const *arg_blocks, const gchar *arg_level, const gchar *arg_name, guint64 arg_chunk, GVariant *arg_options, gchar ** out_resulting_array, GCancellable *cancellable, GError **error); G_GNUC_DEPRECATED void udisks_manager_call_enable_modules ( UDisksManager *proxy, gboolean arg_enable, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); G_GNUC_DEPRECATED gboolean udisks_manager_call_enable_modules_finish ( UDisksManager *proxy, GAsyncResult *res, GError **error); G_GNUC_DEPRECATED gboolean udisks_manager_call_enable_modules_sync ( UDisksManager *proxy, gboolean arg_enable, GCancellable *cancellable, GError **error); void udisks_manager_call_enable_module ( UDisksManager *proxy, const gchar *arg_name, gboolean arg_enable, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_manager_call_enable_module_finish ( UDisksManager *proxy, GAsyncResult *res, GError **error); gboolean udisks_manager_call_enable_module_sync ( UDisksManager *proxy, const gchar *arg_name, gboolean arg_enable, GCancellable *cancellable, GError **error); void udisks_manager_call_get_block_devices ( UDisksManager *proxy, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_manager_call_get_block_devices_finish ( UDisksManager *proxy, gchar *** out_block_objects, GAsyncResult *res, GError **error); gboolean udisks_manager_call_get_block_devices_sync ( UDisksManager *proxy, GVariant *arg_options, gchar *** out_block_objects, GCancellable *cancellable, GError **error); void udisks_manager_call_get_drives ( UDisksManager *proxy, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_manager_call_get_drives_finish ( UDisksManager *proxy, gchar *** out_drive_objects, GAsyncResult *res, GError **error); gboolean udisks_manager_call_get_drives_sync ( UDisksManager *proxy, GVariant *arg_options, gchar *** out_drive_objects, GCancellable *cancellable, GError **error); void udisks_manager_call_resolve_device ( UDisksManager *proxy, GVariant *arg_devspec, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_manager_call_resolve_device_finish ( UDisksManager *proxy, gchar *** out_devices, GAsyncResult *res, GError **error); gboolean udisks_manager_call_resolve_device_sync ( UDisksManager *proxy, GVariant *arg_devspec, GVariant *arg_options, gchar *** out_devices, GCancellable *cancellable, GError **error); /* D-Bus property accessors: */ const gchar *udisks_manager_get_version (UDisksManager *object); gchar *udisks_manager_dup_version (UDisksManager *object); void udisks_manager_set_version (UDisksManager *object, const gchar *value); const gchar *const *udisks_manager_get_supported_filesystems (UDisksManager *object); gchar **udisks_manager_dup_supported_filesystems (UDisksManager *object); void udisks_manager_set_supported_filesystems (UDisksManager *object, const gchar *const *value); const gchar *const *udisks_manager_get_supported_encryption_types (UDisksManager *object); gchar **udisks_manager_dup_supported_encryption_types (UDisksManager *object); void udisks_manager_set_supported_encryption_types (UDisksManager *object, const gchar *const *value); const gchar *udisks_manager_get_default_encryption_type (UDisksManager *object); gchar *udisks_manager_dup_default_encryption_type (UDisksManager *object); void udisks_manager_set_default_encryption_type (UDisksManager *object, const gchar *value); /* ---- */ #define UDISKS_TYPE_MANAGER_PROXY (udisks_manager_proxy_get_type ()) #define UDISKS_MANAGER_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_MANAGER_PROXY, UDisksManagerProxy)) #define UDISKS_MANAGER_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UDISKS_TYPE_MANAGER_PROXY, UDisksManagerProxyClass)) #define UDISKS_MANAGER_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UDISKS_TYPE_MANAGER_PROXY, UDisksManagerProxyClass)) #define UDISKS_IS_MANAGER_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_MANAGER_PROXY)) #define UDISKS_IS_MANAGER_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UDISKS_TYPE_MANAGER_PROXY)) typedef struct _UDisksManagerProxy UDisksManagerProxy; typedef struct _UDisksManagerProxyClass UDisksManagerProxyClass; typedef struct _UDisksManagerProxyPrivate UDisksManagerProxyPrivate; struct _UDisksManagerProxy { /*< private >*/ GDBusProxy parent_instance; UDisksManagerProxyPrivate *priv; }; struct _UDisksManagerProxyClass { GDBusProxyClass parent_class; }; GType udisks_manager_proxy_get_type (void); #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksManagerProxy, g_object_unref) #endif void udisks_manager_proxy_new ( GDBusConnection *connection, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); UDisksManager *udisks_manager_proxy_new_finish ( GAsyncResult *res, GError **error); UDisksManager *udisks_manager_proxy_new_sync ( GDBusConnection *connection, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GError **error); void udisks_manager_proxy_new_for_bus ( GBusType bus_type, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); UDisksManager *udisks_manager_proxy_new_for_bus_finish ( GAsyncResult *res, GError **error); UDisksManager *udisks_manager_proxy_new_for_bus_sync ( GBusType bus_type, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GError **error); /* ---- */ #define UDISKS_TYPE_MANAGER_SKELETON (udisks_manager_skeleton_get_type ()) #define UDISKS_MANAGER_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_MANAGER_SKELETON, UDisksManagerSkeleton)) #define UDISKS_MANAGER_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UDISKS_TYPE_MANAGER_SKELETON, UDisksManagerSkeletonClass)) #define UDISKS_MANAGER_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UDISKS_TYPE_MANAGER_SKELETON, UDisksManagerSkeletonClass)) #define UDISKS_IS_MANAGER_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_MANAGER_SKELETON)) #define UDISKS_IS_MANAGER_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UDISKS_TYPE_MANAGER_SKELETON)) typedef struct _UDisksManagerSkeleton UDisksManagerSkeleton; typedef struct _UDisksManagerSkeletonClass UDisksManagerSkeletonClass; typedef struct _UDisksManagerSkeletonPrivate UDisksManagerSkeletonPrivate; struct _UDisksManagerSkeleton { /*< private >*/ GDBusInterfaceSkeleton parent_instance; UDisksManagerSkeletonPrivate *priv; }; struct _UDisksManagerSkeletonClass { GDBusInterfaceSkeletonClass parent_class; }; GType udisks_manager_skeleton_get_type (void); #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksManagerSkeleton, g_object_unref) #endif UDisksManager *udisks_manager_skeleton_new (void); /* ------------------------------------------------------------------------ */ /* Declarations for org.freedesktop.UDisks2.Manager.NVMe */ #define UDISKS_TYPE_MANAGER_NVME (udisks_manager_nvme_get_type ()) #define UDISKS_MANAGER_NVME(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_MANAGER_NVME, UDisksManagerNVMe)) #define UDISKS_IS_MANAGER_NVME(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_MANAGER_NVME)) #define UDISKS_MANAGER_NVME_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), UDISKS_TYPE_MANAGER_NVME, UDisksManagerNVMeIface)) struct _UDisksManagerNVMe; typedef struct _UDisksManagerNVMe UDisksManagerNVMe; typedef struct _UDisksManagerNVMeIface UDisksManagerNVMeIface; struct _UDisksManagerNVMeIface { GTypeInterface parent_iface; const gchar * (*get_host_id) (UDisksManagerNVMe *object); const gchar * (*get_host_nqn) (UDisksManagerNVMe *object); gboolean (*handle_connect) ( UDisksManagerNVMe *object, GDBusMethodInvocation *invocation, const gchar *arg_subsysnqn, const gchar *arg_transport, const gchar *arg_transport_addr, GVariant *arg_options); gboolean (*handle_set_host_id) ( UDisksManagerNVMe *object, GDBusMethodInvocation *invocation, const gchar *arg_hostid, GVariant *arg_options); gboolean (*handle_set_host_nqn) ( UDisksManagerNVMe *object, GDBusMethodInvocation *invocation, const gchar *arg_hostnqn, GVariant *arg_options); }; #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksManagerNVMe, g_object_unref) #endif GType udisks_manager_nvme_get_type (void); GDBusInterfaceInfo *udisks_manager_nvme_interface_info (void); guint udisks_manager_nvme_override_properties (GObjectClass *klass, guint property_id_begin); /* D-Bus method call completion functions: */ void udisks_manager_nvme_complete_set_host_nqn ( UDisksManagerNVMe *object, GDBusMethodInvocation *invocation); void udisks_manager_nvme_complete_set_host_id ( UDisksManagerNVMe *object, GDBusMethodInvocation *invocation); void udisks_manager_nvme_complete_connect ( UDisksManagerNVMe *object, GDBusMethodInvocation *invocation, const gchar *nvme_ctrl); /* D-Bus method calls: */ void udisks_manager_nvme_call_set_host_nqn ( UDisksManagerNVMe *proxy, const gchar *arg_hostnqn, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_manager_nvme_call_set_host_nqn_finish ( UDisksManagerNVMe *proxy, GAsyncResult *res, GError **error); gboolean udisks_manager_nvme_call_set_host_nqn_sync ( UDisksManagerNVMe *proxy, const gchar *arg_hostnqn, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_manager_nvme_call_set_host_id ( UDisksManagerNVMe *proxy, const gchar *arg_hostid, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_manager_nvme_call_set_host_id_finish ( UDisksManagerNVMe *proxy, GAsyncResult *res, GError **error); gboolean udisks_manager_nvme_call_set_host_id_sync ( UDisksManagerNVMe *proxy, const gchar *arg_hostid, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_manager_nvme_call_connect ( UDisksManagerNVMe *proxy, const gchar *arg_subsysnqn, const gchar *arg_transport, const gchar *arg_transport_addr, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_manager_nvme_call_connect_finish ( UDisksManagerNVMe *proxy, gchar ** out_nvme_ctrl, GAsyncResult *res, GError **error); gboolean udisks_manager_nvme_call_connect_sync ( UDisksManagerNVMe *proxy, const gchar *arg_subsysnqn, const gchar *arg_transport, const gchar *arg_transport_addr, GVariant *arg_options, gchar ** out_nvme_ctrl, GCancellable *cancellable, GError **error); /* D-Bus property accessors: */ const gchar *udisks_manager_nvme_get_host_nqn (UDisksManagerNVMe *object); gchar *udisks_manager_nvme_dup_host_nqn (UDisksManagerNVMe *object); void udisks_manager_nvme_set_host_nqn (UDisksManagerNVMe *object, const gchar *value); const gchar *udisks_manager_nvme_get_host_id (UDisksManagerNVMe *object); gchar *udisks_manager_nvme_dup_host_id (UDisksManagerNVMe *object); void udisks_manager_nvme_set_host_id (UDisksManagerNVMe *object, const gchar *value); /* ---- */ #define UDISKS_TYPE_MANAGER_NVME_PROXY (udisks_manager_nvme_proxy_get_type ()) #define UDISKS_MANAGER_NVME_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_MANAGER_NVME_PROXY, UDisksManagerNVMeProxy)) #define UDISKS_MANAGER_NVME_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UDISKS_TYPE_MANAGER_NVME_PROXY, UDisksManagerNVMeProxyClass)) #define UDISKS_MANAGER_NVME_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UDISKS_TYPE_MANAGER_NVME_PROXY, UDisksManagerNVMeProxyClass)) #define UDISKS_IS_MANAGER_NVME_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_MANAGER_NVME_PROXY)) #define UDISKS_IS_MANAGER_NVME_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UDISKS_TYPE_MANAGER_NVME_PROXY)) typedef struct _UDisksManagerNVMeProxy UDisksManagerNVMeProxy; typedef struct _UDisksManagerNVMeProxyClass UDisksManagerNVMeProxyClass; typedef struct _UDisksManagerNVMeProxyPrivate UDisksManagerNVMeProxyPrivate; struct _UDisksManagerNVMeProxy { /*< private >*/ GDBusProxy parent_instance; UDisksManagerNVMeProxyPrivate *priv; }; struct _UDisksManagerNVMeProxyClass { GDBusProxyClass parent_class; }; GType udisks_manager_nvme_proxy_get_type (void); #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksManagerNVMeProxy, g_object_unref) #endif void udisks_manager_nvme_proxy_new ( GDBusConnection *connection, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); UDisksManagerNVMe *udisks_manager_nvme_proxy_new_finish ( GAsyncResult *res, GError **error); UDisksManagerNVMe *udisks_manager_nvme_proxy_new_sync ( GDBusConnection *connection, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GError **error); void udisks_manager_nvme_proxy_new_for_bus ( GBusType bus_type, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); UDisksManagerNVMe *udisks_manager_nvme_proxy_new_for_bus_finish ( GAsyncResult *res, GError **error); UDisksManagerNVMe *udisks_manager_nvme_proxy_new_for_bus_sync ( GBusType bus_type, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GError **error); /* ---- */ #define UDISKS_TYPE_MANAGER_NVME_SKELETON (udisks_manager_nvme_skeleton_get_type ()) #define UDISKS_MANAGER_NVME_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_MANAGER_NVME_SKELETON, UDisksManagerNVMeSkeleton)) #define UDISKS_MANAGER_NVME_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UDISKS_TYPE_MANAGER_NVME_SKELETON, UDisksManagerNVMeSkeletonClass)) #define UDISKS_MANAGER_NVME_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UDISKS_TYPE_MANAGER_NVME_SKELETON, UDisksManagerNVMeSkeletonClass)) #define UDISKS_IS_MANAGER_NVME_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_MANAGER_NVME_SKELETON)) #define UDISKS_IS_MANAGER_NVME_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UDISKS_TYPE_MANAGER_NVME_SKELETON)) typedef struct _UDisksManagerNVMeSkeleton UDisksManagerNVMeSkeleton; typedef struct _UDisksManagerNVMeSkeletonClass UDisksManagerNVMeSkeletonClass; typedef struct _UDisksManagerNVMeSkeletonPrivate UDisksManagerNVMeSkeletonPrivate; struct _UDisksManagerNVMeSkeleton { /*< private >*/ GDBusInterfaceSkeleton parent_instance; UDisksManagerNVMeSkeletonPrivate *priv; }; struct _UDisksManagerNVMeSkeletonClass { GDBusInterfaceSkeletonClass parent_class; }; GType udisks_manager_nvme_skeleton_get_type (void); #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksManagerNVMeSkeleton, g_object_unref) #endif UDisksManagerNVMe *udisks_manager_nvme_skeleton_new (void); /* ------------------------------------------------------------------------ */ /* Declarations for org.freedesktop.UDisks2.Drive */ #define UDISKS_TYPE_DRIVE (udisks_drive_get_type ()) #define UDISKS_DRIVE(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_DRIVE, UDisksDrive)) #define UDISKS_IS_DRIVE(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_DRIVE)) #define UDISKS_DRIVE_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), UDISKS_TYPE_DRIVE, UDisksDriveIface)) struct _UDisksDrive; typedef struct _UDisksDrive UDisksDrive; typedef struct _UDisksDriveIface UDisksDriveIface; struct _UDisksDriveIface { GTypeInterface parent_iface; gboolean (*handle_eject) ( UDisksDrive *object, GDBusMethodInvocation *invocation, GVariant *arg_options); gboolean (*handle_set_configuration) ( UDisksDrive *object, GDBusMethodInvocation *invocation, GVariant *arg_value, GVariant *arg_options); gboolean (*get_can_power_off) (UDisksDrive *object); GVariant * (*get_configuration) (UDisksDrive *object); const gchar * (*get_connection_bus) (UDisksDrive *object); gboolean (*get_ejectable) (UDisksDrive *object); const gchar * (*get_id) (UDisksDrive *object); const gchar * (*get_media) (UDisksDrive *object); gboolean (*get_media_available) (UDisksDrive *object); gboolean (*get_media_change_detected) (UDisksDrive *object); const gchar *const * (*get_media_compatibility) (UDisksDrive *object); gboolean (*get_media_removable) (UDisksDrive *object); const gchar * (*get_model) (UDisksDrive *object); gboolean (*get_optical) (UDisksDrive *object); gboolean (*get_optical_blank) (UDisksDrive *object); guint (*get_optical_num_audio_tracks) (UDisksDrive *object); guint (*get_optical_num_data_tracks) (UDisksDrive *object); guint (*get_optical_num_sessions) (UDisksDrive *object); guint (*get_optical_num_tracks) (UDisksDrive *object); gboolean (*get_removable) (UDisksDrive *object); const gchar * (*get_revision) (UDisksDrive *object); gint (*get_rotation_rate) (UDisksDrive *object); const gchar * (*get_seat) (UDisksDrive *object); const gchar * (*get_serial) (UDisksDrive *object); const gchar * (*get_sibling_id) (UDisksDrive *object); guint64 (*get_size) (UDisksDrive *object); const gchar * (*get_sort_key) (UDisksDrive *object); guint64 (*get_time_detected) (UDisksDrive *object); guint64 (*get_time_media_detected) (UDisksDrive *object); const gchar * (*get_vendor) (UDisksDrive *object); const gchar * (*get_wwn) (UDisksDrive *object); gboolean (*handle_power_off) ( UDisksDrive *object, GDBusMethodInvocation *invocation, GVariant *arg_options); }; #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksDrive, g_object_unref) #endif GType udisks_drive_get_type (void); GDBusInterfaceInfo *udisks_drive_interface_info (void); guint udisks_drive_override_properties (GObjectClass *klass, guint property_id_begin); /* D-Bus method call completion functions: */ void udisks_drive_complete_eject ( UDisksDrive *object, GDBusMethodInvocation *invocation); void udisks_drive_complete_set_configuration ( UDisksDrive *object, GDBusMethodInvocation *invocation); void udisks_drive_complete_power_off ( UDisksDrive *object, GDBusMethodInvocation *invocation); /* D-Bus method calls: */ void udisks_drive_call_eject ( UDisksDrive *proxy, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_drive_call_eject_finish ( UDisksDrive *proxy, GAsyncResult *res, GError **error); gboolean udisks_drive_call_eject_sync ( UDisksDrive *proxy, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_drive_call_set_configuration ( UDisksDrive *proxy, GVariant *arg_value, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_drive_call_set_configuration_finish ( UDisksDrive *proxy, GAsyncResult *res, GError **error); gboolean udisks_drive_call_set_configuration_sync ( UDisksDrive *proxy, GVariant *arg_value, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_drive_call_power_off ( UDisksDrive *proxy, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_drive_call_power_off_finish ( UDisksDrive *proxy, GAsyncResult *res, GError **error); gboolean udisks_drive_call_power_off_sync ( UDisksDrive *proxy, GVariant *arg_options, GCancellable *cancellable, GError **error); /* D-Bus property accessors: */ const gchar *udisks_drive_get_vendor (UDisksDrive *object); gchar *udisks_drive_dup_vendor (UDisksDrive *object); void udisks_drive_set_vendor (UDisksDrive *object, const gchar *value); const gchar *udisks_drive_get_model (UDisksDrive *object); gchar *udisks_drive_dup_model (UDisksDrive *object); void udisks_drive_set_model (UDisksDrive *object, const gchar *value); const gchar *udisks_drive_get_revision (UDisksDrive *object); gchar *udisks_drive_dup_revision (UDisksDrive *object); void udisks_drive_set_revision (UDisksDrive *object, const gchar *value); const gchar *udisks_drive_get_serial (UDisksDrive *object); gchar *udisks_drive_dup_serial (UDisksDrive *object); void udisks_drive_set_serial (UDisksDrive *object, const gchar *value); const gchar *udisks_drive_get_wwn (UDisksDrive *object); gchar *udisks_drive_dup_wwn (UDisksDrive *object); void udisks_drive_set_wwn (UDisksDrive *object, const gchar *value); const gchar *udisks_drive_get_id (UDisksDrive *object); gchar *udisks_drive_dup_id (UDisksDrive *object); void udisks_drive_set_id (UDisksDrive *object, const gchar *value); GVariant *udisks_drive_get_configuration (UDisksDrive *object); GVariant *udisks_drive_dup_configuration (UDisksDrive *object); void udisks_drive_set_configuration (UDisksDrive *object, GVariant *value); const gchar *udisks_drive_get_media (UDisksDrive *object); gchar *udisks_drive_dup_media (UDisksDrive *object); void udisks_drive_set_media (UDisksDrive *object, const gchar *value); const gchar *const *udisks_drive_get_media_compatibility (UDisksDrive *object); gchar **udisks_drive_dup_media_compatibility (UDisksDrive *object); void udisks_drive_set_media_compatibility (UDisksDrive *object, const gchar *const *value); gboolean udisks_drive_get_media_removable (UDisksDrive *object); void udisks_drive_set_media_removable (UDisksDrive *object, gboolean value); gboolean udisks_drive_get_media_available (UDisksDrive *object); void udisks_drive_set_media_available (UDisksDrive *object, gboolean value); gboolean udisks_drive_get_media_change_detected (UDisksDrive *object); void udisks_drive_set_media_change_detected (UDisksDrive *object, gboolean value); guint64 udisks_drive_get_size (UDisksDrive *object); void udisks_drive_set_size (UDisksDrive *object, guint64 value); guint64 udisks_drive_get_time_detected (UDisksDrive *object); void udisks_drive_set_time_detected (UDisksDrive *object, guint64 value); guint64 udisks_drive_get_time_media_detected (UDisksDrive *object); void udisks_drive_set_time_media_detected (UDisksDrive *object, guint64 value); gboolean udisks_drive_get_optical (UDisksDrive *object); void udisks_drive_set_optical (UDisksDrive *object, gboolean value); gboolean udisks_drive_get_optical_blank (UDisksDrive *object); void udisks_drive_set_optical_blank (UDisksDrive *object, gboolean value); guint udisks_drive_get_optical_num_tracks (UDisksDrive *object); void udisks_drive_set_optical_num_tracks (UDisksDrive *object, guint value); guint udisks_drive_get_optical_num_audio_tracks (UDisksDrive *object); void udisks_drive_set_optical_num_audio_tracks (UDisksDrive *object, guint value); guint udisks_drive_get_optical_num_data_tracks (UDisksDrive *object); void udisks_drive_set_optical_num_data_tracks (UDisksDrive *object, guint value); guint udisks_drive_get_optical_num_sessions (UDisksDrive *object); void udisks_drive_set_optical_num_sessions (UDisksDrive *object, guint value); gint udisks_drive_get_rotation_rate (UDisksDrive *object); void udisks_drive_set_rotation_rate (UDisksDrive *object, gint value); const gchar *udisks_drive_get_connection_bus (UDisksDrive *object); gchar *udisks_drive_dup_connection_bus (UDisksDrive *object); void udisks_drive_set_connection_bus (UDisksDrive *object, const gchar *value); const gchar *udisks_drive_get_seat (UDisksDrive *object); gchar *udisks_drive_dup_seat (UDisksDrive *object); void udisks_drive_set_seat (UDisksDrive *object, const gchar *value); gboolean udisks_drive_get_removable (UDisksDrive *object); void udisks_drive_set_removable (UDisksDrive *object, gboolean value); gboolean udisks_drive_get_ejectable (UDisksDrive *object); void udisks_drive_set_ejectable (UDisksDrive *object, gboolean value); const gchar *udisks_drive_get_sort_key (UDisksDrive *object); gchar *udisks_drive_dup_sort_key (UDisksDrive *object); void udisks_drive_set_sort_key (UDisksDrive *object, const gchar *value); gboolean udisks_drive_get_can_power_off (UDisksDrive *object); void udisks_drive_set_can_power_off (UDisksDrive *object, gboolean value); const gchar *udisks_drive_get_sibling_id (UDisksDrive *object); gchar *udisks_drive_dup_sibling_id (UDisksDrive *object); void udisks_drive_set_sibling_id (UDisksDrive *object, const gchar *value); /* ---- */ #define UDISKS_TYPE_DRIVE_PROXY (udisks_drive_proxy_get_type ()) #define UDISKS_DRIVE_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_DRIVE_PROXY, UDisksDriveProxy)) #define UDISKS_DRIVE_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UDISKS_TYPE_DRIVE_PROXY, UDisksDriveProxyClass)) #define UDISKS_DRIVE_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UDISKS_TYPE_DRIVE_PROXY, UDisksDriveProxyClass)) #define UDISKS_IS_DRIVE_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_DRIVE_PROXY)) #define UDISKS_IS_DRIVE_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UDISKS_TYPE_DRIVE_PROXY)) typedef struct _UDisksDriveProxy UDisksDriveProxy; typedef struct _UDisksDriveProxyClass UDisksDriveProxyClass; typedef struct _UDisksDriveProxyPrivate UDisksDriveProxyPrivate; struct _UDisksDriveProxy { /*< private >*/ GDBusProxy parent_instance; UDisksDriveProxyPrivate *priv; }; struct _UDisksDriveProxyClass { GDBusProxyClass parent_class; }; GType udisks_drive_proxy_get_type (void); #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksDriveProxy, g_object_unref) #endif void udisks_drive_proxy_new ( GDBusConnection *connection, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); UDisksDrive *udisks_drive_proxy_new_finish ( GAsyncResult *res, GError **error); UDisksDrive *udisks_drive_proxy_new_sync ( GDBusConnection *connection, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GError **error); void udisks_drive_proxy_new_for_bus ( GBusType bus_type, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); UDisksDrive *udisks_drive_proxy_new_for_bus_finish ( GAsyncResult *res, GError **error); UDisksDrive *udisks_drive_proxy_new_for_bus_sync ( GBusType bus_type, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GError **error); /* ---- */ #define UDISKS_TYPE_DRIVE_SKELETON (udisks_drive_skeleton_get_type ()) #define UDISKS_DRIVE_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_DRIVE_SKELETON, UDisksDriveSkeleton)) #define UDISKS_DRIVE_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UDISKS_TYPE_DRIVE_SKELETON, UDisksDriveSkeletonClass)) #define UDISKS_DRIVE_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UDISKS_TYPE_DRIVE_SKELETON, UDisksDriveSkeletonClass)) #define UDISKS_IS_DRIVE_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_DRIVE_SKELETON)) #define UDISKS_IS_DRIVE_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UDISKS_TYPE_DRIVE_SKELETON)) typedef struct _UDisksDriveSkeleton UDisksDriveSkeleton; typedef struct _UDisksDriveSkeletonClass UDisksDriveSkeletonClass; typedef struct _UDisksDriveSkeletonPrivate UDisksDriveSkeletonPrivate; struct _UDisksDriveSkeleton { /*< private >*/ GDBusInterfaceSkeleton parent_instance; UDisksDriveSkeletonPrivate *priv; }; struct _UDisksDriveSkeletonClass { GDBusInterfaceSkeletonClass parent_class; }; GType udisks_drive_skeleton_get_type (void); #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksDriveSkeleton, g_object_unref) #endif UDisksDrive *udisks_drive_skeleton_new (void); /* ------------------------------------------------------------------------ */ /* Declarations for org.freedesktop.UDisks2.Drive.Ata */ #define UDISKS_TYPE_DRIVE_ATA (udisks_drive_ata_get_type ()) #define UDISKS_DRIVE_ATA(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_DRIVE_ATA, UDisksDriveAta)) #define UDISKS_IS_DRIVE_ATA(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_DRIVE_ATA)) #define UDISKS_DRIVE_ATA_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), UDISKS_TYPE_DRIVE_ATA, UDisksDriveAtaIface)) struct _UDisksDriveAta; typedef struct _UDisksDriveAta UDisksDriveAta; typedef struct _UDisksDriveAtaIface UDisksDriveAtaIface; struct _UDisksDriveAtaIface { GTypeInterface parent_iface; gboolean (*handle_pm_get_state) ( UDisksDriveAta *object, GDBusMethodInvocation *invocation, GVariant *arg_options); gboolean (*handle_pm_standby) ( UDisksDriveAta *object, GDBusMethodInvocation *invocation, GVariant *arg_options); gboolean (*handle_pm_wakeup) ( UDisksDriveAta *object, GDBusMethodInvocation *invocation, GVariant *arg_options); gboolean (*handle_security_erase_unit) ( UDisksDriveAta *object, GDBusMethodInvocation *invocation, GVariant *arg_options); gboolean (*handle_smart_get_attributes) ( UDisksDriveAta *object, GDBusMethodInvocation *invocation, GVariant *arg_options); gboolean (*handle_smart_selftest_abort) ( UDisksDriveAta *object, GDBusMethodInvocation *invocation, GVariant *arg_options); gboolean (*handle_smart_selftest_start) ( UDisksDriveAta *object, GDBusMethodInvocation *invocation, const gchar *arg_type, GVariant *arg_options); gboolean (*handle_smart_update) ( UDisksDriveAta *object, GDBusMethodInvocation *invocation, GVariant *arg_options); gboolean (*get_aam_enabled) (UDisksDriveAta *object); gboolean (*get_aam_supported) (UDisksDriveAta *object); gint (*get_aam_vendor_recommended_value) (UDisksDriveAta *object); gboolean (*get_apm_enabled) (UDisksDriveAta *object); gboolean (*get_apm_supported) (UDisksDriveAta *object); gboolean (*get_pm_enabled) (UDisksDriveAta *object); gboolean (*get_pm_supported) (UDisksDriveAta *object); gboolean (*get_read_lookahead_enabled) (UDisksDriveAta *object); gboolean (*get_read_lookahead_supported) (UDisksDriveAta *object); gint (*get_security_enhanced_erase_unit_minutes) (UDisksDriveAta *object); gint (*get_security_erase_unit_minutes) (UDisksDriveAta *object); gboolean (*get_security_frozen) (UDisksDriveAta *object); gboolean (*get_smart_enabled) (UDisksDriveAta *object); gboolean (*get_smart_failing) (UDisksDriveAta *object); gint (*get_smart_num_attributes_failed_in_the_past) (UDisksDriveAta *object); gint (*get_smart_num_attributes_failing) (UDisksDriveAta *object); gint64 (*get_smart_num_bad_sectors) (UDisksDriveAta *object); guint64 (*get_smart_power_on_seconds) (UDisksDriveAta *object); gint (*get_smart_selftest_percent_remaining) (UDisksDriveAta *object); const gchar * (*get_smart_selftest_status) (UDisksDriveAta *object); gboolean (*get_smart_supported) (UDisksDriveAta *object); gdouble (*get_smart_temperature) (UDisksDriveAta *object); guint64 (*get_smart_updated) (UDisksDriveAta *object); gboolean (*get_write_cache_enabled) (UDisksDriveAta *object); gboolean (*get_write_cache_supported) (UDisksDriveAta *object); gboolean (*handle_smart_set_enabled) ( UDisksDriveAta *object, GDBusMethodInvocation *invocation, gboolean arg_value, GVariant *arg_options); }; #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksDriveAta, g_object_unref) #endif GType udisks_drive_ata_get_type (void); GDBusInterfaceInfo *udisks_drive_ata_interface_info (void); guint udisks_drive_ata_override_properties (GObjectClass *klass, guint property_id_begin); /* D-Bus method call completion functions: */ void udisks_drive_ata_complete_smart_update ( UDisksDriveAta *object, GDBusMethodInvocation *invocation); void udisks_drive_ata_complete_smart_get_attributes ( UDisksDriveAta *object, GDBusMethodInvocation *invocation, GVariant *attributes); void udisks_drive_ata_complete_smart_selftest_start ( UDisksDriveAta *object, GDBusMethodInvocation *invocation); void udisks_drive_ata_complete_smart_selftest_abort ( UDisksDriveAta *object, GDBusMethodInvocation *invocation); void udisks_drive_ata_complete_smart_set_enabled ( UDisksDriveAta *object, GDBusMethodInvocation *invocation); void udisks_drive_ata_complete_pm_get_state ( UDisksDriveAta *object, GDBusMethodInvocation *invocation, guchar state); void udisks_drive_ata_complete_pm_standby ( UDisksDriveAta *object, GDBusMethodInvocation *invocation); void udisks_drive_ata_complete_pm_wakeup ( UDisksDriveAta *object, GDBusMethodInvocation *invocation); void udisks_drive_ata_complete_security_erase_unit ( UDisksDriveAta *object, GDBusMethodInvocation *invocation); /* D-Bus method calls: */ void udisks_drive_ata_call_smart_update ( UDisksDriveAta *proxy, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_drive_ata_call_smart_update_finish ( UDisksDriveAta *proxy, GAsyncResult *res, GError **error); gboolean udisks_drive_ata_call_smart_update_sync ( UDisksDriveAta *proxy, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_drive_ata_call_smart_get_attributes ( UDisksDriveAta *proxy, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_drive_ata_call_smart_get_attributes_finish ( UDisksDriveAta *proxy, GVariant ** out_attributes, GAsyncResult *res, GError **error); gboolean udisks_drive_ata_call_smart_get_attributes_sync ( UDisksDriveAta *proxy, GVariant *arg_options, GVariant ** out_attributes, GCancellable *cancellable, GError **error); void udisks_drive_ata_call_smart_selftest_start ( UDisksDriveAta *proxy, const gchar *arg_type, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_drive_ata_call_smart_selftest_start_finish ( UDisksDriveAta *proxy, GAsyncResult *res, GError **error); gboolean udisks_drive_ata_call_smart_selftest_start_sync ( UDisksDriveAta *proxy, const gchar *arg_type, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_drive_ata_call_smart_selftest_abort ( UDisksDriveAta *proxy, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_drive_ata_call_smart_selftest_abort_finish ( UDisksDriveAta *proxy, GAsyncResult *res, GError **error); gboolean udisks_drive_ata_call_smart_selftest_abort_sync ( UDisksDriveAta *proxy, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_drive_ata_call_smart_set_enabled ( UDisksDriveAta *proxy, gboolean arg_value, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_drive_ata_call_smart_set_enabled_finish ( UDisksDriveAta *proxy, GAsyncResult *res, GError **error); gboolean udisks_drive_ata_call_smart_set_enabled_sync ( UDisksDriveAta *proxy, gboolean arg_value, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_drive_ata_call_pm_get_state ( UDisksDriveAta *proxy, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_drive_ata_call_pm_get_state_finish ( UDisksDriveAta *proxy, guchar* out_state, GAsyncResult *res, GError **error); gboolean udisks_drive_ata_call_pm_get_state_sync ( UDisksDriveAta *proxy, GVariant *arg_options, guchar* out_state, GCancellable *cancellable, GError **error); void udisks_drive_ata_call_pm_standby ( UDisksDriveAta *proxy, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_drive_ata_call_pm_standby_finish ( UDisksDriveAta *proxy, GAsyncResult *res, GError **error); gboolean udisks_drive_ata_call_pm_standby_sync ( UDisksDriveAta *proxy, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_drive_ata_call_pm_wakeup ( UDisksDriveAta *proxy, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_drive_ata_call_pm_wakeup_finish ( UDisksDriveAta *proxy, GAsyncResult *res, GError **error); gboolean udisks_drive_ata_call_pm_wakeup_sync ( UDisksDriveAta *proxy, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_drive_ata_call_security_erase_unit ( UDisksDriveAta *proxy, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_drive_ata_call_security_erase_unit_finish ( UDisksDriveAta *proxy, GAsyncResult *res, GError **error); gboolean udisks_drive_ata_call_security_erase_unit_sync ( UDisksDriveAta *proxy, GVariant *arg_options, GCancellable *cancellable, GError **error); /* D-Bus property accessors: */ gboolean udisks_drive_ata_get_smart_supported (UDisksDriveAta *object); void udisks_drive_ata_set_smart_supported (UDisksDriveAta *object, gboolean value); gboolean udisks_drive_ata_get_smart_enabled (UDisksDriveAta *object); void udisks_drive_ata_set_smart_enabled (UDisksDriveAta *object, gboolean value); guint64 udisks_drive_ata_get_smart_updated (UDisksDriveAta *object); void udisks_drive_ata_set_smart_updated (UDisksDriveAta *object, guint64 value); gboolean udisks_drive_ata_get_smart_failing (UDisksDriveAta *object); void udisks_drive_ata_set_smart_failing (UDisksDriveAta *object, gboolean value); guint64 udisks_drive_ata_get_smart_power_on_seconds (UDisksDriveAta *object); void udisks_drive_ata_set_smart_power_on_seconds (UDisksDriveAta *object, guint64 value); gdouble udisks_drive_ata_get_smart_temperature (UDisksDriveAta *object); void udisks_drive_ata_set_smart_temperature (UDisksDriveAta *object, gdouble value); gint udisks_drive_ata_get_smart_num_attributes_failing (UDisksDriveAta *object); void udisks_drive_ata_set_smart_num_attributes_failing (UDisksDriveAta *object, gint value); gint udisks_drive_ata_get_smart_num_attributes_failed_in_the_past (UDisksDriveAta *object); void udisks_drive_ata_set_smart_num_attributes_failed_in_the_past (UDisksDriveAta *object, gint value); gint64 udisks_drive_ata_get_smart_num_bad_sectors (UDisksDriveAta *object); void udisks_drive_ata_set_smart_num_bad_sectors (UDisksDriveAta *object, gint64 value); const gchar *udisks_drive_ata_get_smart_selftest_status (UDisksDriveAta *object); gchar *udisks_drive_ata_dup_smart_selftest_status (UDisksDriveAta *object); void udisks_drive_ata_set_smart_selftest_status (UDisksDriveAta *object, const gchar *value); gint udisks_drive_ata_get_smart_selftest_percent_remaining (UDisksDriveAta *object); void udisks_drive_ata_set_smart_selftest_percent_remaining (UDisksDriveAta *object, gint value); gboolean udisks_drive_ata_get_pm_supported (UDisksDriveAta *object); void udisks_drive_ata_set_pm_supported (UDisksDriveAta *object, gboolean value); gboolean udisks_drive_ata_get_pm_enabled (UDisksDriveAta *object); void udisks_drive_ata_set_pm_enabled (UDisksDriveAta *object, gboolean value); gboolean udisks_drive_ata_get_apm_supported (UDisksDriveAta *object); void udisks_drive_ata_set_apm_supported (UDisksDriveAta *object, gboolean value); gboolean udisks_drive_ata_get_apm_enabled (UDisksDriveAta *object); void udisks_drive_ata_set_apm_enabled (UDisksDriveAta *object, gboolean value); gboolean udisks_drive_ata_get_aam_supported (UDisksDriveAta *object); void udisks_drive_ata_set_aam_supported (UDisksDriveAta *object, gboolean value); gboolean udisks_drive_ata_get_aam_enabled (UDisksDriveAta *object); void udisks_drive_ata_set_aam_enabled (UDisksDriveAta *object, gboolean value); gint udisks_drive_ata_get_aam_vendor_recommended_value (UDisksDriveAta *object); void udisks_drive_ata_set_aam_vendor_recommended_value (UDisksDriveAta *object, gint value); gboolean udisks_drive_ata_get_write_cache_supported (UDisksDriveAta *object); void udisks_drive_ata_set_write_cache_supported (UDisksDriveAta *object, gboolean value); gboolean udisks_drive_ata_get_write_cache_enabled (UDisksDriveAta *object); void udisks_drive_ata_set_write_cache_enabled (UDisksDriveAta *object, gboolean value); gboolean udisks_drive_ata_get_read_lookahead_supported (UDisksDriveAta *object); void udisks_drive_ata_set_read_lookahead_supported (UDisksDriveAta *object, gboolean value); gboolean udisks_drive_ata_get_read_lookahead_enabled (UDisksDriveAta *object); void udisks_drive_ata_set_read_lookahead_enabled (UDisksDriveAta *object, gboolean value); gint udisks_drive_ata_get_security_erase_unit_minutes (UDisksDriveAta *object); void udisks_drive_ata_set_security_erase_unit_minutes (UDisksDriveAta *object, gint value); gint udisks_drive_ata_get_security_enhanced_erase_unit_minutes (UDisksDriveAta *object); void udisks_drive_ata_set_security_enhanced_erase_unit_minutes (UDisksDriveAta *object, gint value); gboolean udisks_drive_ata_get_security_frozen (UDisksDriveAta *object); void udisks_drive_ata_set_security_frozen (UDisksDriveAta *object, gboolean value); /* ---- */ #define UDISKS_TYPE_DRIVE_ATA_PROXY (udisks_drive_ata_proxy_get_type ()) #define UDISKS_DRIVE_ATA_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_DRIVE_ATA_PROXY, UDisksDriveAtaProxy)) #define UDISKS_DRIVE_ATA_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UDISKS_TYPE_DRIVE_ATA_PROXY, UDisksDriveAtaProxyClass)) #define UDISKS_DRIVE_ATA_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UDISKS_TYPE_DRIVE_ATA_PROXY, UDisksDriveAtaProxyClass)) #define UDISKS_IS_DRIVE_ATA_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_DRIVE_ATA_PROXY)) #define UDISKS_IS_DRIVE_ATA_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UDISKS_TYPE_DRIVE_ATA_PROXY)) typedef struct _UDisksDriveAtaProxy UDisksDriveAtaProxy; typedef struct _UDisksDriveAtaProxyClass UDisksDriveAtaProxyClass; typedef struct _UDisksDriveAtaProxyPrivate UDisksDriveAtaProxyPrivate; struct _UDisksDriveAtaProxy { /*< private >*/ GDBusProxy parent_instance; UDisksDriveAtaProxyPrivate *priv; }; struct _UDisksDriveAtaProxyClass { GDBusProxyClass parent_class; }; GType udisks_drive_ata_proxy_get_type (void); #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksDriveAtaProxy, g_object_unref) #endif void udisks_drive_ata_proxy_new ( GDBusConnection *connection, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); UDisksDriveAta *udisks_drive_ata_proxy_new_finish ( GAsyncResult *res, GError **error); UDisksDriveAta *udisks_drive_ata_proxy_new_sync ( GDBusConnection *connection, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GError **error); void udisks_drive_ata_proxy_new_for_bus ( GBusType bus_type, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); UDisksDriveAta *udisks_drive_ata_proxy_new_for_bus_finish ( GAsyncResult *res, GError **error); UDisksDriveAta *udisks_drive_ata_proxy_new_for_bus_sync ( GBusType bus_type, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GError **error); /* ---- */ #define UDISKS_TYPE_DRIVE_ATA_SKELETON (udisks_drive_ata_skeleton_get_type ()) #define UDISKS_DRIVE_ATA_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_DRIVE_ATA_SKELETON, UDisksDriveAtaSkeleton)) #define UDISKS_DRIVE_ATA_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UDISKS_TYPE_DRIVE_ATA_SKELETON, UDisksDriveAtaSkeletonClass)) #define UDISKS_DRIVE_ATA_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UDISKS_TYPE_DRIVE_ATA_SKELETON, UDisksDriveAtaSkeletonClass)) #define UDISKS_IS_DRIVE_ATA_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_DRIVE_ATA_SKELETON)) #define UDISKS_IS_DRIVE_ATA_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UDISKS_TYPE_DRIVE_ATA_SKELETON)) typedef struct _UDisksDriveAtaSkeleton UDisksDriveAtaSkeleton; typedef struct _UDisksDriveAtaSkeletonClass UDisksDriveAtaSkeletonClass; typedef struct _UDisksDriveAtaSkeletonPrivate UDisksDriveAtaSkeletonPrivate; struct _UDisksDriveAtaSkeleton { /*< private >*/ GDBusInterfaceSkeleton parent_instance; UDisksDriveAtaSkeletonPrivate *priv; }; struct _UDisksDriveAtaSkeletonClass { GDBusInterfaceSkeletonClass parent_class; }; GType udisks_drive_ata_skeleton_get_type (void); #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksDriveAtaSkeleton, g_object_unref) #endif UDisksDriveAta *udisks_drive_ata_skeleton_new (void); /* ------------------------------------------------------------------------ */ /* Declarations for org.freedesktop.UDisks2.NVMe.Controller */ #define UDISKS_TYPE_NVME_CONTROLLER (udisks_nvme_controller_get_type ()) #define UDISKS_NVME_CONTROLLER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_NVME_CONTROLLER, UDisksNVMeController)) #define UDISKS_IS_NVME_CONTROLLER(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_NVME_CONTROLLER)) #define UDISKS_NVME_CONTROLLER_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), UDISKS_TYPE_NVME_CONTROLLER, UDisksNVMeControllerIface)) struct _UDisksNVMeController; typedef struct _UDisksNVMeController UDisksNVMeController; typedef struct _UDisksNVMeControllerIface UDisksNVMeControllerIface; struct _UDisksNVMeControllerIface { GTypeInterface parent_iface; guint16 (*get_controller_id) (UDisksNVMeController *object); const gchar * (*get_fguid) (UDisksNVMeController *object); const gchar * (*get_nvme_revision) (UDisksNVMeController *object); const gchar * (*get_sanitize_status) (UDisksNVMeController *object); const gchar *const * (*get_smart_critical_warning) (UDisksNVMeController *object); guint64 (*get_smart_power_on_hours) (UDisksNVMeController *object); const gchar * (*get_smart_selftest_status) (UDisksNVMeController *object); guint16 (*get_smart_temperature) (UDisksNVMeController *object); guint64 (*get_smart_updated) (UDisksNVMeController *object); const gchar * (*get_state) (UDisksNVMeController *object); const gchar * (*get_subsystem_nqn) (UDisksNVMeController *object); guint64 (*get_unallocated_capacity) (UDisksNVMeController *object); gboolean (*handle_sanitize_start) ( UDisksNVMeController *object, GDBusMethodInvocation *invocation, const gchar *arg_action, GVariant *arg_options); gboolean (*handle_smart_get_attributes) ( UDisksNVMeController *object, GDBusMethodInvocation *invocation, GVariant *arg_options); gboolean (*handle_smart_selftest_abort) ( UDisksNVMeController *object, GDBusMethodInvocation *invocation, GVariant *arg_options); gboolean (*handle_smart_selftest_start) ( UDisksNVMeController *object, GDBusMethodInvocation *invocation, const gchar *arg_type, GVariant *arg_options); gboolean (*handle_smart_update) ( UDisksNVMeController *object, GDBusMethodInvocation *invocation, GVariant *arg_options); gint (*get_sanitize_percent_remaining) (UDisksNVMeController *object); gint (*get_smart_selftest_percent_remaining) (UDisksNVMeController *object); }; #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksNVMeController, g_object_unref) #endif GType udisks_nvme_controller_get_type (void); GDBusInterfaceInfo *udisks_nvme_controller_interface_info (void); guint udisks_nvme_controller_override_properties (GObjectClass *klass, guint property_id_begin); /* D-Bus method call completion functions: */ void udisks_nvme_controller_complete_smart_update ( UDisksNVMeController *object, GDBusMethodInvocation *invocation); void udisks_nvme_controller_complete_smart_get_attributes ( UDisksNVMeController *object, GDBusMethodInvocation *invocation, GVariant *attributes); void udisks_nvme_controller_complete_smart_selftest_start ( UDisksNVMeController *object, GDBusMethodInvocation *invocation); void udisks_nvme_controller_complete_smart_selftest_abort ( UDisksNVMeController *object, GDBusMethodInvocation *invocation); void udisks_nvme_controller_complete_sanitize_start ( UDisksNVMeController *object, GDBusMethodInvocation *invocation); /* D-Bus method calls: */ void udisks_nvme_controller_call_smart_update ( UDisksNVMeController *proxy, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_nvme_controller_call_smart_update_finish ( UDisksNVMeController *proxy, GAsyncResult *res, GError **error); gboolean udisks_nvme_controller_call_smart_update_sync ( UDisksNVMeController *proxy, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_nvme_controller_call_smart_get_attributes ( UDisksNVMeController *proxy, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_nvme_controller_call_smart_get_attributes_finish ( UDisksNVMeController *proxy, GVariant ** out_attributes, GAsyncResult *res, GError **error); gboolean udisks_nvme_controller_call_smart_get_attributes_sync ( UDisksNVMeController *proxy, GVariant *arg_options, GVariant ** out_attributes, GCancellable *cancellable, GError **error); void udisks_nvme_controller_call_smart_selftest_start ( UDisksNVMeController *proxy, const gchar *arg_type, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_nvme_controller_call_smart_selftest_start_finish ( UDisksNVMeController *proxy, GAsyncResult *res, GError **error); gboolean udisks_nvme_controller_call_smart_selftest_start_sync ( UDisksNVMeController *proxy, const gchar *arg_type, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_nvme_controller_call_smart_selftest_abort ( UDisksNVMeController *proxy, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_nvme_controller_call_smart_selftest_abort_finish ( UDisksNVMeController *proxy, GAsyncResult *res, GError **error); gboolean udisks_nvme_controller_call_smart_selftest_abort_sync ( UDisksNVMeController *proxy, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_nvme_controller_call_sanitize_start ( UDisksNVMeController *proxy, const gchar *arg_action, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_nvme_controller_call_sanitize_start_finish ( UDisksNVMeController *proxy, GAsyncResult *res, GError **error); gboolean udisks_nvme_controller_call_sanitize_start_sync ( UDisksNVMeController *proxy, const gchar *arg_action, GVariant *arg_options, GCancellable *cancellable, GError **error); /* D-Bus property accessors: */ const gchar *udisks_nvme_controller_get_state (UDisksNVMeController *object); gchar *udisks_nvme_controller_dup_state (UDisksNVMeController *object); void udisks_nvme_controller_set_state (UDisksNVMeController *object, const gchar *value); guint16 udisks_nvme_controller_get_controller_id (UDisksNVMeController *object); void udisks_nvme_controller_set_controller_id (UDisksNVMeController *object, guint16 value); const gchar *udisks_nvme_controller_get_subsystem_nqn (UDisksNVMeController *object); gchar *udisks_nvme_controller_dup_subsystem_nqn (UDisksNVMeController *object); void udisks_nvme_controller_set_subsystem_nqn (UDisksNVMeController *object, const gchar *value); const gchar *udisks_nvme_controller_get_fguid (UDisksNVMeController *object); gchar *udisks_nvme_controller_dup_fguid (UDisksNVMeController *object); void udisks_nvme_controller_set_fguid (UDisksNVMeController *object, const gchar *value); const gchar *udisks_nvme_controller_get_nvme_revision (UDisksNVMeController *object); gchar *udisks_nvme_controller_dup_nvme_revision (UDisksNVMeController *object); void udisks_nvme_controller_set_nvme_revision (UDisksNVMeController *object, const gchar *value); guint64 udisks_nvme_controller_get_unallocated_capacity (UDisksNVMeController *object); void udisks_nvme_controller_set_unallocated_capacity (UDisksNVMeController *object, guint64 value); guint64 udisks_nvme_controller_get_smart_updated (UDisksNVMeController *object); void udisks_nvme_controller_set_smart_updated (UDisksNVMeController *object, guint64 value); const gchar *const *udisks_nvme_controller_get_smart_critical_warning (UDisksNVMeController *object); gchar **udisks_nvme_controller_dup_smart_critical_warning (UDisksNVMeController *object); void udisks_nvme_controller_set_smart_critical_warning (UDisksNVMeController *object, const gchar *const *value); guint64 udisks_nvme_controller_get_smart_power_on_hours (UDisksNVMeController *object); void udisks_nvme_controller_set_smart_power_on_hours (UDisksNVMeController *object, guint64 value); guint16 udisks_nvme_controller_get_smart_temperature (UDisksNVMeController *object); void udisks_nvme_controller_set_smart_temperature (UDisksNVMeController *object, guint16 value); const gchar *udisks_nvme_controller_get_smart_selftest_status (UDisksNVMeController *object); gchar *udisks_nvme_controller_dup_smart_selftest_status (UDisksNVMeController *object); void udisks_nvme_controller_set_smart_selftest_status (UDisksNVMeController *object, const gchar *value); gint udisks_nvme_controller_get_smart_selftest_percent_remaining (UDisksNVMeController *object); void udisks_nvme_controller_set_smart_selftest_percent_remaining (UDisksNVMeController *object, gint value); const gchar *udisks_nvme_controller_get_sanitize_status (UDisksNVMeController *object); gchar *udisks_nvme_controller_dup_sanitize_status (UDisksNVMeController *object); void udisks_nvme_controller_set_sanitize_status (UDisksNVMeController *object, const gchar *value); gint udisks_nvme_controller_get_sanitize_percent_remaining (UDisksNVMeController *object); void udisks_nvme_controller_set_sanitize_percent_remaining (UDisksNVMeController *object, gint value); /* ---- */ #define UDISKS_TYPE_NVME_CONTROLLER_PROXY (udisks_nvme_controller_proxy_get_type ()) #define UDISKS_NVME_CONTROLLER_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_NVME_CONTROLLER_PROXY, UDisksNVMeControllerProxy)) #define UDISKS_NVME_CONTROLLER_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UDISKS_TYPE_NVME_CONTROLLER_PROXY, UDisksNVMeControllerProxyClass)) #define UDISKS_NVME_CONTROLLER_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UDISKS_TYPE_NVME_CONTROLLER_PROXY, UDisksNVMeControllerProxyClass)) #define UDISKS_IS_NVME_CONTROLLER_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_NVME_CONTROLLER_PROXY)) #define UDISKS_IS_NVME_CONTROLLER_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UDISKS_TYPE_NVME_CONTROLLER_PROXY)) typedef struct _UDisksNVMeControllerProxy UDisksNVMeControllerProxy; typedef struct _UDisksNVMeControllerProxyClass UDisksNVMeControllerProxyClass; typedef struct _UDisksNVMeControllerProxyPrivate UDisksNVMeControllerProxyPrivate; struct _UDisksNVMeControllerProxy { /*< private >*/ GDBusProxy parent_instance; UDisksNVMeControllerProxyPrivate *priv; }; struct _UDisksNVMeControllerProxyClass { GDBusProxyClass parent_class; }; GType udisks_nvme_controller_proxy_get_type (void); #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksNVMeControllerProxy, g_object_unref) #endif void udisks_nvme_controller_proxy_new ( GDBusConnection *connection, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); UDisksNVMeController *udisks_nvme_controller_proxy_new_finish ( GAsyncResult *res, GError **error); UDisksNVMeController *udisks_nvme_controller_proxy_new_sync ( GDBusConnection *connection, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GError **error); void udisks_nvme_controller_proxy_new_for_bus ( GBusType bus_type, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); UDisksNVMeController *udisks_nvme_controller_proxy_new_for_bus_finish ( GAsyncResult *res, GError **error); UDisksNVMeController *udisks_nvme_controller_proxy_new_for_bus_sync ( GBusType bus_type, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GError **error); /* ---- */ #define UDISKS_TYPE_NVME_CONTROLLER_SKELETON (udisks_nvme_controller_skeleton_get_type ()) #define UDISKS_NVME_CONTROLLER_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_NVME_CONTROLLER_SKELETON, UDisksNVMeControllerSkeleton)) #define UDISKS_NVME_CONTROLLER_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UDISKS_TYPE_NVME_CONTROLLER_SKELETON, UDisksNVMeControllerSkeletonClass)) #define UDISKS_NVME_CONTROLLER_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UDISKS_TYPE_NVME_CONTROLLER_SKELETON, UDisksNVMeControllerSkeletonClass)) #define UDISKS_IS_NVME_CONTROLLER_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_NVME_CONTROLLER_SKELETON)) #define UDISKS_IS_NVME_CONTROLLER_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UDISKS_TYPE_NVME_CONTROLLER_SKELETON)) typedef struct _UDisksNVMeControllerSkeleton UDisksNVMeControllerSkeleton; typedef struct _UDisksNVMeControllerSkeletonClass UDisksNVMeControllerSkeletonClass; typedef struct _UDisksNVMeControllerSkeletonPrivate UDisksNVMeControllerSkeletonPrivate; struct _UDisksNVMeControllerSkeleton { /*< private >*/ GDBusInterfaceSkeleton parent_instance; UDisksNVMeControllerSkeletonPrivate *priv; }; struct _UDisksNVMeControllerSkeletonClass { GDBusInterfaceSkeletonClass parent_class; }; GType udisks_nvme_controller_skeleton_get_type (void); #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksNVMeControllerSkeleton, g_object_unref) #endif UDisksNVMeController *udisks_nvme_controller_skeleton_new (void); /* ------------------------------------------------------------------------ */ /* Declarations for org.freedesktop.UDisks2.NVMe.Namespace */ #define UDISKS_TYPE_NVME_NAMESPACE (udisks_nvme_namespace_get_type ()) #define UDISKS_NVME_NAMESPACE(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_NVME_NAMESPACE, UDisksNVMeNamespace)) #define UDISKS_IS_NVME_NAMESPACE(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_NVME_NAMESPACE)) #define UDISKS_NVME_NAMESPACE_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), UDISKS_TYPE_NVME_NAMESPACE, UDisksNVMeNamespaceIface)) struct _UDisksNVMeNamespace; typedef struct _UDisksNVMeNamespace UDisksNVMeNamespace; typedef struct _UDisksNVMeNamespaceIface UDisksNVMeNamespaceIface; struct _UDisksNVMeNamespaceIface { GTypeInterface parent_iface; const gchar * (*get_eui64) (UDisksNVMeNamespace *object); GVariant * (*get_formatted_lbasize) (UDisksNVMeNamespace *object); GVariant * (*get_lbaformats) (UDisksNVMeNamespace *object); guint64 (*get_namespace_capacity) (UDisksNVMeNamespace *object); guint64 (*get_namespace_size) (UDisksNVMeNamespace *object); guint64 (*get_namespace_utilization) (UDisksNVMeNamespace *object); const gchar * (*get_nguid) (UDisksNVMeNamespace *object); guint (*get_nsid) (UDisksNVMeNamespace *object); const gchar * (*get_uuid) (UDisksNVMeNamespace *object); const gchar * (*get_wwn) (UDisksNVMeNamespace *object); gboolean (*handle_format_namespace) ( UDisksNVMeNamespace *object, GDBusMethodInvocation *invocation, GVariant *arg_options); gint (*get_format_percent_remaining) (UDisksNVMeNamespace *object); }; #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksNVMeNamespace, g_object_unref) #endif GType udisks_nvme_namespace_get_type (void); GDBusInterfaceInfo *udisks_nvme_namespace_interface_info (void); guint udisks_nvme_namespace_override_properties (GObjectClass *klass, guint property_id_begin); /* D-Bus method call completion functions: */ void udisks_nvme_namespace_complete_format_namespace ( UDisksNVMeNamespace *object, GDBusMethodInvocation *invocation); /* D-Bus method calls: */ void udisks_nvme_namespace_call_format_namespace ( UDisksNVMeNamespace *proxy, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_nvme_namespace_call_format_namespace_finish ( UDisksNVMeNamespace *proxy, GAsyncResult *res, GError **error); gboolean udisks_nvme_namespace_call_format_namespace_sync ( UDisksNVMeNamespace *proxy, GVariant *arg_options, GCancellable *cancellable, GError **error); /* D-Bus property accessors: */ guint udisks_nvme_namespace_get_nsid (UDisksNVMeNamespace *object); void udisks_nvme_namespace_set_nsid (UDisksNVMeNamespace *object, guint value); const gchar *udisks_nvme_namespace_get_nguid (UDisksNVMeNamespace *object); gchar *udisks_nvme_namespace_dup_nguid (UDisksNVMeNamespace *object); void udisks_nvme_namespace_set_nguid (UDisksNVMeNamespace *object, const gchar *value); const gchar *udisks_nvme_namespace_get_eui64 (UDisksNVMeNamespace *object); gchar *udisks_nvme_namespace_dup_eui64 (UDisksNVMeNamespace *object); void udisks_nvme_namespace_set_eui64 (UDisksNVMeNamespace *object, const gchar *value); const gchar *udisks_nvme_namespace_get_uuid (UDisksNVMeNamespace *object); gchar *udisks_nvme_namespace_dup_uuid (UDisksNVMeNamespace *object); void udisks_nvme_namespace_set_uuid (UDisksNVMeNamespace *object, const gchar *value); const gchar *udisks_nvme_namespace_get_wwn (UDisksNVMeNamespace *object); gchar *udisks_nvme_namespace_dup_wwn (UDisksNVMeNamespace *object); void udisks_nvme_namespace_set_wwn (UDisksNVMeNamespace *object, const gchar *value); GVariant *udisks_nvme_namespace_get_lbaformats (UDisksNVMeNamespace *object); GVariant *udisks_nvme_namespace_dup_lbaformats (UDisksNVMeNamespace *object); void udisks_nvme_namespace_set_lbaformats (UDisksNVMeNamespace *object, GVariant *value); GVariant *udisks_nvme_namespace_get_formatted_lbasize (UDisksNVMeNamespace *object); GVariant *udisks_nvme_namespace_dup_formatted_lbasize (UDisksNVMeNamespace *object); void udisks_nvme_namespace_set_formatted_lbasize (UDisksNVMeNamespace *object, GVariant *value); guint64 udisks_nvme_namespace_get_namespace_size (UDisksNVMeNamespace *object); void udisks_nvme_namespace_set_namespace_size (UDisksNVMeNamespace *object, guint64 value); guint64 udisks_nvme_namespace_get_namespace_capacity (UDisksNVMeNamespace *object); void udisks_nvme_namespace_set_namespace_capacity (UDisksNVMeNamespace *object, guint64 value); guint64 udisks_nvme_namespace_get_namespace_utilization (UDisksNVMeNamespace *object); void udisks_nvme_namespace_set_namespace_utilization (UDisksNVMeNamespace *object, guint64 value); gint udisks_nvme_namespace_get_format_percent_remaining (UDisksNVMeNamespace *object); void udisks_nvme_namespace_set_format_percent_remaining (UDisksNVMeNamespace *object, gint value); /* ---- */ #define UDISKS_TYPE_NVME_NAMESPACE_PROXY (udisks_nvme_namespace_proxy_get_type ()) #define UDISKS_NVME_NAMESPACE_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_NVME_NAMESPACE_PROXY, UDisksNVMeNamespaceProxy)) #define UDISKS_NVME_NAMESPACE_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UDISKS_TYPE_NVME_NAMESPACE_PROXY, UDisksNVMeNamespaceProxyClass)) #define UDISKS_NVME_NAMESPACE_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UDISKS_TYPE_NVME_NAMESPACE_PROXY, UDisksNVMeNamespaceProxyClass)) #define UDISKS_IS_NVME_NAMESPACE_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_NVME_NAMESPACE_PROXY)) #define UDISKS_IS_NVME_NAMESPACE_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UDISKS_TYPE_NVME_NAMESPACE_PROXY)) typedef struct _UDisksNVMeNamespaceProxy UDisksNVMeNamespaceProxy; typedef struct _UDisksNVMeNamespaceProxyClass UDisksNVMeNamespaceProxyClass; typedef struct _UDisksNVMeNamespaceProxyPrivate UDisksNVMeNamespaceProxyPrivate; struct _UDisksNVMeNamespaceProxy { /*< private >*/ GDBusProxy parent_instance; UDisksNVMeNamespaceProxyPrivate *priv; }; struct _UDisksNVMeNamespaceProxyClass { GDBusProxyClass parent_class; }; GType udisks_nvme_namespace_proxy_get_type (void); #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksNVMeNamespaceProxy, g_object_unref) #endif void udisks_nvme_namespace_proxy_new ( GDBusConnection *connection, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); UDisksNVMeNamespace *udisks_nvme_namespace_proxy_new_finish ( GAsyncResult *res, GError **error); UDisksNVMeNamespace *udisks_nvme_namespace_proxy_new_sync ( GDBusConnection *connection, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GError **error); void udisks_nvme_namespace_proxy_new_for_bus ( GBusType bus_type, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); UDisksNVMeNamespace *udisks_nvme_namespace_proxy_new_for_bus_finish ( GAsyncResult *res, GError **error); UDisksNVMeNamespace *udisks_nvme_namespace_proxy_new_for_bus_sync ( GBusType bus_type, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GError **error); /* ---- */ #define UDISKS_TYPE_NVME_NAMESPACE_SKELETON (udisks_nvme_namespace_skeleton_get_type ()) #define UDISKS_NVME_NAMESPACE_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_NVME_NAMESPACE_SKELETON, UDisksNVMeNamespaceSkeleton)) #define UDISKS_NVME_NAMESPACE_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UDISKS_TYPE_NVME_NAMESPACE_SKELETON, UDisksNVMeNamespaceSkeletonClass)) #define UDISKS_NVME_NAMESPACE_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UDISKS_TYPE_NVME_NAMESPACE_SKELETON, UDisksNVMeNamespaceSkeletonClass)) #define UDISKS_IS_NVME_NAMESPACE_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_NVME_NAMESPACE_SKELETON)) #define UDISKS_IS_NVME_NAMESPACE_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UDISKS_TYPE_NVME_NAMESPACE_SKELETON)) typedef struct _UDisksNVMeNamespaceSkeleton UDisksNVMeNamespaceSkeleton; typedef struct _UDisksNVMeNamespaceSkeletonClass UDisksNVMeNamespaceSkeletonClass; typedef struct _UDisksNVMeNamespaceSkeletonPrivate UDisksNVMeNamespaceSkeletonPrivate; struct _UDisksNVMeNamespaceSkeleton { /*< private >*/ GDBusInterfaceSkeleton parent_instance; UDisksNVMeNamespaceSkeletonPrivate *priv; }; struct _UDisksNVMeNamespaceSkeletonClass { GDBusInterfaceSkeletonClass parent_class; }; GType udisks_nvme_namespace_skeleton_get_type (void); #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksNVMeNamespaceSkeleton, g_object_unref) #endif UDisksNVMeNamespace *udisks_nvme_namespace_skeleton_new (void); /* ------------------------------------------------------------------------ */ /* Declarations for org.freedesktop.UDisks2.NVMe.Fabrics */ #define UDISKS_TYPE_NVME_FABRICS (udisks_nvme_fabrics_get_type ()) #define UDISKS_NVME_FABRICS(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_NVME_FABRICS, UDisksNVMeFabrics)) #define UDISKS_IS_NVME_FABRICS(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_NVME_FABRICS)) #define UDISKS_NVME_FABRICS_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), UDISKS_TYPE_NVME_FABRICS, UDisksNVMeFabricsIface)) struct _UDisksNVMeFabrics; typedef struct _UDisksNVMeFabrics UDisksNVMeFabrics; typedef struct _UDisksNVMeFabricsIface UDisksNVMeFabricsIface; struct _UDisksNVMeFabricsIface { GTypeInterface parent_iface; const gchar * (*get_host_id) (UDisksNVMeFabrics *object); const gchar * (*get_host_nqn) (UDisksNVMeFabrics *object); const gchar * (*get_transport) (UDisksNVMeFabrics *object); const gchar * (*get_transport_address) (UDisksNVMeFabrics *object); gboolean (*handle_disconnect) ( UDisksNVMeFabrics *object, GDBusMethodInvocation *invocation, GVariant *arg_options); }; #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksNVMeFabrics, g_object_unref) #endif GType udisks_nvme_fabrics_get_type (void); GDBusInterfaceInfo *udisks_nvme_fabrics_interface_info (void); guint udisks_nvme_fabrics_override_properties (GObjectClass *klass, guint property_id_begin); /* D-Bus method call completion functions: */ void udisks_nvme_fabrics_complete_disconnect ( UDisksNVMeFabrics *object, GDBusMethodInvocation *invocation); /* D-Bus method calls: */ void udisks_nvme_fabrics_call_disconnect ( UDisksNVMeFabrics *proxy, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_nvme_fabrics_call_disconnect_finish ( UDisksNVMeFabrics *proxy, GAsyncResult *res, GError **error); gboolean udisks_nvme_fabrics_call_disconnect_sync ( UDisksNVMeFabrics *proxy, GVariant *arg_options, GCancellable *cancellable, GError **error); /* D-Bus property accessors: */ const gchar *udisks_nvme_fabrics_get_host_nqn (UDisksNVMeFabrics *object); gchar *udisks_nvme_fabrics_dup_host_nqn (UDisksNVMeFabrics *object); void udisks_nvme_fabrics_set_host_nqn (UDisksNVMeFabrics *object, const gchar *value); const gchar *udisks_nvme_fabrics_get_host_id (UDisksNVMeFabrics *object); gchar *udisks_nvme_fabrics_dup_host_id (UDisksNVMeFabrics *object); void udisks_nvme_fabrics_set_host_id (UDisksNVMeFabrics *object, const gchar *value); const gchar *udisks_nvme_fabrics_get_transport (UDisksNVMeFabrics *object); gchar *udisks_nvme_fabrics_dup_transport (UDisksNVMeFabrics *object); void udisks_nvme_fabrics_set_transport (UDisksNVMeFabrics *object, const gchar *value); const gchar *udisks_nvme_fabrics_get_transport_address (UDisksNVMeFabrics *object); gchar *udisks_nvme_fabrics_dup_transport_address (UDisksNVMeFabrics *object); void udisks_nvme_fabrics_set_transport_address (UDisksNVMeFabrics *object, const gchar *value); /* ---- */ #define UDISKS_TYPE_NVME_FABRICS_PROXY (udisks_nvme_fabrics_proxy_get_type ()) #define UDISKS_NVME_FABRICS_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_NVME_FABRICS_PROXY, UDisksNVMeFabricsProxy)) #define UDISKS_NVME_FABRICS_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UDISKS_TYPE_NVME_FABRICS_PROXY, UDisksNVMeFabricsProxyClass)) #define UDISKS_NVME_FABRICS_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UDISKS_TYPE_NVME_FABRICS_PROXY, UDisksNVMeFabricsProxyClass)) #define UDISKS_IS_NVME_FABRICS_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_NVME_FABRICS_PROXY)) #define UDISKS_IS_NVME_FABRICS_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UDISKS_TYPE_NVME_FABRICS_PROXY)) typedef struct _UDisksNVMeFabricsProxy UDisksNVMeFabricsProxy; typedef struct _UDisksNVMeFabricsProxyClass UDisksNVMeFabricsProxyClass; typedef struct _UDisksNVMeFabricsProxyPrivate UDisksNVMeFabricsProxyPrivate; struct _UDisksNVMeFabricsProxy { /*< private >*/ GDBusProxy parent_instance; UDisksNVMeFabricsProxyPrivate *priv; }; struct _UDisksNVMeFabricsProxyClass { GDBusProxyClass parent_class; }; GType udisks_nvme_fabrics_proxy_get_type (void); #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksNVMeFabricsProxy, g_object_unref) #endif void udisks_nvme_fabrics_proxy_new ( GDBusConnection *connection, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); UDisksNVMeFabrics *udisks_nvme_fabrics_proxy_new_finish ( GAsyncResult *res, GError **error); UDisksNVMeFabrics *udisks_nvme_fabrics_proxy_new_sync ( GDBusConnection *connection, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GError **error); void udisks_nvme_fabrics_proxy_new_for_bus ( GBusType bus_type, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); UDisksNVMeFabrics *udisks_nvme_fabrics_proxy_new_for_bus_finish ( GAsyncResult *res, GError **error); UDisksNVMeFabrics *udisks_nvme_fabrics_proxy_new_for_bus_sync ( GBusType bus_type, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GError **error); /* ---- */ #define UDISKS_TYPE_NVME_FABRICS_SKELETON (udisks_nvme_fabrics_skeleton_get_type ()) #define UDISKS_NVME_FABRICS_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_NVME_FABRICS_SKELETON, UDisksNVMeFabricsSkeleton)) #define UDISKS_NVME_FABRICS_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UDISKS_TYPE_NVME_FABRICS_SKELETON, UDisksNVMeFabricsSkeletonClass)) #define UDISKS_NVME_FABRICS_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UDISKS_TYPE_NVME_FABRICS_SKELETON, UDisksNVMeFabricsSkeletonClass)) #define UDISKS_IS_NVME_FABRICS_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_NVME_FABRICS_SKELETON)) #define UDISKS_IS_NVME_FABRICS_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UDISKS_TYPE_NVME_FABRICS_SKELETON)) typedef struct _UDisksNVMeFabricsSkeleton UDisksNVMeFabricsSkeleton; typedef struct _UDisksNVMeFabricsSkeletonClass UDisksNVMeFabricsSkeletonClass; typedef struct _UDisksNVMeFabricsSkeletonPrivate UDisksNVMeFabricsSkeletonPrivate; struct _UDisksNVMeFabricsSkeleton { /*< private >*/ GDBusInterfaceSkeleton parent_instance; UDisksNVMeFabricsSkeletonPrivate *priv; }; struct _UDisksNVMeFabricsSkeletonClass { GDBusInterfaceSkeletonClass parent_class; }; GType udisks_nvme_fabrics_skeleton_get_type (void); #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksNVMeFabricsSkeleton, g_object_unref) #endif UDisksNVMeFabrics *udisks_nvme_fabrics_skeleton_new (void); /* ------------------------------------------------------------------------ */ /* Declarations for org.freedesktop.UDisks2.Block */ #define UDISKS_TYPE_BLOCK (udisks_block_get_type ()) #define UDISKS_BLOCK(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_BLOCK, UDisksBlock)) #define UDISKS_IS_BLOCK(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_BLOCK)) #define UDISKS_BLOCK_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), UDISKS_TYPE_BLOCK, UDisksBlockIface)) struct _UDisksBlock; typedef struct _UDisksBlock UDisksBlock; typedef struct _UDisksBlockIface UDisksBlockIface; struct _UDisksBlockIface { GTypeInterface parent_iface; gboolean (*handle_add_configuration_item) ( UDisksBlock *object, GDBusMethodInvocation *invocation, GVariant *arg_item, GVariant *arg_options); gboolean (*handle_format) ( UDisksBlock *object, GDBusMethodInvocation *invocation, const gchar *arg_type, GVariant *arg_options); gboolean (*handle_get_secret_configuration) ( UDisksBlock *object, GDBusMethodInvocation *invocation, GVariant *arg_options); gboolean (*handle_open_for_backup) ( UDisksBlock *object, GDBusMethodInvocation *invocation, GUnixFDList *fd_list, GVariant *arg_options); gboolean (*handle_open_for_benchmark) ( UDisksBlock *object, GDBusMethodInvocation *invocation, GUnixFDList *fd_list, GVariant *arg_options); gboolean (*handle_open_for_restore) ( UDisksBlock *object, GDBusMethodInvocation *invocation, GUnixFDList *fd_list, GVariant *arg_options); gboolean (*handle_remove_configuration_item) ( UDisksBlock *object, GDBusMethodInvocation *invocation, GVariant *arg_item, GVariant *arg_options); gboolean (*handle_rescan) ( UDisksBlock *object, GDBusMethodInvocation *invocation, GVariant *arg_options); gboolean (*handle_update_configuration_item) ( UDisksBlock *object, GDBusMethodInvocation *invocation, GVariant *arg_old_item, GVariant *arg_new_item, GVariant *arg_options); GVariant * (*get_configuration) (UDisksBlock *object); const gchar * (*get_crypto_backing_device) (UDisksBlock *object); const gchar * (*get_device) (UDisksBlock *object); guint64 (*get_device_number) (UDisksBlock *object); const gchar * (*get_drive) (UDisksBlock *object); gboolean (*get_hint_auto) (UDisksBlock *object); const gchar * (*get_hint_icon_name) (UDisksBlock *object); gboolean (*get_hint_ignore) (UDisksBlock *object); const gchar * (*get_hint_name) (UDisksBlock *object); gboolean (*get_hint_partitionable) (UDisksBlock *object); const gchar * (*get_hint_symbolic_icon_name) (UDisksBlock *object); gboolean (*get_hint_system) (UDisksBlock *object); const gchar * (*get_id) (UDisksBlock *object); const gchar * (*get_id_label) (UDisksBlock *object); const gchar * (*get_id_type) (UDisksBlock *object); const gchar * (*get_id_usage) (UDisksBlock *object); const gchar * (*get_id_uuid) (UDisksBlock *object); const gchar * (*get_id_version) (UDisksBlock *object); const gchar * (*get_mdraid) (UDisksBlock *object); const gchar * (*get_mdraid_member) (UDisksBlock *object); const gchar * (*get_preferred_device) (UDisksBlock *object); gboolean (*get_read_only) (UDisksBlock *object); guint64 (*get_size) (UDisksBlock *object); const gchar *const * (*get_symlinks) (UDisksBlock *object); const gchar *const * (*get_userspace_mount_options) (UDisksBlock *object); gboolean (*handle_open_device) ( UDisksBlock *object, GDBusMethodInvocation *invocation, GUnixFDList *fd_list, const gchar *arg_mode, GVariant *arg_options); gboolean (*handle_restore_encrypted_header) ( UDisksBlock *object, GDBusMethodInvocation *invocation, const gchar *arg_backup_file, GVariant *arg_options); }; #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksBlock, g_object_unref) #endif GType udisks_block_get_type (void); GDBusInterfaceInfo *udisks_block_interface_info (void); guint udisks_block_override_properties (GObjectClass *klass, guint property_id_begin); /* D-Bus method call completion functions: */ void udisks_block_complete_add_configuration_item ( UDisksBlock *object, GDBusMethodInvocation *invocation); void udisks_block_complete_remove_configuration_item ( UDisksBlock *object, GDBusMethodInvocation *invocation); void udisks_block_complete_update_configuration_item ( UDisksBlock *object, GDBusMethodInvocation *invocation); void udisks_block_complete_get_secret_configuration ( UDisksBlock *object, GDBusMethodInvocation *invocation, GVariant *configuration); void udisks_block_complete_format ( UDisksBlock *object, GDBusMethodInvocation *invocation); void udisks_block_complete_open_for_backup ( UDisksBlock *object, GDBusMethodInvocation *invocation, GUnixFDList *fd_list, GVariant *fd); void udisks_block_complete_open_for_restore ( UDisksBlock *object, GDBusMethodInvocation *invocation, GUnixFDList *fd_list, GVariant *fd); void udisks_block_complete_open_for_benchmark ( UDisksBlock *object, GDBusMethodInvocation *invocation, GUnixFDList *fd_list, GVariant *fd); void udisks_block_complete_open_device ( UDisksBlock *object, GDBusMethodInvocation *invocation, GUnixFDList *fd_list, GVariant *fd); void udisks_block_complete_rescan ( UDisksBlock *object, GDBusMethodInvocation *invocation); void udisks_block_complete_restore_encrypted_header ( UDisksBlock *object, GDBusMethodInvocation *invocation); /* D-Bus method calls: */ void udisks_block_call_add_configuration_item ( UDisksBlock *proxy, GVariant *arg_item, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_block_call_add_configuration_item_finish ( UDisksBlock *proxy, GAsyncResult *res, GError **error); gboolean udisks_block_call_add_configuration_item_sync ( UDisksBlock *proxy, GVariant *arg_item, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_block_call_remove_configuration_item ( UDisksBlock *proxy, GVariant *arg_item, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_block_call_remove_configuration_item_finish ( UDisksBlock *proxy, GAsyncResult *res, GError **error); gboolean udisks_block_call_remove_configuration_item_sync ( UDisksBlock *proxy, GVariant *arg_item, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_block_call_update_configuration_item ( UDisksBlock *proxy, GVariant *arg_old_item, GVariant *arg_new_item, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_block_call_update_configuration_item_finish ( UDisksBlock *proxy, GAsyncResult *res, GError **error); gboolean udisks_block_call_update_configuration_item_sync ( UDisksBlock *proxy, GVariant *arg_old_item, GVariant *arg_new_item, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_block_call_get_secret_configuration ( UDisksBlock *proxy, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_block_call_get_secret_configuration_finish ( UDisksBlock *proxy, GVariant ** out_configuration, GAsyncResult *res, GError **error); gboolean udisks_block_call_get_secret_configuration_sync ( UDisksBlock *proxy, GVariant *arg_options, GVariant ** out_configuration, GCancellable *cancellable, GError **error); void udisks_block_call_format ( UDisksBlock *proxy, const gchar *arg_type, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_block_call_format_finish ( UDisksBlock *proxy, GAsyncResult *res, GError **error); gboolean udisks_block_call_format_sync ( UDisksBlock *proxy, const gchar *arg_type, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_block_call_open_for_backup ( UDisksBlock *proxy, GVariant *arg_options, GUnixFDList *fd_list, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_block_call_open_for_backup_finish ( UDisksBlock *proxy, GVariant ** out_fd, GUnixFDList **out_fd_list, GAsyncResult *res, GError **error); gboolean udisks_block_call_open_for_backup_sync ( UDisksBlock *proxy, GVariant *arg_options, GUnixFDList *fd_list, GVariant ** out_fd, GUnixFDList **out_fd_list, GCancellable *cancellable, GError **error); void udisks_block_call_open_for_restore ( UDisksBlock *proxy, GVariant *arg_options, GUnixFDList *fd_list, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_block_call_open_for_restore_finish ( UDisksBlock *proxy, GVariant ** out_fd, GUnixFDList **out_fd_list, GAsyncResult *res, GError **error); gboolean udisks_block_call_open_for_restore_sync ( UDisksBlock *proxy, GVariant *arg_options, GUnixFDList *fd_list, GVariant ** out_fd, GUnixFDList **out_fd_list, GCancellable *cancellable, GError **error); void udisks_block_call_open_for_benchmark ( UDisksBlock *proxy, GVariant *arg_options, GUnixFDList *fd_list, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_block_call_open_for_benchmark_finish ( UDisksBlock *proxy, GVariant ** out_fd, GUnixFDList **out_fd_list, GAsyncResult *res, GError **error); gboolean udisks_block_call_open_for_benchmark_sync ( UDisksBlock *proxy, GVariant *arg_options, GUnixFDList *fd_list, GVariant ** out_fd, GUnixFDList **out_fd_list, GCancellable *cancellable, GError **error); void udisks_block_call_open_device ( UDisksBlock *proxy, const gchar *arg_mode, GVariant *arg_options, GUnixFDList *fd_list, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_block_call_open_device_finish ( UDisksBlock *proxy, GVariant ** out_fd, GUnixFDList **out_fd_list, GAsyncResult *res, GError **error); gboolean udisks_block_call_open_device_sync ( UDisksBlock *proxy, const gchar *arg_mode, GVariant *arg_options, GUnixFDList *fd_list, GVariant ** out_fd, GUnixFDList **out_fd_list, GCancellable *cancellable, GError **error); void udisks_block_call_rescan ( UDisksBlock *proxy, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_block_call_rescan_finish ( UDisksBlock *proxy, GAsyncResult *res, GError **error); gboolean udisks_block_call_rescan_sync ( UDisksBlock *proxy, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_block_call_restore_encrypted_header ( UDisksBlock *proxy, const gchar *arg_backup_file, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_block_call_restore_encrypted_header_finish ( UDisksBlock *proxy, GAsyncResult *res, GError **error); gboolean udisks_block_call_restore_encrypted_header_sync ( UDisksBlock *proxy, const gchar *arg_backup_file, GVariant *arg_options, GCancellable *cancellable, GError **error); /* D-Bus property accessors: */ const gchar *udisks_block_get_device (UDisksBlock *object); gchar *udisks_block_dup_device (UDisksBlock *object); void udisks_block_set_device (UDisksBlock *object, const gchar *value); const gchar *udisks_block_get_preferred_device (UDisksBlock *object); gchar *udisks_block_dup_preferred_device (UDisksBlock *object); void udisks_block_set_preferred_device (UDisksBlock *object, const gchar *value); const gchar *const *udisks_block_get_symlinks (UDisksBlock *object); gchar **udisks_block_dup_symlinks (UDisksBlock *object); void udisks_block_set_symlinks (UDisksBlock *object, const gchar *const *value); guint64 udisks_block_get_device_number (UDisksBlock *object); void udisks_block_set_device_number (UDisksBlock *object, guint64 value); const gchar *udisks_block_get_id (UDisksBlock *object); gchar *udisks_block_dup_id (UDisksBlock *object); void udisks_block_set_id (UDisksBlock *object, const gchar *value); guint64 udisks_block_get_size (UDisksBlock *object); void udisks_block_set_size (UDisksBlock *object, guint64 value); gboolean udisks_block_get_read_only (UDisksBlock *object); void udisks_block_set_read_only (UDisksBlock *object, gboolean value); const gchar *udisks_block_get_drive (UDisksBlock *object); gchar *udisks_block_dup_drive (UDisksBlock *object); void udisks_block_set_drive (UDisksBlock *object, const gchar *value); const gchar *udisks_block_get_mdraid (UDisksBlock *object); gchar *udisks_block_dup_mdraid (UDisksBlock *object); void udisks_block_set_mdraid (UDisksBlock *object, const gchar *value); const gchar *udisks_block_get_mdraid_member (UDisksBlock *object); gchar *udisks_block_dup_mdraid_member (UDisksBlock *object); void udisks_block_set_mdraid_member (UDisksBlock *object, const gchar *value); const gchar *udisks_block_get_id_usage (UDisksBlock *object); gchar *udisks_block_dup_id_usage (UDisksBlock *object); void udisks_block_set_id_usage (UDisksBlock *object, const gchar *value); const gchar *udisks_block_get_id_type (UDisksBlock *object); gchar *udisks_block_dup_id_type (UDisksBlock *object); void udisks_block_set_id_type (UDisksBlock *object, const gchar *value); const gchar *udisks_block_get_id_version (UDisksBlock *object); gchar *udisks_block_dup_id_version (UDisksBlock *object); void udisks_block_set_id_version (UDisksBlock *object, const gchar *value); const gchar *udisks_block_get_id_label (UDisksBlock *object); gchar *udisks_block_dup_id_label (UDisksBlock *object); void udisks_block_set_id_label (UDisksBlock *object, const gchar *value); const gchar *udisks_block_get_id_uuid (UDisksBlock *object); gchar *udisks_block_dup_id_uuid (UDisksBlock *object); void udisks_block_set_id_uuid (UDisksBlock *object, const gchar *value); GVariant *udisks_block_get_configuration (UDisksBlock *object); GVariant *udisks_block_dup_configuration (UDisksBlock *object); void udisks_block_set_configuration (UDisksBlock *object, GVariant *value); const gchar *udisks_block_get_crypto_backing_device (UDisksBlock *object); gchar *udisks_block_dup_crypto_backing_device (UDisksBlock *object); void udisks_block_set_crypto_backing_device (UDisksBlock *object, const gchar *value); gboolean udisks_block_get_hint_partitionable (UDisksBlock *object); void udisks_block_set_hint_partitionable (UDisksBlock *object, gboolean value); gboolean udisks_block_get_hint_system (UDisksBlock *object); void udisks_block_set_hint_system (UDisksBlock *object, gboolean value); gboolean udisks_block_get_hint_ignore (UDisksBlock *object); void udisks_block_set_hint_ignore (UDisksBlock *object, gboolean value); gboolean udisks_block_get_hint_auto (UDisksBlock *object); void udisks_block_set_hint_auto (UDisksBlock *object, gboolean value); const gchar *udisks_block_get_hint_name (UDisksBlock *object); gchar *udisks_block_dup_hint_name (UDisksBlock *object); void udisks_block_set_hint_name (UDisksBlock *object, const gchar *value); const gchar *udisks_block_get_hint_icon_name (UDisksBlock *object); gchar *udisks_block_dup_hint_icon_name (UDisksBlock *object); void udisks_block_set_hint_icon_name (UDisksBlock *object, const gchar *value); const gchar *udisks_block_get_hint_symbolic_icon_name (UDisksBlock *object); gchar *udisks_block_dup_hint_symbolic_icon_name (UDisksBlock *object); void udisks_block_set_hint_symbolic_icon_name (UDisksBlock *object, const gchar *value); const gchar *const *udisks_block_get_userspace_mount_options (UDisksBlock *object); gchar **udisks_block_dup_userspace_mount_options (UDisksBlock *object); void udisks_block_set_userspace_mount_options (UDisksBlock *object, const gchar *const *value); /* ---- */ #define UDISKS_TYPE_BLOCK_PROXY (udisks_block_proxy_get_type ()) #define UDISKS_BLOCK_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_BLOCK_PROXY, UDisksBlockProxy)) #define UDISKS_BLOCK_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UDISKS_TYPE_BLOCK_PROXY, UDisksBlockProxyClass)) #define UDISKS_BLOCK_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UDISKS_TYPE_BLOCK_PROXY, UDisksBlockProxyClass)) #define UDISKS_IS_BLOCK_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_BLOCK_PROXY)) #define UDISKS_IS_BLOCK_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UDISKS_TYPE_BLOCK_PROXY)) typedef struct _UDisksBlockProxy UDisksBlockProxy; typedef struct _UDisksBlockProxyClass UDisksBlockProxyClass; typedef struct _UDisksBlockProxyPrivate UDisksBlockProxyPrivate; struct _UDisksBlockProxy { /*< private >*/ GDBusProxy parent_instance; UDisksBlockProxyPrivate *priv; }; struct _UDisksBlockProxyClass { GDBusProxyClass parent_class; }; GType udisks_block_proxy_get_type (void); #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksBlockProxy, g_object_unref) #endif void udisks_block_proxy_new ( GDBusConnection *connection, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); UDisksBlock *udisks_block_proxy_new_finish ( GAsyncResult *res, GError **error); UDisksBlock *udisks_block_proxy_new_sync ( GDBusConnection *connection, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GError **error); void udisks_block_proxy_new_for_bus ( GBusType bus_type, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); UDisksBlock *udisks_block_proxy_new_for_bus_finish ( GAsyncResult *res, GError **error); UDisksBlock *udisks_block_proxy_new_for_bus_sync ( GBusType bus_type, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GError **error); /* ---- */ #define UDISKS_TYPE_BLOCK_SKELETON (udisks_block_skeleton_get_type ()) #define UDISKS_BLOCK_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_BLOCK_SKELETON, UDisksBlockSkeleton)) #define UDISKS_BLOCK_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UDISKS_TYPE_BLOCK_SKELETON, UDisksBlockSkeletonClass)) #define UDISKS_BLOCK_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UDISKS_TYPE_BLOCK_SKELETON, UDisksBlockSkeletonClass)) #define UDISKS_IS_BLOCK_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_BLOCK_SKELETON)) #define UDISKS_IS_BLOCK_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UDISKS_TYPE_BLOCK_SKELETON)) typedef struct _UDisksBlockSkeleton UDisksBlockSkeleton; typedef struct _UDisksBlockSkeletonClass UDisksBlockSkeletonClass; typedef struct _UDisksBlockSkeletonPrivate UDisksBlockSkeletonPrivate; struct _UDisksBlockSkeleton { /*< private >*/ GDBusInterfaceSkeleton parent_instance; UDisksBlockSkeletonPrivate *priv; }; struct _UDisksBlockSkeletonClass { GDBusInterfaceSkeletonClass parent_class; }; GType udisks_block_skeleton_get_type (void); #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksBlockSkeleton, g_object_unref) #endif UDisksBlock *udisks_block_skeleton_new (void); /* ------------------------------------------------------------------------ */ /* Declarations for org.freedesktop.UDisks2.PartitionTable */ #define UDISKS_TYPE_PARTITION_TABLE (udisks_partition_table_get_type ()) #define UDISKS_PARTITION_TABLE(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_PARTITION_TABLE, UDisksPartitionTable)) #define UDISKS_IS_PARTITION_TABLE(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_PARTITION_TABLE)) #define UDISKS_PARTITION_TABLE_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), UDISKS_TYPE_PARTITION_TABLE, UDisksPartitionTableIface)) struct _UDisksPartitionTable; typedef struct _UDisksPartitionTable UDisksPartitionTable; typedef struct _UDisksPartitionTableIface UDisksPartitionTableIface; struct _UDisksPartitionTableIface { GTypeInterface parent_iface; gboolean (*handle_create_partition) ( UDisksPartitionTable *object, GDBusMethodInvocation *invocation, guint64 arg_offset, guint64 arg_size, const gchar *arg_type, const gchar *arg_name, GVariant *arg_options); gboolean (*handle_create_partition_and_format) ( UDisksPartitionTable *object, GDBusMethodInvocation *invocation, guint64 arg_offset, guint64 arg_size, const gchar *arg_type, const gchar *arg_name, GVariant *arg_options, const gchar *arg_format_type, GVariant *arg_format_options); const gchar *const * (*get_partitions) (UDisksPartitionTable *object); const gchar * (*get_type_) (UDisksPartitionTable *object); }; #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksPartitionTable, g_object_unref) #endif GType udisks_partition_table_get_type (void); GDBusInterfaceInfo *udisks_partition_table_interface_info (void); guint udisks_partition_table_override_properties (GObjectClass *klass, guint property_id_begin); /* D-Bus method call completion functions: */ void udisks_partition_table_complete_create_partition ( UDisksPartitionTable *object, GDBusMethodInvocation *invocation, const gchar *created_partition); void udisks_partition_table_complete_create_partition_and_format ( UDisksPartitionTable *object, GDBusMethodInvocation *invocation, const gchar *created_partition); /* D-Bus method calls: */ void udisks_partition_table_call_create_partition ( UDisksPartitionTable *proxy, guint64 arg_offset, guint64 arg_size, const gchar *arg_type, const gchar *arg_name, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_partition_table_call_create_partition_finish ( UDisksPartitionTable *proxy, gchar ** out_created_partition, GAsyncResult *res, GError **error); gboolean udisks_partition_table_call_create_partition_sync ( UDisksPartitionTable *proxy, guint64 arg_offset, guint64 arg_size, const gchar *arg_type, const gchar *arg_name, GVariant *arg_options, gchar ** out_created_partition, GCancellable *cancellable, GError **error); void udisks_partition_table_call_create_partition_and_format ( UDisksPartitionTable *proxy, guint64 arg_offset, guint64 arg_size, const gchar *arg_type, const gchar *arg_name, GVariant *arg_options, const gchar *arg_format_type, GVariant *arg_format_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_partition_table_call_create_partition_and_format_finish ( UDisksPartitionTable *proxy, gchar ** out_created_partition, GAsyncResult *res, GError **error); gboolean udisks_partition_table_call_create_partition_and_format_sync ( UDisksPartitionTable *proxy, guint64 arg_offset, guint64 arg_size, const gchar *arg_type, const gchar *arg_name, GVariant *arg_options, const gchar *arg_format_type, GVariant *arg_format_options, gchar ** out_created_partition, GCancellable *cancellable, GError **error); /* D-Bus property accessors: */ const gchar *const *udisks_partition_table_get_partitions (UDisksPartitionTable *object); gchar **udisks_partition_table_dup_partitions (UDisksPartitionTable *object); void udisks_partition_table_set_partitions (UDisksPartitionTable *object, const gchar *const *value); const gchar *udisks_partition_table_get_type_ (UDisksPartitionTable *object); gchar *udisks_partition_table_dup_type_ (UDisksPartitionTable *object); void udisks_partition_table_set_type_ (UDisksPartitionTable *object, const gchar *value); /* ---- */ #define UDISKS_TYPE_PARTITION_TABLE_PROXY (udisks_partition_table_proxy_get_type ()) #define UDISKS_PARTITION_TABLE_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_PARTITION_TABLE_PROXY, UDisksPartitionTableProxy)) #define UDISKS_PARTITION_TABLE_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UDISKS_TYPE_PARTITION_TABLE_PROXY, UDisksPartitionTableProxyClass)) #define UDISKS_PARTITION_TABLE_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UDISKS_TYPE_PARTITION_TABLE_PROXY, UDisksPartitionTableProxyClass)) #define UDISKS_IS_PARTITION_TABLE_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_PARTITION_TABLE_PROXY)) #define UDISKS_IS_PARTITION_TABLE_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UDISKS_TYPE_PARTITION_TABLE_PROXY)) typedef struct _UDisksPartitionTableProxy UDisksPartitionTableProxy; typedef struct _UDisksPartitionTableProxyClass UDisksPartitionTableProxyClass; typedef struct _UDisksPartitionTableProxyPrivate UDisksPartitionTableProxyPrivate; struct _UDisksPartitionTableProxy { /*< private >*/ GDBusProxy parent_instance; UDisksPartitionTableProxyPrivate *priv; }; struct _UDisksPartitionTableProxyClass { GDBusProxyClass parent_class; }; GType udisks_partition_table_proxy_get_type (void); #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksPartitionTableProxy, g_object_unref) #endif void udisks_partition_table_proxy_new ( GDBusConnection *connection, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); UDisksPartitionTable *udisks_partition_table_proxy_new_finish ( GAsyncResult *res, GError **error); UDisksPartitionTable *udisks_partition_table_proxy_new_sync ( GDBusConnection *connection, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GError **error); void udisks_partition_table_proxy_new_for_bus ( GBusType bus_type, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); UDisksPartitionTable *udisks_partition_table_proxy_new_for_bus_finish ( GAsyncResult *res, GError **error); UDisksPartitionTable *udisks_partition_table_proxy_new_for_bus_sync ( GBusType bus_type, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GError **error); /* ---- */ #define UDISKS_TYPE_PARTITION_TABLE_SKELETON (udisks_partition_table_skeleton_get_type ()) #define UDISKS_PARTITION_TABLE_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_PARTITION_TABLE_SKELETON, UDisksPartitionTableSkeleton)) #define UDISKS_PARTITION_TABLE_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UDISKS_TYPE_PARTITION_TABLE_SKELETON, UDisksPartitionTableSkeletonClass)) #define UDISKS_PARTITION_TABLE_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UDISKS_TYPE_PARTITION_TABLE_SKELETON, UDisksPartitionTableSkeletonClass)) #define UDISKS_IS_PARTITION_TABLE_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_PARTITION_TABLE_SKELETON)) #define UDISKS_IS_PARTITION_TABLE_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UDISKS_TYPE_PARTITION_TABLE_SKELETON)) typedef struct _UDisksPartitionTableSkeleton UDisksPartitionTableSkeleton; typedef struct _UDisksPartitionTableSkeletonClass UDisksPartitionTableSkeletonClass; typedef struct _UDisksPartitionTableSkeletonPrivate UDisksPartitionTableSkeletonPrivate; struct _UDisksPartitionTableSkeleton { /*< private >*/ GDBusInterfaceSkeleton parent_instance; UDisksPartitionTableSkeletonPrivate *priv; }; struct _UDisksPartitionTableSkeletonClass { GDBusInterfaceSkeletonClass parent_class; }; GType udisks_partition_table_skeleton_get_type (void); #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksPartitionTableSkeleton, g_object_unref) #endif UDisksPartitionTable *udisks_partition_table_skeleton_new (void); /* ------------------------------------------------------------------------ */ /* Declarations for org.freedesktop.UDisks2.Partition */ #define UDISKS_TYPE_PARTITION (udisks_partition_get_type ()) #define UDISKS_PARTITION(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_PARTITION, UDisksPartition)) #define UDISKS_IS_PARTITION(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_PARTITION)) #define UDISKS_PARTITION_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), UDISKS_TYPE_PARTITION, UDisksPartitionIface)) struct _UDisksPartition; typedef struct _UDisksPartition UDisksPartition; typedef struct _UDisksPartitionIface UDisksPartitionIface; struct _UDisksPartitionIface { GTypeInterface parent_iface; gboolean (*handle_delete) ( UDisksPartition *object, GDBusMethodInvocation *invocation, GVariant *arg_options); gboolean (*handle_resize) ( UDisksPartition *object, GDBusMethodInvocation *invocation, guint64 arg_size, GVariant *arg_options); gboolean (*handle_set_flags) ( UDisksPartition *object, GDBusMethodInvocation *invocation, guint64 arg_flags, GVariant *arg_options); gboolean (*handle_set_name) ( UDisksPartition *object, GDBusMethodInvocation *invocation, const gchar *arg_name, GVariant *arg_options); gboolean (*handle_set_type) ( UDisksPartition *object, GDBusMethodInvocation *invocation, const gchar *arg_type, GVariant *arg_options); guint64 (*get_flags) (UDisksPartition *object); gboolean (*get_is_contained) (UDisksPartition *object); gboolean (*get_is_container) (UDisksPartition *object); const gchar * (*get_name) (UDisksPartition *object); guint (*get_number) (UDisksPartition *object); guint64 (*get_offset) (UDisksPartition *object); guint64 (*get_size) (UDisksPartition *object); const gchar * (*get_table) (UDisksPartition *object); const gchar * (*get_type_) (UDisksPartition *object); const gchar * (*get_uuid) (UDisksPartition *object); gboolean (*handle_set_uuid) ( UDisksPartition *object, GDBusMethodInvocation *invocation, const gchar *arg_uuid, GVariant *arg_options); }; #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksPartition, g_object_unref) #endif GType udisks_partition_get_type (void); GDBusInterfaceInfo *udisks_partition_interface_info (void); guint udisks_partition_override_properties (GObjectClass *klass, guint property_id_begin); /* D-Bus method call completion functions: */ void udisks_partition_complete_set_type ( UDisksPartition *object, GDBusMethodInvocation *invocation); void udisks_partition_complete_set_name ( UDisksPartition *object, GDBusMethodInvocation *invocation); void udisks_partition_complete_set_uuid ( UDisksPartition *object, GDBusMethodInvocation *invocation); void udisks_partition_complete_set_flags ( UDisksPartition *object, GDBusMethodInvocation *invocation); void udisks_partition_complete_resize ( UDisksPartition *object, GDBusMethodInvocation *invocation); void udisks_partition_complete_delete ( UDisksPartition *object, GDBusMethodInvocation *invocation); /* D-Bus method calls: */ void udisks_partition_call_set_type ( UDisksPartition *proxy, const gchar *arg_type, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_partition_call_set_type_finish ( UDisksPartition *proxy, GAsyncResult *res, GError **error); gboolean udisks_partition_call_set_type_sync ( UDisksPartition *proxy, const gchar *arg_type, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_partition_call_set_name ( UDisksPartition *proxy, const gchar *arg_name, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_partition_call_set_name_finish ( UDisksPartition *proxy, GAsyncResult *res, GError **error); gboolean udisks_partition_call_set_name_sync ( UDisksPartition *proxy, const gchar *arg_name, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_partition_call_set_uuid ( UDisksPartition *proxy, const gchar *arg_uuid, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_partition_call_set_uuid_finish ( UDisksPartition *proxy, GAsyncResult *res, GError **error); gboolean udisks_partition_call_set_uuid_sync ( UDisksPartition *proxy, const gchar *arg_uuid, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_partition_call_set_flags ( UDisksPartition *proxy, guint64 arg_flags, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_partition_call_set_flags_finish ( UDisksPartition *proxy, GAsyncResult *res, GError **error); gboolean udisks_partition_call_set_flags_sync ( UDisksPartition *proxy, guint64 arg_flags, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_partition_call_resize ( UDisksPartition *proxy, guint64 arg_size, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_partition_call_resize_finish ( UDisksPartition *proxy, GAsyncResult *res, GError **error); gboolean udisks_partition_call_resize_sync ( UDisksPartition *proxy, guint64 arg_size, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_partition_call_delete ( UDisksPartition *proxy, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_partition_call_delete_finish ( UDisksPartition *proxy, GAsyncResult *res, GError **error); gboolean udisks_partition_call_delete_sync ( UDisksPartition *proxy, GVariant *arg_options, GCancellable *cancellable, GError **error); /* D-Bus property accessors: */ guint udisks_partition_get_number (UDisksPartition *object); void udisks_partition_set_number (UDisksPartition *object, guint value); const gchar *udisks_partition_get_type_ (UDisksPartition *object); gchar *udisks_partition_dup_type_ (UDisksPartition *object); void udisks_partition_set_type_ (UDisksPartition *object, const gchar *value); guint64 udisks_partition_get_flags (UDisksPartition *object); void udisks_partition_set_flags (UDisksPartition *object, guint64 value); guint64 udisks_partition_get_offset (UDisksPartition *object); void udisks_partition_set_offset (UDisksPartition *object, guint64 value); guint64 udisks_partition_get_size (UDisksPartition *object); void udisks_partition_set_size (UDisksPartition *object, guint64 value); const gchar *udisks_partition_get_name (UDisksPartition *object); gchar *udisks_partition_dup_name (UDisksPartition *object); void udisks_partition_set_name (UDisksPartition *object, const gchar *value); const gchar *udisks_partition_get_uuid (UDisksPartition *object); gchar *udisks_partition_dup_uuid (UDisksPartition *object); void udisks_partition_set_uuid (UDisksPartition *object, const gchar *value); const gchar *udisks_partition_get_table (UDisksPartition *object); gchar *udisks_partition_dup_table (UDisksPartition *object); void udisks_partition_set_table (UDisksPartition *object, const gchar *value); gboolean udisks_partition_get_is_container (UDisksPartition *object); void udisks_partition_set_is_container (UDisksPartition *object, gboolean value); gboolean udisks_partition_get_is_contained (UDisksPartition *object); void udisks_partition_set_is_contained (UDisksPartition *object, gboolean value); /* ---- */ #define UDISKS_TYPE_PARTITION_PROXY (udisks_partition_proxy_get_type ()) #define UDISKS_PARTITION_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_PARTITION_PROXY, UDisksPartitionProxy)) #define UDISKS_PARTITION_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UDISKS_TYPE_PARTITION_PROXY, UDisksPartitionProxyClass)) #define UDISKS_PARTITION_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UDISKS_TYPE_PARTITION_PROXY, UDisksPartitionProxyClass)) #define UDISKS_IS_PARTITION_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_PARTITION_PROXY)) #define UDISKS_IS_PARTITION_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UDISKS_TYPE_PARTITION_PROXY)) typedef struct _UDisksPartitionProxy UDisksPartitionProxy; typedef struct _UDisksPartitionProxyClass UDisksPartitionProxyClass; typedef struct _UDisksPartitionProxyPrivate UDisksPartitionProxyPrivate; struct _UDisksPartitionProxy { /*< private >*/ GDBusProxy parent_instance; UDisksPartitionProxyPrivate *priv; }; struct _UDisksPartitionProxyClass { GDBusProxyClass parent_class; }; GType udisks_partition_proxy_get_type (void); #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksPartitionProxy, g_object_unref) #endif void udisks_partition_proxy_new ( GDBusConnection *connection, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); UDisksPartition *udisks_partition_proxy_new_finish ( GAsyncResult *res, GError **error); UDisksPartition *udisks_partition_proxy_new_sync ( GDBusConnection *connection, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GError **error); void udisks_partition_proxy_new_for_bus ( GBusType bus_type, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); UDisksPartition *udisks_partition_proxy_new_for_bus_finish ( GAsyncResult *res, GError **error); UDisksPartition *udisks_partition_proxy_new_for_bus_sync ( GBusType bus_type, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GError **error); /* ---- */ #define UDISKS_TYPE_PARTITION_SKELETON (udisks_partition_skeleton_get_type ()) #define UDISKS_PARTITION_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_PARTITION_SKELETON, UDisksPartitionSkeleton)) #define UDISKS_PARTITION_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UDISKS_TYPE_PARTITION_SKELETON, UDisksPartitionSkeletonClass)) #define UDISKS_PARTITION_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UDISKS_TYPE_PARTITION_SKELETON, UDisksPartitionSkeletonClass)) #define UDISKS_IS_PARTITION_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_PARTITION_SKELETON)) #define UDISKS_IS_PARTITION_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UDISKS_TYPE_PARTITION_SKELETON)) typedef struct _UDisksPartitionSkeleton UDisksPartitionSkeleton; typedef struct _UDisksPartitionSkeletonClass UDisksPartitionSkeletonClass; typedef struct _UDisksPartitionSkeletonPrivate UDisksPartitionSkeletonPrivate; struct _UDisksPartitionSkeleton { /*< private >*/ GDBusInterfaceSkeleton parent_instance; UDisksPartitionSkeletonPrivate *priv; }; struct _UDisksPartitionSkeletonClass { GDBusInterfaceSkeletonClass parent_class; }; GType udisks_partition_skeleton_get_type (void); #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksPartitionSkeleton, g_object_unref) #endif UDisksPartition *udisks_partition_skeleton_new (void); /* ------------------------------------------------------------------------ */ /* Declarations for org.freedesktop.UDisks2.Filesystem */ #define UDISKS_TYPE_FILESYSTEM (udisks_filesystem_get_type ()) #define UDISKS_FILESYSTEM(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_FILESYSTEM, UDisksFilesystem)) #define UDISKS_IS_FILESYSTEM(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_FILESYSTEM)) #define UDISKS_FILESYSTEM_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), UDISKS_TYPE_FILESYSTEM, UDisksFilesystemIface)) struct _UDisksFilesystem; typedef struct _UDisksFilesystem UDisksFilesystem; typedef struct _UDisksFilesystemIface UDisksFilesystemIface; struct _UDisksFilesystemIface { GTypeInterface parent_iface; gboolean (*handle_check) ( UDisksFilesystem *object, GDBusMethodInvocation *invocation, GVariant *arg_options); gboolean (*handle_mount) ( UDisksFilesystem *object, GDBusMethodInvocation *invocation, GVariant *arg_options); gboolean (*handle_repair) ( UDisksFilesystem *object, GDBusMethodInvocation *invocation, GVariant *arg_options); gboolean (*handle_set_label) ( UDisksFilesystem *object, GDBusMethodInvocation *invocation, const gchar *arg_label, GVariant *arg_options); gboolean (*handle_take_ownership) ( UDisksFilesystem *object, GDBusMethodInvocation *invocation, GVariant *arg_options); gboolean (*handle_unmount) ( UDisksFilesystem *object, GDBusMethodInvocation *invocation, GVariant *arg_options); const gchar *const * (*get_mount_points) (UDisksFilesystem *object); guint64 (*get_size) (UDisksFilesystem *object); gboolean (*handle_resize) ( UDisksFilesystem *object, GDBusMethodInvocation *invocation, guint64 arg_size, GVariant *arg_options); gboolean (*handle_set_uuid) ( UDisksFilesystem *object, GDBusMethodInvocation *invocation, const gchar *arg_uuid, GVariant *arg_options); }; #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksFilesystem, g_object_unref) #endif GType udisks_filesystem_get_type (void); GDBusInterfaceInfo *udisks_filesystem_interface_info (void); guint udisks_filesystem_override_properties (GObjectClass *klass, guint property_id_begin); /* D-Bus method call completion functions: */ void udisks_filesystem_complete_set_label ( UDisksFilesystem *object, GDBusMethodInvocation *invocation); void udisks_filesystem_complete_set_uuid ( UDisksFilesystem *object, GDBusMethodInvocation *invocation); void udisks_filesystem_complete_mount ( UDisksFilesystem *object, GDBusMethodInvocation *invocation, const gchar *mount_path); void udisks_filesystem_complete_unmount ( UDisksFilesystem *object, GDBusMethodInvocation *invocation); void udisks_filesystem_complete_resize ( UDisksFilesystem *object, GDBusMethodInvocation *invocation); void udisks_filesystem_complete_check ( UDisksFilesystem *object, GDBusMethodInvocation *invocation, gboolean consistent); void udisks_filesystem_complete_repair ( UDisksFilesystem *object, GDBusMethodInvocation *invocation, gboolean repaired); void udisks_filesystem_complete_take_ownership ( UDisksFilesystem *object, GDBusMethodInvocation *invocation); /* D-Bus method calls: */ void udisks_filesystem_call_set_label ( UDisksFilesystem *proxy, const gchar *arg_label, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_filesystem_call_set_label_finish ( UDisksFilesystem *proxy, GAsyncResult *res, GError **error); gboolean udisks_filesystem_call_set_label_sync ( UDisksFilesystem *proxy, const gchar *arg_label, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_filesystem_call_set_uuid ( UDisksFilesystem *proxy, const gchar *arg_uuid, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_filesystem_call_set_uuid_finish ( UDisksFilesystem *proxy, GAsyncResult *res, GError **error); gboolean udisks_filesystem_call_set_uuid_sync ( UDisksFilesystem *proxy, const gchar *arg_uuid, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_filesystem_call_mount ( UDisksFilesystem *proxy, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_filesystem_call_mount_finish ( UDisksFilesystem *proxy, gchar ** out_mount_path, GAsyncResult *res, GError **error); gboolean udisks_filesystem_call_mount_sync ( UDisksFilesystem *proxy, GVariant *arg_options, gchar ** out_mount_path, GCancellable *cancellable, GError **error); void udisks_filesystem_call_unmount ( UDisksFilesystem *proxy, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_filesystem_call_unmount_finish ( UDisksFilesystem *proxy, GAsyncResult *res, GError **error); gboolean udisks_filesystem_call_unmount_sync ( UDisksFilesystem *proxy, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_filesystem_call_resize ( UDisksFilesystem *proxy, guint64 arg_size, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_filesystem_call_resize_finish ( UDisksFilesystem *proxy, GAsyncResult *res, GError **error); gboolean udisks_filesystem_call_resize_sync ( UDisksFilesystem *proxy, guint64 arg_size, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_filesystem_call_check ( UDisksFilesystem *proxy, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_filesystem_call_check_finish ( UDisksFilesystem *proxy, gboolean* out_consistent, GAsyncResult *res, GError **error); gboolean udisks_filesystem_call_check_sync ( UDisksFilesystem *proxy, GVariant *arg_options, gboolean* out_consistent, GCancellable *cancellable, GError **error); void udisks_filesystem_call_repair ( UDisksFilesystem *proxy, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_filesystem_call_repair_finish ( UDisksFilesystem *proxy, gboolean* out_repaired, GAsyncResult *res, GError **error); gboolean udisks_filesystem_call_repair_sync ( UDisksFilesystem *proxy, GVariant *arg_options, gboolean* out_repaired, GCancellable *cancellable, GError **error); void udisks_filesystem_call_take_ownership ( UDisksFilesystem *proxy, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_filesystem_call_take_ownership_finish ( UDisksFilesystem *proxy, GAsyncResult *res, GError **error); gboolean udisks_filesystem_call_take_ownership_sync ( UDisksFilesystem *proxy, GVariant *arg_options, GCancellable *cancellable, GError **error); /* D-Bus property accessors: */ const gchar *const *udisks_filesystem_get_mount_points (UDisksFilesystem *object); gchar **udisks_filesystem_dup_mount_points (UDisksFilesystem *object); void udisks_filesystem_set_mount_points (UDisksFilesystem *object, const gchar *const *value); guint64 udisks_filesystem_get_size (UDisksFilesystem *object); void udisks_filesystem_set_size (UDisksFilesystem *object, guint64 value); /* ---- */ #define UDISKS_TYPE_FILESYSTEM_PROXY (udisks_filesystem_proxy_get_type ()) #define UDISKS_FILESYSTEM_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_FILESYSTEM_PROXY, UDisksFilesystemProxy)) #define UDISKS_FILESYSTEM_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UDISKS_TYPE_FILESYSTEM_PROXY, UDisksFilesystemProxyClass)) #define UDISKS_FILESYSTEM_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UDISKS_TYPE_FILESYSTEM_PROXY, UDisksFilesystemProxyClass)) #define UDISKS_IS_FILESYSTEM_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_FILESYSTEM_PROXY)) #define UDISKS_IS_FILESYSTEM_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UDISKS_TYPE_FILESYSTEM_PROXY)) typedef struct _UDisksFilesystemProxy UDisksFilesystemProxy; typedef struct _UDisksFilesystemProxyClass UDisksFilesystemProxyClass; typedef struct _UDisksFilesystemProxyPrivate UDisksFilesystemProxyPrivate; struct _UDisksFilesystemProxy { /*< private >*/ GDBusProxy parent_instance; UDisksFilesystemProxyPrivate *priv; }; struct _UDisksFilesystemProxyClass { GDBusProxyClass parent_class; }; GType udisks_filesystem_proxy_get_type (void); #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksFilesystemProxy, g_object_unref) #endif void udisks_filesystem_proxy_new ( GDBusConnection *connection, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); UDisksFilesystem *udisks_filesystem_proxy_new_finish ( GAsyncResult *res, GError **error); UDisksFilesystem *udisks_filesystem_proxy_new_sync ( GDBusConnection *connection, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GError **error); void udisks_filesystem_proxy_new_for_bus ( GBusType bus_type, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); UDisksFilesystem *udisks_filesystem_proxy_new_for_bus_finish ( GAsyncResult *res, GError **error); UDisksFilesystem *udisks_filesystem_proxy_new_for_bus_sync ( GBusType bus_type, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GError **error); /* ---- */ #define UDISKS_TYPE_FILESYSTEM_SKELETON (udisks_filesystem_skeleton_get_type ()) #define UDISKS_FILESYSTEM_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_FILESYSTEM_SKELETON, UDisksFilesystemSkeleton)) #define UDISKS_FILESYSTEM_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UDISKS_TYPE_FILESYSTEM_SKELETON, UDisksFilesystemSkeletonClass)) #define UDISKS_FILESYSTEM_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UDISKS_TYPE_FILESYSTEM_SKELETON, UDisksFilesystemSkeletonClass)) #define UDISKS_IS_FILESYSTEM_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_FILESYSTEM_SKELETON)) #define UDISKS_IS_FILESYSTEM_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UDISKS_TYPE_FILESYSTEM_SKELETON)) typedef struct _UDisksFilesystemSkeleton UDisksFilesystemSkeleton; typedef struct _UDisksFilesystemSkeletonClass UDisksFilesystemSkeletonClass; typedef struct _UDisksFilesystemSkeletonPrivate UDisksFilesystemSkeletonPrivate; struct _UDisksFilesystemSkeleton { /*< private >*/ GDBusInterfaceSkeleton parent_instance; UDisksFilesystemSkeletonPrivate *priv; }; struct _UDisksFilesystemSkeletonClass { GDBusInterfaceSkeletonClass parent_class; }; GType udisks_filesystem_skeleton_get_type (void); #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksFilesystemSkeleton, g_object_unref) #endif UDisksFilesystem *udisks_filesystem_skeleton_new (void); /* ------------------------------------------------------------------------ */ /* Declarations for org.freedesktop.UDisks2.Swapspace */ #define UDISKS_TYPE_SWAPSPACE (udisks_swapspace_get_type ()) #define UDISKS_SWAPSPACE(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_SWAPSPACE, UDisksSwapspace)) #define UDISKS_IS_SWAPSPACE(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_SWAPSPACE)) #define UDISKS_SWAPSPACE_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), UDISKS_TYPE_SWAPSPACE, UDisksSwapspaceIface)) struct _UDisksSwapspace; typedef struct _UDisksSwapspace UDisksSwapspace; typedef struct _UDisksSwapspaceIface UDisksSwapspaceIface; struct _UDisksSwapspaceIface { GTypeInterface parent_iface; gboolean (*handle_set_label) ( UDisksSwapspace *object, GDBusMethodInvocation *invocation, const gchar *arg_label, GVariant *arg_options); gboolean (*handle_start) ( UDisksSwapspace *object, GDBusMethodInvocation *invocation, GVariant *arg_options); gboolean (*handle_stop) ( UDisksSwapspace *object, GDBusMethodInvocation *invocation, GVariant *arg_options); gboolean (*get_active) (UDisksSwapspace *object); gboolean (*handle_set_uuid) ( UDisksSwapspace *object, GDBusMethodInvocation *invocation, const gchar *arg_uuid, GVariant *arg_options); }; #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksSwapspace, g_object_unref) #endif GType udisks_swapspace_get_type (void); GDBusInterfaceInfo *udisks_swapspace_interface_info (void); guint udisks_swapspace_override_properties (GObjectClass *klass, guint property_id_begin); /* D-Bus method call completion functions: */ void udisks_swapspace_complete_start ( UDisksSwapspace *object, GDBusMethodInvocation *invocation); void udisks_swapspace_complete_stop ( UDisksSwapspace *object, GDBusMethodInvocation *invocation); void udisks_swapspace_complete_set_label ( UDisksSwapspace *object, GDBusMethodInvocation *invocation); void udisks_swapspace_complete_set_uuid ( UDisksSwapspace *object, GDBusMethodInvocation *invocation); /* D-Bus method calls: */ void udisks_swapspace_call_start ( UDisksSwapspace *proxy, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_swapspace_call_start_finish ( UDisksSwapspace *proxy, GAsyncResult *res, GError **error); gboolean udisks_swapspace_call_start_sync ( UDisksSwapspace *proxy, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_swapspace_call_stop ( UDisksSwapspace *proxy, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_swapspace_call_stop_finish ( UDisksSwapspace *proxy, GAsyncResult *res, GError **error); gboolean udisks_swapspace_call_stop_sync ( UDisksSwapspace *proxy, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_swapspace_call_set_label ( UDisksSwapspace *proxy, const gchar *arg_label, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_swapspace_call_set_label_finish ( UDisksSwapspace *proxy, GAsyncResult *res, GError **error); gboolean udisks_swapspace_call_set_label_sync ( UDisksSwapspace *proxy, const gchar *arg_label, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_swapspace_call_set_uuid ( UDisksSwapspace *proxy, const gchar *arg_uuid, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_swapspace_call_set_uuid_finish ( UDisksSwapspace *proxy, GAsyncResult *res, GError **error); gboolean udisks_swapspace_call_set_uuid_sync ( UDisksSwapspace *proxy, const gchar *arg_uuid, GVariant *arg_options, GCancellable *cancellable, GError **error); /* D-Bus property accessors: */ gboolean udisks_swapspace_get_active (UDisksSwapspace *object); void udisks_swapspace_set_active (UDisksSwapspace *object, gboolean value); /* ---- */ #define UDISKS_TYPE_SWAPSPACE_PROXY (udisks_swapspace_proxy_get_type ()) #define UDISKS_SWAPSPACE_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_SWAPSPACE_PROXY, UDisksSwapspaceProxy)) #define UDISKS_SWAPSPACE_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UDISKS_TYPE_SWAPSPACE_PROXY, UDisksSwapspaceProxyClass)) #define UDISKS_SWAPSPACE_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UDISKS_TYPE_SWAPSPACE_PROXY, UDisksSwapspaceProxyClass)) #define UDISKS_IS_SWAPSPACE_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_SWAPSPACE_PROXY)) #define UDISKS_IS_SWAPSPACE_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UDISKS_TYPE_SWAPSPACE_PROXY)) typedef struct _UDisksSwapspaceProxy UDisksSwapspaceProxy; typedef struct _UDisksSwapspaceProxyClass UDisksSwapspaceProxyClass; typedef struct _UDisksSwapspaceProxyPrivate UDisksSwapspaceProxyPrivate; struct _UDisksSwapspaceProxy { /*< private >*/ GDBusProxy parent_instance; UDisksSwapspaceProxyPrivate *priv; }; struct _UDisksSwapspaceProxyClass { GDBusProxyClass parent_class; }; GType udisks_swapspace_proxy_get_type (void); #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksSwapspaceProxy, g_object_unref) #endif void udisks_swapspace_proxy_new ( GDBusConnection *connection, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); UDisksSwapspace *udisks_swapspace_proxy_new_finish ( GAsyncResult *res, GError **error); UDisksSwapspace *udisks_swapspace_proxy_new_sync ( GDBusConnection *connection, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GError **error); void udisks_swapspace_proxy_new_for_bus ( GBusType bus_type, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); UDisksSwapspace *udisks_swapspace_proxy_new_for_bus_finish ( GAsyncResult *res, GError **error); UDisksSwapspace *udisks_swapspace_proxy_new_for_bus_sync ( GBusType bus_type, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GError **error); /* ---- */ #define UDISKS_TYPE_SWAPSPACE_SKELETON (udisks_swapspace_skeleton_get_type ()) #define UDISKS_SWAPSPACE_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_SWAPSPACE_SKELETON, UDisksSwapspaceSkeleton)) #define UDISKS_SWAPSPACE_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UDISKS_TYPE_SWAPSPACE_SKELETON, UDisksSwapspaceSkeletonClass)) #define UDISKS_SWAPSPACE_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UDISKS_TYPE_SWAPSPACE_SKELETON, UDisksSwapspaceSkeletonClass)) #define UDISKS_IS_SWAPSPACE_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_SWAPSPACE_SKELETON)) #define UDISKS_IS_SWAPSPACE_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UDISKS_TYPE_SWAPSPACE_SKELETON)) typedef struct _UDisksSwapspaceSkeleton UDisksSwapspaceSkeleton; typedef struct _UDisksSwapspaceSkeletonClass UDisksSwapspaceSkeletonClass; typedef struct _UDisksSwapspaceSkeletonPrivate UDisksSwapspaceSkeletonPrivate; struct _UDisksSwapspaceSkeleton { /*< private >*/ GDBusInterfaceSkeleton parent_instance; UDisksSwapspaceSkeletonPrivate *priv; }; struct _UDisksSwapspaceSkeletonClass { GDBusInterfaceSkeletonClass parent_class; }; GType udisks_swapspace_skeleton_get_type (void); #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksSwapspaceSkeleton, g_object_unref) #endif UDisksSwapspace *udisks_swapspace_skeleton_new (void); /* ------------------------------------------------------------------------ */ /* Declarations for org.freedesktop.UDisks2.Encrypted */ #define UDISKS_TYPE_ENCRYPTED (udisks_encrypted_get_type ()) #define UDISKS_ENCRYPTED(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_ENCRYPTED, UDisksEncrypted)) #define UDISKS_IS_ENCRYPTED(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_ENCRYPTED)) #define UDISKS_ENCRYPTED_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), UDISKS_TYPE_ENCRYPTED, UDisksEncryptedIface)) struct _UDisksEncrypted; typedef struct _UDisksEncrypted UDisksEncrypted; typedef struct _UDisksEncryptedIface UDisksEncryptedIface; struct _UDisksEncryptedIface { GTypeInterface parent_iface; gboolean (*handle_change_passphrase) ( UDisksEncrypted *object, GDBusMethodInvocation *invocation, const gchar *arg_passphrase, const gchar *arg_new_passphrase, GVariant *arg_options); gboolean (*handle_lock) ( UDisksEncrypted *object, GDBusMethodInvocation *invocation, GVariant *arg_options); gboolean (*handle_unlock) ( UDisksEncrypted *object, GDBusMethodInvocation *invocation, const gchar *arg_passphrase, GVariant *arg_options); GVariant * (*get_child_configuration) (UDisksEncrypted *object); const gchar * (*get_cleartext_device) (UDisksEncrypted *object); const gchar * (*get_hint_encryption_type) (UDisksEncrypted *object); guint64 (*get_metadata_size) (UDisksEncrypted *object); gboolean (*handle_resize) ( UDisksEncrypted *object, GDBusMethodInvocation *invocation, guint64 arg_size, GVariant *arg_options); gboolean (*handle_convert) ( UDisksEncrypted *object, GDBusMethodInvocation *invocation, const gchar *arg_target_version, GVariant *arg_options); gboolean (*handle_header_backup) ( UDisksEncrypted *object, GDBusMethodInvocation *invocation, const gchar *arg_backup_file, GVariant *arg_options); }; #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksEncrypted, g_object_unref) #endif GType udisks_encrypted_get_type (void); GDBusInterfaceInfo *udisks_encrypted_interface_info (void); guint udisks_encrypted_override_properties (GObjectClass *klass, guint property_id_begin); /* D-Bus method call completion functions: */ void udisks_encrypted_complete_unlock ( UDisksEncrypted *object, GDBusMethodInvocation *invocation, const gchar *cleartext_device); void udisks_encrypted_complete_lock ( UDisksEncrypted *object, GDBusMethodInvocation *invocation); void udisks_encrypted_complete_change_passphrase ( UDisksEncrypted *object, GDBusMethodInvocation *invocation); void udisks_encrypted_complete_resize ( UDisksEncrypted *object, GDBusMethodInvocation *invocation); void udisks_encrypted_complete_convert ( UDisksEncrypted *object, GDBusMethodInvocation *invocation); void udisks_encrypted_complete_header_backup ( UDisksEncrypted *object, GDBusMethodInvocation *invocation); /* D-Bus method calls: */ void udisks_encrypted_call_unlock ( UDisksEncrypted *proxy, const gchar *arg_passphrase, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_encrypted_call_unlock_finish ( UDisksEncrypted *proxy, gchar ** out_cleartext_device, GAsyncResult *res, GError **error); gboolean udisks_encrypted_call_unlock_sync ( UDisksEncrypted *proxy, const gchar *arg_passphrase, GVariant *arg_options, gchar ** out_cleartext_device, GCancellable *cancellable, GError **error); void udisks_encrypted_call_lock ( UDisksEncrypted *proxy, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_encrypted_call_lock_finish ( UDisksEncrypted *proxy, GAsyncResult *res, GError **error); gboolean udisks_encrypted_call_lock_sync ( UDisksEncrypted *proxy, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_encrypted_call_change_passphrase ( UDisksEncrypted *proxy, const gchar *arg_passphrase, const gchar *arg_new_passphrase, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_encrypted_call_change_passphrase_finish ( UDisksEncrypted *proxy, GAsyncResult *res, GError **error); gboolean udisks_encrypted_call_change_passphrase_sync ( UDisksEncrypted *proxy, const gchar *arg_passphrase, const gchar *arg_new_passphrase, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_encrypted_call_resize ( UDisksEncrypted *proxy, guint64 arg_size, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_encrypted_call_resize_finish ( UDisksEncrypted *proxy, GAsyncResult *res, GError **error); gboolean udisks_encrypted_call_resize_sync ( UDisksEncrypted *proxy, guint64 arg_size, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_encrypted_call_convert ( UDisksEncrypted *proxy, const gchar *arg_target_version, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_encrypted_call_convert_finish ( UDisksEncrypted *proxy, GAsyncResult *res, GError **error); gboolean udisks_encrypted_call_convert_sync ( UDisksEncrypted *proxy, const gchar *arg_target_version, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_encrypted_call_header_backup ( UDisksEncrypted *proxy, const gchar *arg_backup_file, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_encrypted_call_header_backup_finish ( UDisksEncrypted *proxy, GAsyncResult *res, GError **error); gboolean udisks_encrypted_call_header_backup_sync ( UDisksEncrypted *proxy, const gchar *arg_backup_file, GVariant *arg_options, GCancellable *cancellable, GError **error); /* D-Bus property accessors: */ GVariant *udisks_encrypted_get_child_configuration (UDisksEncrypted *object); GVariant *udisks_encrypted_dup_child_configuration (UDisksEncrypted *object); void udisks_encrypted_set_child_configuration (UDisksEncrypted *object, GVariant *value); const gchar *udisks_encrypted_get_hint_encryption_type (UDisksEncrypted *object); gchar *udisks_encrypted_dup_hint_encryption_type (UDisksEncrypted *object); void udisks_encrypted_set_hint_encryption_type (UDisksEncrypted *object, const gchar *value); guint64 udisks_encrypted_get_metadata_size (UDisksEncrypted *object); void udisks_encrypted_set_metadata_size (UDisksEncrypted *object, guint64 value); const gchar *udisks_encrypted_get_cleartext_device (UDisksEncrypted *object); gchar *udisks_encrypted_dup_cleartext_device (UDisksEncrypted *object); void udisks_encrypted_set_cleartext_device (UDisksEncrypted *object, const gchar *value); /* ---- */ #define UDISKS_TYPE_ENCRYPTED_PROXY (udisks_encrypted_proxy_get_type ()) #define UDISKS_ENCRYPTED_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_ENCRYPTED_PROXY, UDisksEncryptedProxy)) #define UDISKS_ENCRYPTED_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UDISKS_TYPE_ENCRYPTED_PROXY, UDisksEncryptedProxyClass)) #define UDISKS_ENCRYPTED_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UDISKS_TYPE_ENCRYPTED_PROXY, UDisksEncryptedProxyClass)) #define UDISKS_IS_ENCRYPTED_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_ENCRYPTED_PROXY)) #define UDISKS_IS_ENCRYPTED_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UDISKS_TYPE_ENCRYPTED_PROXY)) typedef struct _UDisksEncryptedProxy UDisksEncryptedProxy; typedef struct _UDisksEncryptedProxyClass UDisksEncryptedProxyClass; typedef struct _UDisksEncryptedProxyPrivate UDisksEncryptedProxyPrivate; struct _UDisksEncryptedProxy { /*< private >*/ GDBusProxy parent_instance; UDisksEncryptedProxyPrivate *priv; }; struct _UDisksEncryptedProxyClass { GDBusProxyClass parent_class; }; GType udisks_encrypted_proxy_get_type (void); #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksEncryptedProxy, g_object_unref) #endif void udisks_encrypted_proxy_new ( GDBusConnection *connection, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); UDisksEncrypted *udisks_encrypted_proxy_new_finish ( GAsyncResult *res, GError **error); UDisksEncrypted *udisks_encrypted_proxy_new_sync ( GDBusConnection *connection, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GError **error); void udisks_encrypted_proxy_new_for_bus ( GBusType bus_type, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); UDisksEncrypted *udisks_encrypted_proxy_new_for_bus_finish ( GAsyncResult *res, GError **error); UDisksEncrypted *udisks_encrypted_proxy_new_for_bus_sync ( GBusType bus_type, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GError **error); /* ---- */ #define UDISKS_TYPE_ENCRYPTED_SKELETON (udisks_encrypted_skeleton_get_type ()) #define UDISKS_ENCRYPTED_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_ENCRYPTED_SKELETON, UDisksEncryptedSkeleton)) #define UDISKS_ENCRYPTED_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UDISKS_TYPE_ENCRYPTED_SKELETON, UDisksEncryptedSkeletonClass)) #define UDISKS_ENCRYPTED_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UDISKS_TYPE_ENCRYPTED_SKELETON, UDisksEncryptedSkeletonClass)) #define UDISKS_IS_ENCRYPTED_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_ENCRYPTED_SKELETON)) #define UDISKS_IS_ENCRYPTED_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UDISKS_TYPE_ENCRYPTED_SKELETON)) typedef struct _UDisksEncryptedSkeleton UDisksEncryptedSkeleton; typedef struct _UDisksEncryptedSkeletonClass UDisksEncryptedSkeletonClass; typedef struct _UDisksEncryptedSkeletonPrivate UDisksEncryptedSkeletonPrivate; struct _UDisksEncryptedSkeleton { /*< private >*/ GDBusInterfaceSkeleton parent_instance; UDisksEncryptedSkeletonPrivate *priv; }; struct _UDisksEncryptedSkeletonClass { GDBusInterfaceSkeletonClass parent_class; }; GType udisks_encrypted_skeleton_get_type (void); #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksEncryptedSkeleton, g_object_unref) #endif UDisksEncrypted *udisks_encrypted_skeleton_new (void); /* ------------------------------------------------------------------------ */ /* Declarations for org.freedesktop.UDisks2.Loop */ #define UDISKS_TYPE_LOOP (udisks_loop_get_type ()) #define UDISKS_LOOP(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_LOOP, UDisksLoop)) #define UDISKS_IS_LOOP(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_LOOP)) #define UDISKS_LOOP_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), UDISKS_TYPE_LOOP, UDisksLoopIface)) struct _UDisksLoop; typedef struct _UDisksLoop UDisksLoop; typedef struct _UDisksLoopIface UDisksLoopIface; struct _UDisksLoopIface { GTypeInterface parent_iface; gboolean (*handle_delete) ( UDisksLoop *object, GDBusMethodInvocation *invocation, GVariant *arg_options); gboolean (*handle_set_autoclear) ( UDisksLoop *object, GDBusMethodInvocation *invocation, gboolean arg_value, GVariant *arg_options); gboolean (*get_autoclear) (UDisksLoop *object); const gchar * (*get_backing_file) (UDisksLoop *object); guint (*get_setup_by_uid) (UDisksLoop *object); gboolean (*handle_set_capacity) ( UDisksLoop *object, GDBusMethodInvocation *invocation, GVariant *arg_options); }; #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksLoop, g_object_unref) #endif GType udisks_loop_get_type (void); GDBusInterfaceInfo *udisks_loop_interface_info (void); guint udisks_loop_override_properties (GObjectClass *klass, guint property_id_begin); /* D-Bus method call completion functions: */ void udisks_loop_complete_delete ( UDisksLoop *object, GDBusMethodInvocation *invocation); void udisks_loop_complete_set_autoclear ( UDisksLoop *object, GDBusMethodInvocation *invocation); void udisks_loop_complete_set_capacity ( UDisksLoop *object, GDBusMethodInvocation *invocation); /* D-Bus method calls: */ void udisks_loop_call_delete ( UDisksLoop *proxy, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_loop_call_delete_finish ( UDisksLoop *proxy, GAsyncResult *res, GError **error); gboolean udisks_loop_call_delete_sync ( UDisksLoop *proxy, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_loop_call_set_autoclear ( UDisksLoop *proxy, gboolean arg_value, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_loop_call_set_autoclear_finish ( UDisksLoop *proxy, GAsyncResult *res, GError **error); gboolean udisks_loop_call_set_autoclear_sync ( UDisksLoop *proxy, gboolean arg_value, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_loop_call_set_capacity ( UDisksLoop *proxy, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_loop_call_set_capacity_finish ( UDisksLoop *proxy, GAsyncResult *res, GError **error); gboolean udisks_loop_call_set_capacity_sync ( UDisksLoop *proxy, GVariant *arg_options, GCancellable *cancellable, GError **error); /* D-Bus property accessors: */ const gchar *udisks_loop_get_backing_file (UDisksLoop *object); gchar *udisks_loop_dup_backing_file (UDisksLoop *object); void udisks_loop_set_backing_file (UDisksLoop *object, const gchar *value); gboolean udisks_loop_get_autoclear (UDisksLoop *object); void udisks_loop_set_autoclear (UDisksLoop *object, gboolean value); guint udisks_loop_get_setup_by_uid (UDisksLoop *object); void udisks_loop_set_setup_by_uid (UDisksLoop *object, guint value); /* ---- */ #define UDISKS_TYPE_LOOP_PROXY (udisks_loop_proxy_get_type ()) #define UDISKS_LOOP_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_LOOP_PROXY, UDisksLoopProxy)) #define UDISKS_LOOP_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UDISKS_TYPE_LOOP_PROXY, UDisksLoopProxyClass)) #define UDISKS_LOOP_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UDISKS_TYPE_LOOP_PROXY, UDisksLoopProxyClass)) #define UDISKS_IS_LOOP_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_LOOP_PROXY)) #define UDISKS_IS_LOOP_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UDISKS_TYPE_LOOP_PROXY)) typedef struct _UDisksLoopProxy UDisksLoopProxy; typedef struct _UDisksLoopProxyClass UDisksLoopProxyClass; typedef struct _UDisksLoopProxyPrivate UDisksLoopProxyPrivate; struct _UDisksLoopProxy { /*< private >*/ GDBusProxy parent_instance; UDisksLoopProxyPrivate *priv; }; struct _UDisksLoopProxyClass { GDBusProxyClass parent_class; }; GType udisks_loop_proxy_get_type (void); #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksLoopProxy, g_object_unref) #endif void udisks_loop_proxy_new ( GDBusConnection *connection, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); UDisksLoop *udisks_loop_proxy_new_finish ( GAsyncResult *res, GError **error); UDisksLoop *udisks_loop_proxy_new_sync ( GDBusConnection *connection, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GError **error); void udisks_loop_proxy_new_for_bus ( GBusType bus_type, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); UDisksLoop *udisks_loop_proxy_new_for_bus_finish ( GAsyncResult *res, GError **error); UDisksLoop *udisks_loop_proxy_new_for_bus_sync ( GBusType bus_type, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GError **error); /* ---- */ #define UDISKS_TYPE_LOOP_SKELETON (udisks_loop_skeleton_get_type ()) #define UDISKS_LOOP_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_LOOP_SKELETON, UDisksLoopSkeleton)) #define UDISKS_LOOP_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UDISKS_TYPE_LOOP_SKELETON, UDisksLoopSkeletonClass)) #define UDISKS_LOOP_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UDISKS_TYPE_LOOP_SKELETON, UDisksLoopSkeletonClass)) #define UDISKS_IS_LOOP_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_LOOP_SKELETON)) #define UDISKS_IS_LOOP_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UDISKS_TYPE_LOOP_SKELETON)) typedef struct _UDisksLoopSkeleton UDisksLoopSkeleton; typedef struct _UDisksLoopSkeletonClass UDisksLoopSkeletonClass; typedef struct _UDisksLoopSkeletonPrivate UDisksLoopSkeletonPrivate; struct _UDisksLoopSkeleton { /*< private >*/ GDBusInterfaceSkeleton parent_instance; UDisksLoopSkeletonPrivate *priv; }; struct _UDisksLoopSkeletonClass { GDBusInterfaceSkeletonClass parent_class; }; GType udisks_loop_skeleton_get_type (void); #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksLoopSkeleton, g_object_unref) #endif UDisksLoop *udisks_loop_skeleton_new (void); /* ------------------------------------------------------------------------ */ /* Declarations for org.freedesktop.UDisks2.MDRaid */ #define UDISKS_TYPE_MDRAID (udisks_mdraid_get_type ()) #define UDISKS_MDRAID(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_MDRAID, UDisksMDRaid)) #define UDISKS_IS_MDRAID(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_MDRAID)) #define UDISKS_MDRAID_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), UDISKS_TYPE_MDRAID, UDisksMDRaidIface)) struct _UDisksMDRaid; typedef struct _UDisksMDRaid UDisksMDRaid; typedef struct _UDisksMDRaidIface UDisksMDRaidIface; struct _UDisksMDRaidIface { GTypeInterface parent_iface; gboolean (*handle_add_device) ( UDisksMDRaid *object, GDBusMethodInvocation *invocation, const gchar *arg_device, GVariant *arg_options); gboolean (*handle_delete) ( UDisksMDRaid *object, GDBusMethodInvocation *invocation, GVariant *arg_options); gboolean (*handle_remove_device) ( UDisksMDRaid *object, GDBusMethodInvocation *invocation, const gchar *arg_device, GVariant *arg_options); gboolean (*handle_request_sync_action) ( UDisksMDRaid *object, GDBusMethodInvocation *invocation, const gchar *arg_sync_action, GVariant *arg_options); gboolean (*handle_set_bitmap_location) ( UDisksMDRaid *object, GDBusMethodInvocation *invocation, const gchar *arg_value, GVariant *arg_options); gboolean (*handle_start) ( UDisksMDRaid *object, GDBusMethodInvocation *invocation, GVariant *arg_options); gboolean (*handle_stop) ( UDisksMDRaid *object, GDBusMethodInvocation *invocation, GVariant *arg_options); GVariant * (*get_active_devices) (UDisksMDRaid *object); const gchar * (*get_bitmap_location) (UDisksMDRaid *object); GVariant * (*get_child_configuration) (UDisksMDRaid *object); guint64 (*get_chunk_size) (UDisksMDRaid *object); const gchar * (*get_consistency_policy) (UDisksMDRaid *object); guint (*get_degraded) (UDisksMDRaid *object); const gchar * (*get_level) (UDisksMDRaid *object); const gchar * (*get_name) (UDisksMDRaid *object); guint (*get_num_devices) (UDisksMDRaid *object); gboolean (*get_running) (UDisksMDRaid *object); guint64 (*get_size) (UDisksMDRaid *object); const gchar * (*get_sync_action) (UDisksMDRaid *object); gdouble (*get_sync_completed) (UDisksMDRaid *object); guint64 (*get_sync_rate) (UDisksMDRaid *object); guint64 (*get_sync_remaining_time) (UDisksMDRaid *object); const gchar * (*get_uuid) (UDisksMDRaid *object); }; #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksMDRaid, g_object_unref) #endif GType udisks_mdraid_get_type (void); GDBusInterfaceInfo *udisks_mdraid_interface_info (void); guint udisks_mdraid_override_properties (GObjectClass *klass, guint property_id_begin); /* D-Bus method call completion functions: */ void udisks_mdraid_complete_start ( UDisksMDRaid *object, GDBusMethodInvocation *invocation); void udisks_mdraid_complete_stop ( UDisksMDRaid *object, GDBusMethodInvocation *invocation); void udisks_mdraid_complete_remove_device ( UDisksMDRaid *object, GDBusMethodInvocation *invocation); void udisks_mdraid_complete_add_device ( UDisksMDRaid *object, GDBusMethodInvocation *invocation); void udisks_mdraid_complete_set_bitmap_location ( UDisksMDRaid *object, GDBusMethodInvocation *invocation); void udisks_mdraid_complete_request_sync_action ( UDisksMDRaid *object, GDBusMethodInvocation *invocation); void udisks_mdraid_complete_delete ( UDisksMDRaid *object, GDBusMethodInvocation *invocation); /* D-Bus method calls: */ void udisks_mdraid_call_start ( UDisksMDRaid *proxy, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_mdraid_call_start_finish ( UDisksMDRaid *proxy, GAsyncResult *res, GError **error); gboolean udisks_mdraid_call_start_sync ( UDisksMDRaid *proxy, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_mdraid_call_stop ( UDisksMDRaid *proxy, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_mdraid_call_stop_finish ( UDisksMDRaid *proxy, GAsyncResult *res, GError **error); gboolean udisks_mdraid_call_stop_sync ( UDisksMDRaid *proxy, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_mdraid_call_remove_device ( UDisksMDRaid *proxy, const gchar *arg_device, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_mdraid_call_remove_device_finish ( UDisksMDRaid *proxy, GAsyncResult *res, GError **error); gboolean udisks_mdraid_call_remove_device_sync ( UDisksMDRaid *proxy, const gchar *arg_device, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_mdraid_call_add_device ( UDisksMDRaid *proxy, const gchar *arg_device, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_mdraid_call_add_device_finish ( UDisksMDRaid *proxy, GAsyncResult *res, GError **error); gboolean udisks_mdraid_call_add_device_sync ( UDisksMDRaid *proxy, const gchar *arg_device, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_mdraid_call_set_bitmap_location ( UDisksMDRaid *proxy, const gchar *arg_value, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_mdraid_call_set_bitmap_location_finish ( UDisksMDRaid *proxy, GAsyncResult *res, GError **error); gboolean udisks_mdraid_call_set_bitmap_location_sync ( UDisksMDRaid *proxy, const gchar *arg_value, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_mdraid_call_request_sync_action ( UDisksMDRaid *proxy, const gchar *arg_sync_action, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_mdraid_call_request_sync_action_finish ( UDisksMDRaid *proxy, GAsyncResult *res, GError **error); gboolean udisks_mdraid_call_request_sync_action_sync ( UDisksMDRaid *proxy, const gchar *arg_sync_action, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_mdraid_call_delete ( UDisksMDRaid *proxy, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_mdraid_call_delete_finish ( UDisksMDRaid *proxy, GAsyncResult *res, GError **error); gboolean udisks_mdraid_call_delete_sync ( UDisksMDRaid *proxy, GVariant *arg_options, GCancellable *cancellable, GError **error); /* D-Bus property accessors: */ const gchar *udisks_mdraid_get_uuid (UDisksMDRaid *object); gchar *udisks_mdraid_dup_uuid (UDisksMDRaid *object); void udisks_mdraid_set_uuid (UDisksMDRaid *object, const gchar *value); const gchar *udisks_mdraid_get_name (UDisksMDRaid *object); gchar *udisks_mdraid_dup_name (UDisksMDRaid *object); void udisks_mdraid_set_name (UDisksMDRaid *object, const gchar *value); const gchar *udisks_mdraid_get_level (UDisksMDRaid *object); gchar *udisks_mdraid_dup_level (UDisksMDRaid *object); void udisks_mdraid_set_level (UDisksMDRaid *object, const gchar *value); guint udisks_mdraid_get_num_devices (UDisksMDRaid *object); void udisks_mdraid_set_num_devices (UDisksMDRaid *object, guint value); guint64 udisks_mdraid_get_size (UDisksMDRaid *object); void udisks_mdraid_set_size (UDisksMDRaid *object, guint64 value); const gchar *udisks_mdraid_get_sync_action (UDisksMDRaid *object); gchar *udisks_mdraid_dup_sync_action (UDisksMDRaid *object); void udisks_mdraid_set_sync_action (UDisksMDRaid *object, const gchar *value); gdouble udisks_mdraid_get_sync_completed (UDisksMDRaid *object); void udisks_mdraid_set_sync_completed (UDisksMDRaid *object, gdouble value); guint64 udisks_mdraid_get_sync_rate (UDisksMDRaid *object); void udisks_mdraid_set_sync_rate (UDisksMDRaid *object, guint64 value); guint64 udisks_mdraid_get_sync_remaining_time (UDisksMDRaid *object); void udisks_mdraid_set_sync_remaining_time (UDisksMDRaid *object, guint64 value); guint udisks_mdraid_get_degraded (UDisksMDRaid *object); void udisks_mdraid_set_degraded (UDisksMDRaid *object, guint value); const gchar *udisks_mdraid_get_consistency_policy (UDisksMDRaid *object); gchar *udisks_mdraid_dup_consistency_policy (UDisksMDRaid *object); void udisks_mdraid_set_consistency_policy (UDisksMDRaid *object, const gchar *value); const gchar *udisks_mdraid_get_bitmap_location (UDisksMDRaid *object); gchar *udisks_mdraid_dup_bitmap_location (UDisksMDRaid *object); void udisks_mdraid_set_bitmap_location (UDisksMDRaid *object, const gchar *value); guint64 udisks_mdraid_get_chunk_size (UDisksMDRaid *object); void udisks_mdraid_set_chunk_size (UDisksMDRaid *object, guint64 value); GVariant *udisks_mdraid_get_active_devices (UDisksMDRaid *object); GVariant *udisks_mdraid_dup_active_devices (UDisksMDRaid *object); void udisks_mdraid_set_active_devices (UDisksMDRaid *object, GVariant *value); GVariant *udisks_mdraid_get_child_configuration (UDisksMDRaid *object); GVariant *udisks_mdraid_dup_child_configuration (UDisksMDRaid *object); void udisks_mdraid_set_child_configuration (UDisksMDRaid *object, GVariant *value); gboolean udisks_mdraid_get_running (UDisksMDRaid *object); void udisks_mdraid_set_running (UDisksMDRaid *object, gboolean value); /* ---- */ #define UDISKS_TYPE_MDRAID_PROXY (udisks_mdraid_proxy_get_type ()) #define UDISKS_MDRAID_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_MDRAID_PROXY, UDisksMDRaidProxy)) #define UDISKS_MDRAID_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UDISKS_TYPE_MDRAID_PROXY, UDisksMDRaidProxyClass)) #define UDISKS_MDRAID_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UDISKS_TYPE_MDRAID_PROXY, UDisksMDRaidProxyClass)) #define UDISKS_IS_MDRAID_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_MDRAID_PROXY)) #define UDISKS_IS_MDRAID_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UDISKS_TYPE_MDRAID_PROXY)) typedef struct _UDisksMDRaidProxy UDisksMDRaidProxy; typedef struct _UDisksMDRaidProxyClass UDisksMDRaidProxyClass; typedef struct _UDisksMDRaidProxyPrivate UDisksMDRaidProxyPrivate; struct _UDisksMDRaidProxy { /*< private >*/ GDBusProxy parent_instance; UDisksMDRaidProxyPrivate *priv; }; struct _UDisksMDRaidProxyClass { GDBusProxyClass parent_class; }; GType udisks_mdraid_proxy_get_type (void); #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksMDRaidProxy, g_object_unref) #endif void udisks_mdraid_proxy_new ( GDBusConnection *connection, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); UDisksMDRaid *udisks_mdraid_proxy_new_finish ( GAsyncResult *res, GError **error); UDisksMDRaid *udisks_mdraid_proxy_new_sync ( GDBusConnection *connection, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GError **error); void udisks_mdraid_proxy_new_for_bus ( GBusType bus_type, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); UDisksMDRaid *udisks_mdraid_proxy_new_for_bus_finish ( GAsyncResult *res, GError **error); UDisksMDRaid *udisks_mdraid_proxy_new_for_bus_sync ( GBusType bus_type, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GError **error); /* ---- */ #define UDISKS_TYPE_MDRAID_SKELETON (udisks_mdraid_skeleton_get_type ()) #define UDISKS_MDRAID_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_MDRAID_SKELETON, UDisksMDRaidSkeleton)) #define UDISKS_MDRAID_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UDISKS_TYPE_MDRAID_SKELETON, UDisksMDRaidSkeletonClass)) #define UDISKS_MDRAID_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UDISKS_TYPE_MDRAID_SKELETON, UDisksMDRaidSkeletonClass)) #define UDISKS_IS_MDRAID_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_MDRAID_SKELETON)) #define UDISKS_IS_MDRAID_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UDISKS_TYPE_MDRAID_SKELETON)) typedef struct _UDisksMDRaidSkeleton UDisksMDRaidSkeleton; typedef struct _UDisksMDRaidSkeletonClass UDisksMDRaidSkeletonClass; typedef struct _UDisksMDRaidSkeletonPrivate UDisksMDRaidSkeletonPrivate; struct _UDisksMDRaidSkeleton { /*< private >*/ GDBusInterfaceSkeleton parent_instance; UDisksMDRaidSkeletonPrivate *priv; }; struct _UDisksMDRaidSkeletonClass { GDBusInterfaceSkeletonClass parent_class; }; GType udisks_mdraid_skeleton_get_type (void); #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksMDRaidSkeleton, g_object_unref) #endif UDisksMDRaid *udisks_mdraid_skeleton_new (void); /* ------------------------------------------------------------------------ */ /* Declarations for org.freedesktop.UDisks2.Job */ #define UDISKS_TYPE_JOB (udisks_job_get_type ()) #define UDISKS_JOB(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_JOB, UDisksJob)) #define UDISKS_IS_JOB(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_JOB)) #define UDISKS_JOB_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), UDISKS_TYPE_JOB, UDisksJobIface)) struct _UDisksJob; typedef struct _UDisksJob UDisksJob; typedef struct _UDisksJobIface UDisksJobIface; struct _UDisksJobIface { GTypeInterface parent_iface; gboolean (*handle_cancel) ( UDisksJob *object, GDBusMethodInvocation *invocation, GVariant *arg_options); guint64 (*get_bytes) (UDisksJob *object); gboolean (*get_cancelable) (UDisksJob *object); guint64 (*get_expected_end_time) (UDisksJob *object); const gchar *const * (*get_objects) (UDisksJob *object); const gchar * (*get_operation) (UDisksJob *object); gdouble (*get_progress) (UDisksJob *object); gboolean (*get_progress_valid) (UDisksJob *object); guint64 (*get_rate) (UDisksJob *object); guint64 (*get_start_time) (UDisksJob *object); guint (*get_started_by_uid) (UDisksJob *object); void (*completed) ( UDisksJob *object, gboolean arg_success, const gchar *arg_message); }; #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksJob, g_object_unref) #endif GType udisks_job_get_type (void); GDBusInterfaceInfo *udisks_job_interface_info (void); guint udisks_job_override_properties (GObjectClass *klass, guint property_id_begin); /* D-Bus method call completion functions: */ void udisks_job_complete_cancel ( UDisksJob *object, GDBusMethodInvocation *invocation); /* D-Bus signal emissions functions: */ void udisks_job_emit_completed ( UDisksJob *object, gboolean arg_success, const gchar *arg_message); /* D-Bus method calls: */ void udisks_job_call_cancel ( UDisksJob *proxy, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_job_call_cancel_finish ( UDisksJob *proxy, GAsyncResult *res, GError **error); gboolean udisks_job_call_cancel_sync ( UDisksJob *proxy, GVariant *arg_options, GCancellable *cancellable, GError **error); /* D-Bus property accessors: */ const gchar *udisks_job_get_operation (UDisksJob *object); gchar *udisks_job_dup_operation (UDisksJob *object); void udisks_job_set_operation (UDisksJob *object, const gchar *value); gdouble udisks_job_get_progress (UDisksJob *object); void udisks_job_set_progress (UDisksJob *object, gdouble value); gboolean udisks_job_get_progress_valid (UDisksJob *object); void udisks_job_set_progress_valid (UDisksJob *object, gboolean value); guint64 udisks_job_get_bytes (UDisksJob *object); void udisks_job_set_bytes (UDisksJob *object, guint64 value); guint64 udisks_job_get_rate (UDisksJob *object); void udisks_job_set_rate (UDisksJob *object, guint64 value); guint64 udisks_job_get_start_time (UDisksJob *object); void udisks_job_set_start_time (UDisksJob *object, guint64 value); guint64 udisks_job_get_expected_end_time (UDisksJob *object); void udisks_job_set_expected_end_time (UDisksJob *object, guint64 value); const gchar *const *udisks_job_get_objects (UDisksJob *object); gchar **udisks_job_dup_objects (UDisksJob *object); void udisks_job_set_objects (UDisksJob *object, const gchar *const *value); guint udisks_job_get_started_by_uid (UDisksJob *object); void udisks_job_set_started_by_uid (UDisksJob *object, guint value); gboolean udisks_job_get_cancelable (UDisksJob *object); void udisks_job_set_cancelable (UDisksJob *object, gboolean value); /* ---- */ #define UDISKS_TYPE_JOB_PROXY (udisks_job_proxy_get_type ()) #define UDISKS_JOB_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_JOB_PROXY, UDisksJobProxy)) #define UDISKS_JOB_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UDISKS_TYPE_JOB_PROXY, UDisksJobProxyClass)) #define UDISKS_JOB_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UDISKS_TYPE_JOB_PROXY, UDisksJobProxyClass)) #define UDISKS_IS_JOB_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_JOB_PROXY)) #define UDISKS_IS_JOB_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UDISKS_TYPE_JOB_PROXY)) typedef struct _UDisksJobProxy UDisksJobProxy; typedef struct _UDisksJobProxyClass UDisksJobProxyClass; typedef struct _UDisksJobProxyPrivate UDisksJobProxyPrivate; struct _UDisksJobProxy { /*< private >*/ GDBusProxy parent_instance; UDisksJobProxyPrivate *priv; }; struct _UDisksJobProxyClass { GDBusProxyClass parent_class; }; GType udisks_job_proxy_get_type (void); #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksJobProxy, g_object_unref) #endif void udisks_job_proxy_new ( GDBusConnection *connection, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); UDisksJob *udisks_job_proxy_new_finish ( GAsyncResult *res, GError **error); UDisksJob *udisks_job_proxy_new_sync ( GDBusConnection *connection, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GError **error); void udisks_job_proxy_new_for_bus ( GBusType bus_type, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); UDisksJob *udisks_job_proxy_new_for_bus_finish ( GAsyncResult *res, GError **error); UDisksJob *udisks_job_proxy_new_for_bus_sync ( GBusType bus_type, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GError **error); /* ---- */ #define UDISKS_TYPE_JOB_SKELETON (udisks_job_skeleton_get_type ()) #define UDISKS_JOB_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_JOB_SKELETON, UDisksJobSkeleton)) #define UDISKS_JOB_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UDISKS_TYPE_JOB_SKELETON, UDisksJobSkeletonClass)) #define UDISKS_JOB_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UDISKS_TYPE_JOB_SKELETON, UDisksJobSkeletonClass)) #define UDISKS_IS_JOB_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_JOB_SKELETON)) #define UDISKS_IS_JOB_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UDISKS_TYPE_JOB_SKELETON)) typedef struct _UDisksJobSkeleton UDisksJobSkeleton; typedef struct _UDisksJobSkeletonClass UDisksJobSkeletonClass; typedef struct _UDisksJobSkeletonPrivate UDisksJobSkeletonPrivate; struct _UDisksJobSkeleton { /*< private >*/ GDBusInterfaceSkeleton parent_instance; UDisksJobSkeletonPrivate *priv; }; struct _UDisksJobSkeletonClass { GDBusInterfaceSkeletonClass parent_class; }; GType udisks_job_skeleton_get_type (void); #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksJobSkeleton, g_object_unref) #endif UDisksJob *udisks_job_skeleton_new (void); /* ------------------------------------------------------------------------ */ /* Declarations for org.freedesktop.UDisks2.Manager.BTRFS */ #define UDISKS_TYPE_MANAGER_BTRFS (udisks_manager_btrfs_get_type ()) #define UDISKS_MANAGER_BTRFS(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_MANAGER_BTRFS, UDisksManagerBTRFS)) #define UDISKS_IS_MANAGER_BTRFS(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_MANAGER_BTRFS)) #define UDISKS_MANAGER_BTRFS_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), UDISKS_TYPE_MANAGER_BTRFS, UDisksManagerBTRFSIface)) struct _UDisksManagerBTRFS; typedef struct _UDisksManagerBTRFS UDisksManagerBTRFS; typedef struct _UDisksManagerBTRFSIface UDisksManagerBTRFSIface; struct _UDisksManagerBTRFSIface { GTypeInterface parent_iface; gboolean (*handle_create_volume) ( UDisksManagerBTRFS *object, GDBusMethodInvocation *invocation, const gchar *const *arg_devices, const gchar *arg_label, const gchar *arg_data_level, const gchar *arg_md_level, GVariant *arg_options); }; #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksManagerBTRFS, g_object_unref) #endif GType udisks_manager_btrfs_get_type (void); GDBusInterfaceInfo *udisks_manager_btrfs_interface_info (void); guint udisks_manager_btrfs_override_properties (GObjectClass *klass, guint property_id_begin); /* D-Bus method call completion functions: */ void udisks_manager_btrfs_complete_create_volume ( UDisksManagerBTRFS *object, GDBusMethodInvocation *invocation); /* D-Bus method calls: */ void udisks_manager_btrfs_call_create_volume ( UDisksManagerBTRFS *proxy, const gchar *const *arg_devices, const gchar *arg_label, const gchar *arg_data_level, const gchar *arg_md_level, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_manager_btrfs_call_create_volume_finish ( UDisksManagerBTRFS *proxy, GAsyncResult *res, GError **error); gboolean udisks_manager_btrfs_call_create_volume_sync ( UDisksManagerBTRFS *proxy, const gchar *const *arg_devices, const gchar *arg_label, const gchar *arg_data_level, const gchar *arg_md_level, GVariant *arg_options, GCancellable *cancellable, GError **error); /* ---- */ #define UDISKS_TYPE_MANAGER_BTRFS_PROXY (udisks_manager_btrfs_proxy_get_type ()) #define UDISKS_MANAGER_BTRFS_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_MANAGER_BTRFS_PROXY, UDisksManagerBTRFSProxy)) #define UDISKS_MANAGER_BTRFS_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UDISKS_TYPE_MANAGER_BTRFS_PROXY, UDisksManagerBTRFSProxyClass)) #define UDISKS_MANAGER_BTRFS_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UDISKS_TYPE_MANAGER_BTRFS_PROXY, UDisksManagerBTRFSProxyClass)) #define UDISKS_IS_MANAGER_BTRFS_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_MANAGER_BTRFS_PROXY)) #define UDISKS_IS_MANAGER_BTRFS_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UDISKS_TYPE_MANAGER_BTRFS_PROXY)) typedef struct _UDisksManagerBTRFSProxy UDisksManagerBTRFSProxy; typedef struct _UDisksManagerBTRFSProxyClass UDisksManagerBTRFSProxyClass; typedef struct _UDisksManagerBTRFSProxyPrivate UDisksManagerBTRFSProxyPrivate; struct _UDisksManagerBTRFSProxy { /*< private >*/ GDBusProxy parent_instance; UDisksManagerBTRFSProxyPrivate *priv; }; struct _UDisksManagerBTRFSProxyClass { GDBusProxyClass parent_class; }; GType udisks_manager_btrfs_proxy_get_type (void); #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksManagerBTRFSProxy, g_object_unref) #endif void udisks_manager_btrfs_proxy_new ( GDBusConnection *connection, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); UDisksManagerBTRFS *udisks_manager_btrfs_proxy_new_finish ( GAsyncResult *res, GError **error); UDisksManagerBTRFS *udisks_manager_btrfs_proxy_new_sync ( GDBusConnection *connection, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GError **error); void udisks_manager_btrfs_proxy_new_for_bus ( GBusType bus_type, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); UDisksManagerBTRFS *udisks_manager_btrfs_proxy_new_for_bus_finish ( GAsyncResult *res, GError **error); UDisksManagerBTRFS *udisks_manager_btrfs_proxy_new_for_bus_sync ( GBusType bus_type, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GError **error); /* ---- */ #define UDISKS_TYPE_MANAGER_BTRFS_SKELETON (udisks_manager_btrfs_skeleton_get_type ()) #define UDISKS_MANAGER_BTRFS_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_MANAGER_BTRFS_SKELETON, UDisksManagerBTRFSSkeleton)) #define UDISKS_MANAGER_BTRFS_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UDISKS_TYPE_MANAGER_BTRFS_SKELETON, UDisksManagerBTRFSSkeletonClass)) #define UDISKS_MANAGER_BTRFS_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UDISKS_TYPE_MANAGER_BTRFS_SKELETON, UDisksManagerBTRFSSkeletonClass)) #define UDISKS_IS_MANAGER_BTRFS_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_MANAGER_BTRFS_SKELETON)) #define UDISKS_IS_MANAGER_BTRFS_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UDISKS_TYPE_MANAGER_BTRFS_SKELETON)) typedef struct _UDisksManagerBTRFSSkeleton UDisksManagerBTRFSSkeleton; typedef struct _UDisksManagerBTRFSSkeletonClass UDisksManagerBTRFSSkeletonClass; typedef struct _UDisksManagerBTRFSSkeletonPrivate UDisksManagerBTRFSSkeletonPrivate; struct _UDisksManagerBTRFSSkeleton { /*< private >*/ GDBusInterfaceSkeleton parent_instance; UDisksManagerBTRFSSkeletonPrivate *priv; }; struct _UDisksManagerBTRFSSkeletonClass { GDBusInterfaceSkeletonClass parent_class; }; GType udisks_manager_btrfs_skeleton_get_type (void); #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksManagerBTRFSSkeleton, g_object_unref) #endif UDisksManagerBTRFS *udisks_manager_btrfs_skeleton_new (void); /* ------------------------------------------------------------------------ */ /* Declarations for org.freedesktop.UDisks2.Filesystem.BTRFS */ #define UDISKS_TYPE_FILESYSTEM_BTRFS (udisks_filesystem_btrfs_get_type ()) #define UDISKS_FILESYSTEM_BTRFS(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_FILESYSTEM_BTRFS, UDisksFilesystemBTRFS)) #define UDISKS_IS_FILESYSTEM_BTRFS(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_FILESYSTEM_BTRFS)) #define UDISKS_FILESYSTEM_BTRFS_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), UDISKS_TYPE_FILESYSTEM_BTRFS, UDisksFilesystemBTRFSIface)) struct _UDisksFilesystemBTRFS; typedef struct _UDisksFilesystemBTRFS UDisksFilesystemBTRFS; typedef struct _UDisksFilesystemBTRFSIface UDisksFilesystemBTRFSIface; struct _UDisksFilesystemBTRFSIface { GTypeInterface parent_iface; gboolean (*handle_create_snapshot) ( UDisksFilesystemBTRFS *object, GDBusMethodInvocation *invocation, const gchar *arg_source, const gchar *arg_dest, gboolean arg_ro, GVariant *arg_options); gboolean (*handle_create_subvolume) ( UDisksFilesystemBTRFS *object, GDBusMethodInvocation *invocation, const gchar *arg_name, GVariant *arg_options); gboolean (*handle_get_subvolumes) ( UDisksFilesystemBTRFS *object, GDBusMethodInvocation *invocation, gboolean arg_snapshots_only, GVariant *arg_options); gboolean (*handle_remove_subvolume) ( UDisksFilesystemBTRFS *object, GDBusMethodInvocation *invocation, const gchar *arg_name, GVariant *arg_options); gboolean (*handle_set_label) ( UDisksFilesystemBTRFS *object, GDBusMethodInvocation *invocation, const gchar *arg_label, GVariant *arg_options); const gchar * (*get_label) (UDisksFilesystemBTRFS *object); guint64 (*get_num_devices) (UDisksFilesystemBTRFS *object); guint64 (*get_used) (UDisksFilesystemBTRFS *object); const gchar * (*get_uuid) (UDisksFilesystemBTRFS *object); gboolean (*handle_add_device) ( UDisksFilesystemBTRFS *object, GDBusMethodInvocation *invocation, const gchar *arg_device, GVariant *arg_options); gboolean (*handle_remove_device) ( UDisksFilesystemBTRFS *object, GDBusMethodInvocation *invocation, const gchar *arg_device, GVariant *arg_options); gboolean (*handle_repair) ( UDisksFilesystemBTRFS *object, GDBusMethodInvocation *invocation, GVariant *arg_options); gboolean (*handle_resize) ( UDisksFilesystemBTRFS *object, GDBusMethodInvocation *invocation, guint64 arg_size, GVariant *arg_options); gboolean (*handle_get_default_subvolume_id) ( UDisksFilesystemBTRFS *object, GDBusMethodInvocation *invocation, GVariant *arg_options); gboolean (*handle_set_default_subvolume_id) ( UDisksFilesystemBTRFS *object, GDBusMethodInvocation *invocation, guint arg_id, GVariant *arg_options); }; #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksFilesystemBTRFS, g_object_unref) #endif GType udisks_filesystem_btrfs_get_type (void); GDBusInterfaceInfo *udisks_filesystem_btrfs_interface_info (void); guint udisks_filesystem_btrfs_override_properties (GObjectClass *klass, guint property_id_begin); /* D-Bus method call completion functions: */ void udisks_filesystem_btrfs_complete_add_device ( UDisksFilesystemBTRFS *object, GDBusMethodInvocation *invocation); void udisks_filesystem_btrfs_complete_remove_device ( UDisksFilesystemBTRFS *object, GDBusMethodInvocation *invocation); void udisks_filesystem_btrfs_complete_create_subvolume ( UDisksFilesystemBTRFS *object, GDBusMethodInvocation *invocation); void udisks_filesystem_btrfs_complete_remove_subvolume ( UDisksFilesystemBTRFS *object, GDBusMethodInvocation *invocation); void udisks_filesystem_btrfs_complete_get_subvolumes ( UDisksFilesystemBTRFS *object, GDBusMethodInvocation *invocation, GVariant *subvolumes, gint subvolumes_cnt); void udisks_filesystem_btrfs_complete_create_snapshot ( UDisksFilesystemBTRFS *object, GDBusMethodInvocation *invocation); void udisks_filesystem_btrfs_complete_repair ( UDisksFilesystemBTRFS *object, GDBusMethodInvocation *invocation); void udisks_filesystem_btrfs_complete_resize ( UDisksFilesystemBTRFS *object, GDBusMethodInvocation *invocation); void udisks_filesystem_btrfs_complete_set_label ( UDisksFilesystemBTRFS *object, GDBusMethodInvocation *invocation); void udisks_filesystem_btrfs_complete_get_default_subvolume_id ( UDisksFilesystemBTRFS *object, GDBusMethodInvocation *invocation, guint id); void udisks_filesystem_btrfs_complete_set_default_subvolume_id ( UDisksFilesystemBTRFS *object, GDBusMethodInvocation *invocation); /* D-Bus method calls: */ void udisks_filesystem_btrfs_call_add_device ( UDisksFilesystemBTRFS *proxy, const gchar *arg_device, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_filesystem_btrfs_call_add_device_finish ( UDisksFilesystemBTRFS *proxy, GAsyncResult *res, GError **error); gboolean udisks_filesystem_btrfs_call_add_device_sync ( UDisksFilesystemBTRFS *proxy, const gchar *arg_device, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_filesystem_btrfs_call_remove_device ( UDisksFilesystemBTRFS *proxy, const gchar *arg_device, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_filesystem_btrfs_call_remove_device_finish ( UDisksFilesystemBTRFS *proxy, GAsyncResult *res, GError **error); gboolean udisks_filesystem_btrfs_call_remove_device_sync ( UDisksFilesystemBTRFS *proxy, const gchar *arg_device, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_filesystem_btrfs_call_create_subvolume ( UDisksFilesystemBTRFS *proxy, const gchar *arg_name, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_filesystem_btrfs_call_create_subvolume_finish ( UDisksFilesystemBTRFS *proxy, GAsyncResult *res, GError **error); gboolean udisks_filesystem_btrfs_call_create_subvolume_sync ( UDisksFilesystemBTRFS *proxy, const gchar *arg_name, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_filesystem_btrfs_call_remove_subvolume ( UDisksFilesystemBTRFS *proxy, const gchar *arg_name, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_filesystem_btrfs_call_remove_subvolume_finish ( UDisksFilesystemBTRFS *proxy, GAsyncResult *res, GError **error); gboolean udisks_filesystem_btrfs_call_remove_subvolume_sync ( UDisksFilesystemBTRFS *proxy, const gchar *arg_name, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_filesystem_btrfs_call_get_subvolumes ( UDisksFilesystemBTRFS *proxy, gboolean arg_snapshots_only, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_filesystem_btrfs_call_get_subvolumes_finish ( UDisksFilesystemBTRFS *proxy, GVariant ** out_subvolumes, gint* out_subvolumes_cnt, GAsyncResult *res, GError **error); gboolean udisks_filesystem_btrfs_call_get_subvolumes_sync ( UDisksFilesystemBTRFS *proxy, gboolean arg_snapshots_only, GVariant *arg_options, GVariant ** out_subvolumes, gint* out_subvolumes_cnt, GCancellable *cancellable, GError **error); void udisks_filesystem_btrfs_call_create_snapshot ( UDisksFilesystemBTRFS *proxy, const gchar *arg_source, const gchar *arg_dest, gboolean arg_ro, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_filesystem_btrfs_call_create_snapshot_finish ( UDisksFilesystemBTRFS *proxy, GAsyncResult *res, GError **error); gboolean udisks_filesystem_btrfs_call_create_snapshot_sync ( UDisksFilesystemBTRFS *proxy, const gchar *arg_source, const gchar *arg_dest, gboolean arg_ro, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_filesystem_btrfs_call_repair ( UDisksFilesystemBTRFS *proxy, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_filesystem_btrfs_call_repair_finish ( UDisksFilesystemBTRFS *proxy, GAsyncResult *res, GError **error); gboolean udisks_filesystem_btrfs_call_repair_sync ( UDisksFilesystemBTRFS *proxy, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_filesystem_btrfs_call_resize ( UDisksFilesystemBTRFS *proxy, guint64 arg_size, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_filesystem_btrfs_call_resize_finish ( UDisksFilesystemBTRFS *proxy, GAsyncResult *res, GError **error); gboolean udisks_filesystem_btrfs_call_resize_sync ( UDisksFilesystemBTRFS *proxy, guint64 arg_size, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_filesystem_btrfs_call_set_label ( UDisksFilesystemBTRFS *proxy, const gchar *arg_label, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_filesystem_btrfs_call_set_label_finish ( UDisksFilesystemBTRFS *proxy, GAsyncResult *res, GError **error); gboolean udisks_filesystem_btrfs_call_set_label_sync ( UDisksFilesystemBTRFS *proxy, const gchar *arg_label, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_filesystem_btrfs_call_get_default_subvolume_id ( UDisksFilesystemBTRFS *proxy, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_filesystem_btrfs_call_get_default_subvolume_id_finish ( UDisksFilesystemBTRFS *proxy, guint* out_id, GAsyncResult *res, GError **error); gboolean udisks_filesystem_btrfs_call_get_default_subvolume_id_sync ( UDisksFilesystemBTRFS *proxy, GVariant *arg_options, guint* out_id, GCancellable *cancellable, GError **error); void udisks_filesystem_btrfs_call_set_default_subvolume_id ( UDisksFilesystemBTRFS *proxy, guint arg_id, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_filesystem_btrfs_call_set_default_subvolume_id_finish ( UDisksFilesystemBTRFS *proxy, GAsyncResult *res, GError **error); gboolean udisks_filesystem_btrfs_call_set_default_subvolume_id_sync ( UDisksFilesystemBTRFS *proxy, guint arg_id, GVariant *arg_options, GCancellable *cancellable, GError **error); /* D-Bus property accessors: */ const gchar *udisks_filesystem_btrfs_get_label (UDisksFilesystemBTRFS *object); gchar *udisks_filesystem_btrfs_dup_label (UDisksFilesystemBTRFS *object); void udisks_filesystem_btrfs_set_label (UDisksFilesystemBTRFS *object, const gchar *value); const gchar *udisks_filesystem_btrfs_get_uuid (UDisksFilesystemBTRFS *object); gchar *udisks_filesystem_btrfs_dup_uuid (UDisksFilesystemBTRFS *object); void udisks_filesystem_btrfs_set_uuid (UDisksFilesystemBTRFS *object, const gchar *value); guint64 udisks_filesystem_btrfs_get_num_devices (UDisksFilesystemBTRFS *object); void udisks_filesystem_btrfs_set_num_devices (UDisksFilesystemBTRFS *object, guint64 value); guint64 udisks_filesystem_btrfs_get_used (UDisksFilesystemBTRFS *object); void udisks_filesystem_btrfs_set_used (UDisksFilesystemBTRFS *object, guint64 value); /* ---- */ #define UDISKS_TYPE_FILESYSTEM_BTRFS_PROXY (udisks_filesystem_btrfs_proxy_get_type ()) #define UDISKS_FILESYSTEM_BTRFS_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_FILESYSTEM_BTRFS_PROXY, UDisksFilesystemBTRFSProxy)) #define UDISKS_FILESYSTEM_BTRFS_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UDISKS_TYPE_FILESYSTEM_BTRFS_PROXY, UDisksFilesystemBTRFSProxyClass)) #define UDISKS_FILESYSTEM_BTRFS_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UDISKS_TYPE_FILESYSTEM_BTRFS_PROXY, UDisksFilesystemBTRFSProxyClass)) #define UDISKS_IS_FILESYSTEM_BTRFS_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_FILESYSTEM_BTRFS_PROXY)) #define UDISKS_IS_FILESYSTEM_BTRFS_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UDISKS_TYPE_FILESYSTEM_BTRFS_PROXY)) typedef struct _UDisksFilesystemBTRFSProxy UDisksFilesystemBTRFSProxy; typedef struct _UDisksFilesystemBTRFSProxyClass UDisksFilesystemBTRFSProxyClass; typedef struct _UDisksFilesystemBTRFSProxyPrivate UDisksFilesystemBTRFSProxyPrivate; struct _UDisksFilesystemBTRFSProxy { /*< private >*/ GDBusProxy parent_instance; UDisksFilesystemBTRFSProxyPrivate *priv; }; struct _UDisksFilesystemBTRFSProxyClass { GDBusProxyClass parent_class; }; GType udisks_filesystem_btrfs_proxy_get_type (void); #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksFilesystemBTRFSProxy, g_object_unref) #endif void udisks_filesystem_btrfs_proxy_new ( GDBusConnection *connection, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); UDisksFilesystemBTRFS *udisks_filesystem_btrfs_proxy_new_finish ( GAsyncResult *res, GError **error); UDisksFilesystemBTRFS *udisks_filesystem_btrfs_proxy_new_sync ( GDBusConnection *connection, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GError **error); void udisks_filesystem_btrfs_proxy_new_for_bus ( GBusType bus_type, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); UDisksFilesystemBTRFS *udisks_filesystem_btrfs_proxy_new_for_bus_finish ( GAsyncResult *res, GError **error); UDisksFilesystemBTRFS *udisks_filesystem_btrfs_proxy_new_for_bus_sync ( GBusType bus_type, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GError **error); /* ---- */ #define UDISKS_TYPE_FILESYSTEM_BTRFS_SKELETON (udisks_filesystem_btrfs_skeleton_get_type ()) #define UDISKS_FILESYSTEM_BTRFS_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_FILESYSTEM_BTRFS_SKELETON, UDisksFilesystemBTRFSSkeleton)) #define UDISKS_FILESYSTEM_BTRFS_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UDISKS_TYPE_FILESYSTEM_BTRFS_SKELETON, UDisksFilesystemBTRFSSkeletonClass)) #define UDISKS_FILESYSTEM_BTRFS_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UDISKS_TYPE_FILESYSTEM_BTRFS_SKELETON, UDisksFilesystemBTRFSSkeletonClass)) #define UDISKS_IS_FILESYSTEM_BTRFS_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_FILESYSTEM_BTRFS_SKELETON)) #define UDISKS_IS_FILESYSTEM_BTRFS_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UDISKS_TYPE_FILESYSTEM_BTRFS_SKELETON)) typedef struct _UDisksFilesystemBTRFSSkeleton UDisksFilesystemBTRFSSkeleton; typedef struct _UDisksFilesystemBTRFSSkeletonClass UDisksFilesystemBTRFSSkeletonClass; typedef struct _UDisksFilesystemBTRFSSkeletonPrivate UDisksFilesystemBTRFSSkeletonPrivate; struct _UDisksFilesystemBTRFSSkeleton { /*< private >*/ GDBusInterfaceSkeleton parent_instance; UDisksFilesystemBTRFSSkeletonPrivate *priv; }; struct _UDisksFilesystemBTRFSSkeletonClass { GDBusInterfaceSkeletonClass parent_class; }; GType udisks_filesystem_btrfs_skeleton_get_type (void); #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksFilesystemBTRFSSkeleton, g_object_unref) #endif UDisksFilesystemBTRFS *udisks_filesystem_btrfs_skeleton_new (void); /* ------------------------------------------------------------------------ */ /* Declarations for org.freedesktop.UDisks2.Manager.LVM2 */ #define UDISKS_TYPE_MANAGER_LVM2 (udisks_manager_lvm2_get_type ()) #define UDISKS_MANAGER_LVM2(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_MANAGER_LVM2, UDisksManagerLVM2)) #define UDISKS_IS_MANAGER_LVM2(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_MANAGER_LVM2)) #define UDISKS_MANAGER_LVM2_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), UDISKS_TYPE_MANAGER_LVM2, UDisksManagerLVM2Iface)) struct _UDisksManagerLVM2; typedef struct _UDisksManagerLVM2 UDisksManagerLVM2; typedef struct _UDisksManagerLVM2Iface UDisksManagerLVM2Iface; struct _UDisksManagerLVM2Iface { GTypeInterface parent_iface; gboolean (*handle_volume_group_create) ( UDisksManagerLVM2 *object, GDBusMethodInvocation *invocation, const gchar *arg_name, const gchar *const *arg_blocks, GVariant *arg_options); }; #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksManagerLVM2, g_object_unref) #endif GType udisks_manager_lvm2_get_type (void); GDBusInterfaceInfo *udisks_manager_lvm2_interface_info (void); guint udisks_manager_lvm2_override_properties (GObjectClass *klass, guint property_id_begin); /* D-Bus method call completion functions: */ void udisks_manager_lvm2_complete_volume_group_create ( UDisksManagerLVM2 *object, GDBusMethodInvocation *invocation, const gchar *result); /* D-Bus method calls: */ void udisks_manager_lvm2_call_volume_group_create ( UDisksManagerLVM2 *proxy, const gchar *arg_name, const gchar *const *arg_blocks, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_manager_lvm2_call_volume_group_create_finish ( UDisksManagerLVM2 *proxy, gchar ** out_result, GAsyncResult *res, GError **error); gboolean udisks_manager_lvm2_call_volume_group_create_sync ( UDisksManagerLVM2 *proxy, const gchar *arg_name, const gchar *const *arg_blocks, GVariant *arg_options, gchar ** out_result, GCancellable *cancellable, GError **error); /* ---- */ #define UDISKS_TYPE_MANAGER_LVM2_PROXY (udisks_manager_lvm2_proxy_get_type ()) #define UDISKS_MANAGER_LVM2_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_MANAGER_LVM2_PROXY, UDisksManagerLVM2Proxy)) #define UDISKS_MANAGER_LVM2_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UDISKS_TYPE_MANAGER_LVM2_PROXY, UDisksManagerLVM2ProxyClass)) #define UDISKS_MANAGER_LVM2_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UDISKS_TYPE_MANAGER_LVM2_PROXY, UDisksManagerLVM2ProxyClass)) #define UDISKS_IS_MANAGER_LVM2_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_MANAGER_LVM2_PROXY)) #define UDISKS_IS_MANAGER_LVM2_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UDISKS_TYPE_MANAGER_LVM2_PROXY)) typedef struct _UDisksManagerLVM2Proxy UDisksManagerLVM2Proxy; typedef struct _UDisksManagerLVM2ProxyClass UDisksManagerLVM2ProxyClass; typedef struct _UDisksManagerLVM2ProxyPrivate UDisksManagerLVM2ProxyPrivate; struct _UDisksManagerLVM2Proxy { /*< private >*/ GDBusProxy parent_instance; UDisksManagerLVM2ProxyPrivate *priv; }; struct _UDisksManagerLVM2ProxyClass { GDBusProxyClass parent_class; }; GType udisks_manager_lvm2_proxy_get_type (void); #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksManagerLVM2Proxy, g_object_unref) #endif void udisks_manager_lvm2_proxy_new ( GDBusConnection *connection, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); UDisksManagerLVM2 *udisks_manager_lvm2_proxy_new_finish ( GAsyncResult *res, GError **error); UDisksManagerLVM2 *udisks_manager_lvm2_proxy_new_sync ( GDBusConnection *connection, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GError **error); void udisks_manager_lvm2_proxy_new_for_bus ( GBusType bus_type, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); UDisksManagerLVM2 *udisks_manager_lvm2_proxy_new_for_bus_finish ( GAsyncResult *res, GError **error); UDisksManagerLVM2 *udisks_manager_lvm2_proxy_new_for_bus_sync ( GBusType bus_type, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GError **error); /* ---- */ #define UDISKS_TYPE_MANAGER_LVM2_SKELETON (udisks_manager_lvm2_skeleton_get_type ()) #define UDISKS_MANAGER_LVM2_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_MANAGER_LVM2_SKELETON, UDisksManagerLVM2Skeleton)) #define UDISKS_MANAGER_LVM2_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UDISKS_TYPE_MANAGER_LVM2_SKELETON, UDisksManagerLVM2SkeletonClass)) #define UDISKS_MANAGER_LVM2_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UDISKS_TYPE_MANAGER_LVM2_SKELETON, UDisksManagerLVM2SkeletonClass)) #define UDISKS_IS_MANAGER_LVM2_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_MANAGER_LVM2_SKELETON)) #define UDISKS_IS_MANAGER_LVM2_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UDISKS_TYPE_MANAGER_LVM2_SKELETON)) typedef struct _UDisksManagerLVM2Skeleton UDisksManagerLVM2Skeleton; typedef struct _UDisksManagerLVM2SkeletonClass UDisksManagerLVM2SkeletonClass; typedef struct _UDisksManagerLVM2SkeletonPrivate UDisksManagerLVM2SkeletonPrivate; struct _UDisksManagerLVM2Skeleton { /*< private >*/ GDBusInterfaceSkeleton parent_instance; UDisksManagerLVM2SkeletonPrivate *priv; }; struct _UDisksManagerLVM2SkeletonClass { GDBusInterfaceSkeletonClass parent_class; }; GType udisks_manager_lvm2_skeleton_get_type (void); #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksManagerLVM2Skeleton, g_object_unref) #endif UDisksManagerLVM2 *udisks_manager_lvm2_skeleton_new (void); /* ------------------------------------------------------------------------ */ /* Declarations for org.freedesktop.UDisks2.Block.LVM2 */ #define UDISKS_TYPE_BLOCK_LVM2 (udisks_block_lvm2_get_type ()) #define UDISKS_BLOCK_LVM2(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_BLOCK_LVM2, UDisksBlockLVM2)) #define UDISKS_IS_BLOCK_LVM2(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_BLOCK_LVM2)) #define UDISKS_BLOCK_LVM2_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), UDISKS_TYPE_BLOCK_LVM2, UDisksBlockLVM2Iface)) struct _UDisksBlockLVM2; typedef struct _UDisksBlockLVM2 UDisksBlockLVM2; typedef struct _UDisksBlockLVM2Iface UDisksBlockLVM2Iface; struct _UDisksBlockLVM2Iface { GTypeInterface parent_iface; const gchar * (*get_logical_volume) (UDisksBlockLVM2 *object); }; #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksBlockLVM2, g_object_unref) #endif GType udisks_block_lvm2_get_type (void); GDBusInterfaceInfo *udisks_block_lvm2_interface_info (void); guint udisks_block_lvm2_override_properties (GObjectClass *klass, guint property_id_begin); /* D-Bus property accessors: */ const gchar *udisks_block_lvm2_get_logical_volume (UDisksBlockLVM2 *object); gchar *udisks_block_lvm2_dup_logical_volume (UDisksBlockLVM2 *object); void udisks_block_lvm2_set_logical_volume (UDisksBlockLVM2 *object, const gchar *value); /* ---- */ #define UDISKS_TYPE_BLOCK_LVM2_PROXY (udisks_block_lvm2_proxy_get_type ()) #define UDISKS_BLOCK_LVM2_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_BLOCK_LVM2_PROXY, UDisksBlockLVM2Proxy)) #define UDISKS_BLOCK_LVM2_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UDISKS_TYPE_BLOCK_LVM2_PROXY, UDisksBlockLVM2ProxyClass)) #define UDISKS_BLOCK_LVM2_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UDISKS_TYPE_BLOCK_LVM2_PROXY, UDisksBlockLVM2ProxyClass)) #define UDISKS_IS_BLOCK_LVM2_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_BLOCK_LVM2_PROXY)) #define UDISKS_IS_BLOCK_LVM2_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UDISKS_TYPE_BLOCK_LVM2_PROXY)) typedef struct _UDisksBlockLVM2Proxy UDisksBlockLVM2Proxy; typedef struct _UDisksBlockLVM2ProxyClass UDisksBlockLVM2ProxyClass; typedef struct _UDisksBlockLVM2ProxyPrivate UDisksBlockLVM2ProxyPrivate; struct _UDisksBlockLVM2Proxy { /*< private >*/ GDBusProxy parent_instance; UDisksBlockLVM2ProxyPrivate *priv; }; struct _UDisksBlockLVM2ProxyClass { GDBusProxyClass parent_class; }; GType udisks_block_lvm2_proxy_get_type (void); #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksBlockLVM2Proxy, g_object_unref) #endif void udisks_block_lvm2_proxy_new ( GDBusConnection *connection, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); UDisksBlockLVM2 *udisks_block_lvm2_proxy_new_finish ( GAsyncResult *res, GError **error); UDisksBlockLVM2 *udisks_block_lvm2_proxy_new_sync ( GDBusConnection *connection, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GError **error); void udisks_block_lvm2_proxy_new_for_bus ( GBusType bus_type, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); UDisksBlockLVM2 *udisks_block_lvm2_proxy_new_for_bus_finish ( GAsyncResult *res, GError **error); UDisksBlockLVM2 *udisks_block_lvm2_proxy_new_for_bus_sync ( GBusType bus_type, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GError **error); /* ---- */ #define UDISKS_TYPE_BLOCK_LVM2_SKELETON (udisks_block_lvm2_skeleton_get_type ()) #define UDISKS_BLOCK_LVM2_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_BLOCK_LVM2_SKELETON, UDisksBlockLVM2Skeleton)) #define UDISKS_BLOCK_LVM2_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UDISKS_TYPE_BLOCK_LVM2_SKELETON, UDisksBlockLVM2SkeletonClass)) #define UDISKS_BLOCK_LVM2_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UDISKS_TYPE_BLOCK_LVM2_SKELETON, UDisksBlockLVM2SkeletonClass)) #define UDISKS_IS_BLOCK_LVM2_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_BLOCK_LVM2_SKELETON)) #define UDISKS_IS_BLOCK_LVM2_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UDISKS_TYPE_BLOCK_LVM2_SKELETON)) typedef struct _UDisksBlockLVM2Skeleton UDisksBlockLVM2Skeleton; typedef struct _UDisksBlockLVM2SkeletonClass UDisksBlockLVM2SkeletonClass; typedef struct _UDisksBlockLVM2SkeletonPrivate UDisksBlockLVM2SkeletonPrivate; struct _UDisksBlockLVM2Skeleton { /*< private >*/ GDBusInterfaceSkeleton parent_instance; UDisksBlockLVM2SkeletonPrivate *priv; }; struct _UDisksBlockLVM2SkeletonClass { GDBusInterfaceSkeletonClass parent_class; }; GType udisks_block_lvm2_skeleton_get_type (void); #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksBlockLVM2Skeleton, g_object_unref) #endif UDisksBlockLVM2 *udisks_block_lvm2_skeleton_new (void); /* ------------------------------------------------------------------------ */ /* Declarations for org.freedesktop.UDisks2.PhysicalVolume */ #define UDISKS_TYPE_PHYSICAL_VOLUME (udisks_physical_volume_get_type ()) #define UDISKS_PHYSICAL_VOLUME(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_PHYSICAL_VOLUME, UDisksPhysicalVolume)) #define UDISKS_IS_PHYSICAL_VOLUME(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_PHYSICAL_VOLUME)) #define UDISKS_PHYSICAL_VOLUME_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), UDISKS_TYPE_PHYSICAL_VOLUME, UDisksPhysicalVolumeIface)) struct _UDisksPhysicalVolume; typedef struct _UDisksPhysicalVolume UDisksPhysicalVolume; typedef struct _UDisksPhysicalVolumeIface UDisksPhysicalVolumeIface; struct _UDisksPhysicalVolumeIface { GTypeInterface parent_iface; guint64 (*get_free_size) (UDisksPhysicalVolume *object); guint64 (*get_size) (UDisksPhysicalVolume *object); const gchar * (*get_volume_group) (UDisksPhysicalVolume *object); }; #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksPhysicalVolume, g_object_unref) #endif GType udisks_physical_volume_get_type (void); GDBusInterfaceInfo *udisks_physical_volume_interface_info (void); guint udisks_physical_volume_override_properties (GObjectClass *klass, guint property_id_begin); /* D-Bus property accessors: */ const gchar *udisks_physical_volume_get_volume_group (UDisksPhysicalVolume *object); gchar *udisks_physical_volume_dup_volume_group (UDisksPhysicalVolume *object); void udisks_physical_volume_set_volume_group (UDisksPhysicalVolume *object, const gchar *value); guint64 udisks_physical_volume_get_size (UDisksPhysicalVolume *object); void udisks_physical_volume_set_size (UDisksPhysicalVolume *object, guint64 value); guint64 udisks_physical_volume_get_free_size (UDisksPhysicalVolume *object); void udisks_physical_volume_set_free_size (UDisksPhysicalVolume *object, guint64 value); /* ---- */ #define UDISKS_TYPE_PHYSICAL_VOLUME_PROXY (udisks_physical_volume_proxy_get_type ()) #define UDISKS_PHYSICAL_VOLUME_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_PHYSICAL_VOLUME_PROXY, UDisksPhysicalVolumeProxy)) #define UDISKS_PHYSICAL_VOLUME_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UDISKS_TYPE_PHYSICAL_VOLUME_PROXY, UDisksPhysicalVolumeProxyClass)) #define UDISKS_PHYSICAL_VOLUME_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UDISKS_TYPE_PHYSICAL_VOLUME_PROXY, UDisksPhysicalVolumeProxyClass)) #define UDISKS_IS_PHYSICAL_VOLUME_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_PHYSICAL_VOLUME_PROXY)) #define UDISKS_IS_PHYSICAL_VOLUME_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UDISKS_TYPE_PHYSICAL_VOLUME_PROXY)) typedef struct _UDisksPhysicalVolumeProxy UDisksPhysicalVolumeProxy; typedef struct _UDisksPhysicalVolumeProxyClass UDisksPhysicalVolumeProxyClass; typedef struct _UDisksPhysicalVolumeProxyPrivate UDisksPhysicalVolumeProxyPrivate; struct _UDisksPhysicalVolumeProxy { /*< private >*/ GDBusProxy parent_instance; UDisksPhysicalVolumeProxyPrivate *priv; }; struct _UDisksPhysicalVolumeProxyClass { GDBusProxyClass parent_class; }; GType udisks_physical_volume_proxy_get_type (void); #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksPhysicalVolumeProxy, g_object_unref) #endif void udisks_physical_volume_proxy_new ( GDBusConnection *connection, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); UDisksPhysicalVolume *udisks_physical_volume_proxy_new_finish ( GAsyncResult *res, GError **error); UDisksPhysicalVolume *udisks_physical_volume_proxy_new_sync ( GDBusConnection *connection, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GError **error); void udisks_physical_volume_proxy_new_for_bus ( GBusType bus_type, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); UDisksPhysicalVolume *udisks_physical_volume_proxy_new_for_bus_finish ( GAsyncResult *res, GError **error); UDisksPhysicalVolume *udisks_physical_volume_proxy_new_for_bus_sync ( GBusType bus_type, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GError **error); /* ---- */ #define UDISKS_TYPE_PHYSICAL_VOLUME_SKELETON (udisks_physical_volume_skeleton_get_type ()) #define UDISKS_PHYSICAL_VOLUME_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_PHYSICAL_VOLUME_SKELETON, UDisksPhysicalVolumeSkeleton)) #define UDISKS_PHYSICAL_VOLUME_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UDISKS_TYPE_PHYSICAL_VOLUME_SKELETON, UDisksPhysicalVolumeSkeletonClass)) #define UDISKS_PHYSICAL_VOLUME_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UDISKS_TYPE_PHYSICAL_VOLUME_SKELETON, UDisksPhysicalVolumeSkeletonClass)) #define UDISKS_IS_PHYSICAL_VOLUME_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_PHYSICAL_VOLUME_SKELETON)) #define UDISKS_IS_PHYSICAL_VOLUME_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UDISKS_TYPE_PHYSICAL_VOLUME_SKELETON)) typedef struct _UDisksPhysicalVolumeSkeleton UDisksPhysicalVolumeSkeleton; typedef struct _UDisksPhysicalVolumeSkeletonClass UDisksPhysicalVolumeSkeletonClass; typedef struct _UDisksPhysicalVolumeSkeletonPrivate UDisksPhysicalVolumeSkeletonPrivate; struct _UDisksPhysicalVolumeSkeleton { /*< private >*/ GDBusInterfaceSkeleton parent_instance; UDisksPhysicalVolumeSkeletonPrivate *priv; }; struct _UDisksPhysicalVolumeSkeletonClass { GDBusInterfaceSkeletonClass parent_class; }; GType udisks_physical_volume_skeleton_get_type (void); #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksPhysicalVolumeSkeleton, g_object_unref) #endif UDisksPhysicalVolume *udisks_physical_volume_skeleton_new (void); /* ------------------------------------------------------------------------ */ /* Declarations for org.freedesktop.UDisks2.VolumeGroup */ #define UDISKS_TYPE_VOLUME_GROUP (udisks_volume_group_get_type ()) #define UDISKS_VOLUME_GROUP(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_VOLUME_GROUP, UDisksVolumeGroup)) #define UDISKS_IS_VOLUME_GROUP(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_VOLUME_GROUP)) #define UDISKS_VOLUME_GROUP_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), UDISKS_TYPE_VOLUME_GROUP, UDisksVolumeGroupIface)) struct _UDisksVolumeGroup; typedef struct _UDisksVolumeGroup UDisksVolumeGroup; typedef struct _UDisksVolumeGroupIface UDisksVolumeGroupIface; struct _UDisksVolumeGroupIface { GTypeInterface parent_iface; gboolean (*handle_add_device) ( UDisksVolumeGroup *object, GDBusMethodInvocation *invocation, const gchar *arg_block, GVariant *arg_options); gboolean (*handle_create_plain_volume) ( UDisksVolumeGroup *object, GDBusMethodInvocation *invocation, const gchar *arg_name, guint64 arg_size, GVariant *arg_options); gboolean (*handle_create_plain_volume_with_layout) ( UDisksVolumeGroup *object, GDBusMethodInvocation *invocation, const gchar *arg_name, guint64 arg_size, const gchar *arg_layout, const gchar *const *arg_pvs, GVariant *arg_options); gboolean (*handle_create_thin_pool_volume) ( UDisksVolumeGroup *object, GDBusMethodInvocation *invocation, const gchar *arg_name, guint64 arg_size, GVariant *arg_options); gboolean (*handle_create_thin_volume) ( UDisksVolumeGroup *object, GDBusMethodInvocation *invocation, const gchar *arg_name, guint64 arg_size, const gchar *arg_pool, GVariant *arg_options); gboolean (*handle_create_vdo_volume) ( UDisksVolumeGroup *object, GDBusMethodInvocation *invocation, const gchar *arg_lv_name, const gchar *arg_pool_name, guint64 arg_data_size, guint64 arg_virtual_size, guint64 arg_index_memory, gboolean arg_compression, gboolean arg_deduplication, const gchar *arg_write_policy, GVariant *arg_options); gboolean (*handle_delete) ( UDisksVolumeGroup *object, GDBusMethodInvocation *invocation, gboolean arg_wipe, GVariant *arg_options); gboolean (*handle_empty_device) ( UDisksVolumeGroup *object, GDBusMethodInvocation *invocation, const gchar *arg_block, GVariant *arg_options); gboolean (*handle_poll) ( UDisksVolumeGroup *object, GDBusMethodInvocation *invocation); gboolean (*handle_remove_device) ( UDisksVolumeGroup *object, GDBusMethodInvocation *invocation, const gchar *arg_block, gboolean arg_wipe, GVariant *arg_options); gboolean (*handle_remove_missing_physical_volumes) ( UDisksVolumeGroup *object, GDBusMethodInvocation *invocation, GVariant *arg_options); gboolean (*handle_rename) ( UDisksVolumeGroup *object, GDBusMethodInvocation *invocation, const gchar *arg_new_name, GVariant *arg_options); guint64 (*get_extent_size) (UDisksVolumeGroup *object); guint64 (*get_free_size) (UDisksVolumeGroup *object); const gchar *const * (*get_missing_physical_volumes) (UDisksVolumeGroup *object); const gchar * (*get_name) (UDisksVolumeGroup *object); gboolean (*get_needs_polling) (UDisksVolumeGroup *object); guint64 (*get_size) (UDisksVolumeGroup *object); const gchar * (*get_uuid) (UDisksVolumeGroup *object); }; #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksVolumeGroup, g_object_unref) #endif GType udisks_volume_group_get_type (void); GDBusInterfaceInfo *udisks_volume_group_interface_info (void); guint udisks_volume_group_override_properties (GObjectClass *klass, guint property_id_begin); /* D-Bus method call completion functions: */ void udisks_volume_group_complete_poll ( UDisksVolumeGroup *object, GDBusMethodInvocation *invocation); void udisks_volume_group_complete_delete ( UDisksVolumeGroup *object, GDBusMethodInvocation *invocation); void udisks_volume_group_complete_rename ( UDisksVolumeGroup *object, GDBusMethodInvocation *invocation, const gchar *result); void udisks_volume_group_complete_add_device ( UDisksVolumeGroup *object, GDBusMethodInvocation *invocation); void udisks_volume_group_complete_empty_device ( UDisksVolumeGroup *object, GDBusMethodInvocation *invocation); void udisks_volume_group_complete_remove_device ( UDisksVolumeGroup *object, GDBusMethodInvocation *invocation); void udisks_volume_group_complete_remove_missing_physical_volumes ( UDisksVolumeGroup *object, GDBusMethodInvocation *invocation); void udisks_volume_group_complete_create_plain_volume ( UDisksVolumeGroup *object, GDBusMethodInvocation *invocation, const gchar *result); void udisks_volume_group_complete_create_plain_volume_with_layout ( UDisksVolumeGroup *object, GDBusMethodInvocation *invocation, const gchar *result); void udisks_volume_group_complete_create_thin_pool_volume ( UDisksVolumeGroup *object, GDBusMethodInvocation *invocation, const gchar *result); void udisks_volume_group_complete_create_thin_volume ( UDisksVolumeGroup *object, GDBusMethodInvocation *invocation, const gchar *result); void udisks_volume_group_complete_create_vdo_volume ( UDisksVolumeGroup *object, GDBusMethodInvocation *invocation, const gchar *result); /* D-Bus method calls: */ void udisks_volume_group_call_poll ( UDisksVolumeGroup *proxy, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_volume_group_call_poll_finish ( UDisksVolumeGroup *proxy, GAsyncResult *res, GError **error); gboolean udisks_volume_group_call_poll_sync ( UDisksVolumeGroup *proxy, GCancellable *cancellable, GError **error); void udisks_volume_group_call_delete ( UDisksVolumeGroup *proxy, gboolean arg_wipe, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_volume_group_call_delete_finish ( UDisksVolumeGroup *proxy, GAsyncResult *res, GError **error); gboolean udisks_volume_group_call_delete_sync ( UDisksVolumeGroup *proxy, gboolean arg_wipe, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_volume_group_call_rename ( UDisksVolumeGroup *proxy, const gchar *arg_new_name, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_volume_group_call_rename_finish ( UDisksVolumeGroup *proxy, gchar ** out_result, GAsyncResult *res, GError **error); gboolean udisks_volume_group_call_rename_sync ( UDisksVolumeGroup *proxy, const gchar *arg_new_name, GVariant *arg_options, gchar ** out_result, GCancellable *cancellable, GError **error); void udisks_volume_group_call_add_device ( UDisksVolumeGroup *proxy, const gchar *arg_block, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_volume_group_call_add_device_finish ( UDisksVolumeGroup *proxy, GAsyncResult *res, GError **error); gboolean udisks_volume_group_call_add_device_sync ( UDisksVolumeGroup *proxy, const gchar *arg_block, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_volume_group_call_empty_device ( UDisksVolumeGroup *proxy, const gchar *arg_block, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_volume_group_call_empty_device_finish ( UDisksVolumeGroup *proxy, GAsyncResult *res, GError **error); gboolean udisks_volume_group_call_empty_device_sync ( UDisksVolumeGroup *proxy, const gchar *arg_block, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_volume_group_call_remove_device ( UDisksVolumeGroup *proxy, const gchar *arg_block, gboolean arg_wipe, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_volume_group_call_remove_device_finish ( UDisksVolumeGroup *proxy, GAsyncResult *res, GError **error); gboolean udisks_volume_group_call_remove_device_sync ( UDisksVolumeGroup *proxy, const gchar *arg_block, gboolean arg_wipe, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_volume_group_call_remove_missing_physical_volumes ( UDisksVolumeGroup *proxy, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_volume_group_call_remove_missing_physical_volumes_finish ( UDisksVolumeGroup *proxy, GAsyncResult *res, GError **error); gboolean udisks_volume_group_call_remove_missing_physical_volumes_sync ( UDisksVolumeGroup *proxy, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_volume_group_call_create_plain_volume ( UDisksVolumeGroup *proxy, const gchar *arg_name, guint64 arg_size, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_volume_group_call_create_plain_volume_finish ( UDisksVolumeGroup *proxy, gchar ** out_result, GAsyncResult *res, GError **error); gboolean udisks_volume_group_call_create_plain_volume_sync ( UDisksVolumeGroup *proxy, const gchar *arg_name, guint64 arg_size, GVariant *arg_options, gchar ** out_result, GCancellable *cancellable, GError **error); void udisks_volume_group_call_create_plain_volume_with_layout ( UDisksVolumeGroup *proxy, const gchar *arg_name, guint64 arg_size, const gchar *arg_layout, const gchar *const *arg_pvs, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_volume_group_call_create_plain_volume_with_layout_finish ( UDisksVolumeGroup *proxy, gchar ** out_result, GAsyncResult *res, GError **error); gboolean udisks_volume_group_call_create_plain_volume_with_layout_sync ( UDisksVolumeGroup *proxy, const gchar *arg_name, guint64 arg_size, const gchar *arg_layout, const gchar *const *arg_pvs, GVariant *arg_options, gchar ** out_result, GCancellable *cancellable, GError **error); void udisks_volume_group_call_create_thin_pool_volume ( UDisksVolumeGroup *proxy, const gchar *arg_name, guint64 arg_size, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_volume_group_call_create_thin_pool_volume_finish ( UDisksVolumeGroup *proxy, gchar ** out_result, GAsyncResult *res, GError **error); gboolean udisks_volume_group_call_create_thin_pool_volume_sync ( UDisksVolumeGroup *proxy, const gchar *arg_name, guint64 arg_size, GVariant *arg_options, gchar ** out_result, GCancellable *cancellable, GError **error); void udisks_volume_group_call_create_thin_volume ( UDisksVolumeGroup *proxy, const gchar *arg_name, guint64 arg_size, const gchar *arg_pool, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_volume_group_call_create_thin_volume_finish ( UDisksVolumeGroup *proxy, gchar ** out_result, GAsyncResult *res, GError **error); gboolean udisks_volume_group_call_create_thin_volume_sync ( UDisksVolumeGroup *proxy, const gchar *arg_name, guint64 arg_size, const gchar *arg_pool, GVariant *arg_options, gchar ** out_result, GCancellable *cancellable, GError **error); void udisks_volume_group_call_create_vdo_volume ( UDisksVolumeGroup *proxy, const gchar *arg_lv_name, const gchar *arg_pool_name, guint64 arg_data_size, guint64 arg_virtual_size, guint64 arg_index_memory, gboolean arg_compression, gboolean arg_deduplication, const gchar *arg_write_policy, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_volume_group_call_create_vdo_volume_finish ( UDisksVolumeGroup *proxy, gchar ** out_result, GAsyncResult *res, GError **error); gboolean udisks_volume_group_call_create_vdo_volume_sync ( UDisksVolumeGroup *proxy, const gchar *arg_lv_name, const gchar *arg_pool_name, guint64 arg_data_size, guint64 arg_virtual_size, guint64 arg_index_memory, gboolean arg_compression, gboolean arg_deduplication, const gchar *arg_write_policy, GVariant *arg_options, gchar ** out_result, GCancellable *cancellable, GError **error); /* D-Bus property accessors: */ const gchar *udisks_volume_group_get_name (UDisksVolumeGroup *object); gchar *udisks_volume_group_dup_name (UDisksVolumeGroup *object); void udisks_volume_group_set_name (UDisksVolumeGroup *object, const gchar *value); const gchar *udisks_volume_group_get_uuid (UDisksVolumeGroup *object); gchar *udisks_volume_group_dup_uuid (UDisksVolumeGroup *object); void udisks_volume_group_set_uuid (UDisksVolumeGroup *object, const gchar *value); guint64 udisks_volume_group_get_size (UDisksVolumeGroup *object); void udisks_volume_group_set_size (UDisksVolumeGroup *object, guint64 value); guint64 udisks_volume_group_get_free_size (UDisksVolumeGroup *object); void udisks_volume_group_set_free_size (UDisksVolumeGroup *object, guint64 value); guint64 udisks_volume_group_get_extent_size (UDisksVolumeGroup *object); void udisks_volume_group_set_extent_size (UDisksVolumeGroup *object, guint64 value); gboolean udisks_volume_group_get_needs_polling (UDisksVolumeGroup *object); void udisks_volume_group_set_needs_polling (UDisksVolumeGroup *object, gboolean value); const gchar *const *udisks_volume_group_get_missing_physical_volumes (UDisksVolumeGroup *object); gchar **udisks_volume_group_dup_missing_physical_volumes (UDisksVolumeGroup *object); void udisks_volume_group_set_missing_physical_volumes (UDisksVolumeGroup *object, const gchar *const *value); /* ---- */ #define UDISKS_TYPE_VOLUME_GROUP_PROXY (udisks_volume_group_proxy_get_type ()) #define UDISKS_VOLUME_GROUP_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_VOLUME_GROUP_PROXY, UDisksVolumeGroupProxy)) #define UDISKS_VOLUME_GROUP_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UDISKS_TYPE_VOLUME_GROUP_PROXY, UDisksVolumeGroupProxyClass)) #define UDISKS_VOLUME_GROUP_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UDISKS_TYPE_VOLUME_GROUP_PROXY, UDisksVolumeGroupProxyClass)) #define UDISKS_IS_VOLUME_GROUP_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_VOLUME_GROUP_PROXY)) #define UDISKS_IS_VOLUME_GROUP_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UDISKS_TYPE_VOLUME_GROUP_PROXY)) typedef struct _UDisksVolumeGroupProxy UDisksVolumeGroupProxy; typedef struct _UDisksVolumeGroupProxyClass UDisksVolumeGroupProxyClass; typedef struct _UDisksVolumeGroupProxyPrivate UDisksVolumeGroupProxyPrivate; struct _UDisksVolumeGroupProxy { /*< private >*/ GDBusProxy parent_instance; UDisksVolumeGroupProxyPrivate *priv; }; struct _UDisksVolumeGroupProxyClass { GDBusProxyClass parent_class; }; GType udisks_volume_group_proxy_get_type (void); #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksVolumeGroupProxy, g_object_unref) #endif void udisks_volume_group_proxy_new ( GDBusConnection *connection, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); UDisksVolumeGroup *udisks_volume_group_proxy_new_finish ( GAsyncResult *res, GError **error); UDisksVolumeGroup *udisks_volume_group_proxy_new_sync ( GDBusConnection *connection, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GError **error); void udisks_volume_group_proxy_new_for_bus ( GBusType bus_type, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); UDisksVolumeGroup *udisks_volume_group_proxy_new_for_bus_finish ( GAsyncResult *res, GError **error); UDisksVolumeGroup *udisks_volume_group_proxy_new_for_bus_sync ( GBusType bus_type, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GError **error); /* ---- */ #define UDISKS_TYPE_VOLUME_GROUP_SKELETON (udisks_volume_group_skeleton_get_type ()) #define UDISKS_VOLUME_GROUP_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_VOLUME_GROUP_SKELETON, UDisksVolumeGroupSkeleton)) #define UDISKS_VOLUME_GROUP_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UDISKS_TYPE_VOLUME_GROUP_SKELETON, UDisksVolumeGroupSkeletonClass)) #define UDISKS_VOLUME_GROUP_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UDISKS_TYPE_VOLUME_GROUP_SKELETON, UDisksVolumeGroupSkeletonClass)) #define UDISKS_IS_VOLUME_GROUP_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_VOLUME_GROUP_SKELETON)) #define UDISKS_IS_VOLUME_GROUP_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UDISKS_TYPE_VOLUME_GROUP_SKELETON)) typedef struct _UDisksVolumeGroupSkeleton UDisksVolumeGroupSkeleton; typedef struct _UDisksVolumeGroupSkeletonClass UDisksVolumeGroupSkeletonClass; typedef struct _UDisksVolumeGroupSkeletonPrivate UDisksVolumeGroupSkeletonPrivate; struct _UDisksVolumeGroupSkeleton { /*< private >*/ GDBusInterfaceSkeleton parent_instance; UDisksVolumeGroupSkeletonPrivate *priv; }; struct _UDisksVolumeGroupSkeletonClass { GDBusInterfaceSkeletonClass parent_class; }; GType udisks_volume_group_skeleton_get_type (void); #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksVolumeGroupSkeleton, g_object_unref) #endif UDisksVolumeGroup *udisks_volume_group_skeleton_new (void); /* ------------------------------------------------------------------------ */ /* Declarations for org.freedesktop.UDisks2.LogicalVolume */ #define UDISKS_TYPE_LOGICAL_VOLUME (udisks_logical_volume_get_type ()) #define UDISKS_LOGICAL_VOLUME(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_LOGICAL_VOLUME, UDisksLogicalVolume)) #define UDISKS_IS_LOGICAL_VOLUME(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_LOGICAL_VOLUME)) #define UDISKS_LOGICAL_VOLUME_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), UDISKS_TYPE_LOGICAL_VOLUME, UDisksLogicalVolumeIface)) struct _UDisksLogicalVolume; typedef struct _UDisksLogicalVolume UDisksLogicalVolume; typedef struct _UDisksLogicalVolumeIface UDisksLogicalVolumeIface; struct _UDisksLogicalVolumeIface { GTypeInterface parent_iface; gboolean (*handle_activate) ( UDisksLogicalVolume *object, GDBusMethodInvocation *invocation, GVariant *arg_options); gboolean (*handle_cache_attach) ( UDisksLogicalVolume *object, GDBusMethodInvocation *invocation, const gchar *arg_cache_name, GVariant *arg_options); gboolean (*handle_cache_detach) ( UDisksLogicalVolume *object, GDBusMethodInvocation *invocation, GVariant *arg_options); gboolean (*handle_cache_split) ( UDisksLogicalVolume *object, GDBusMethodInvocation *invocation, GVariant *arg_options); gboolean (*handle_create_snapshot) ( UDisksLogicalVolume *object, GDBusMethodInvocation *invocation, const gchar *arg_name, guint64 arg_size, GVariant *arg_options); gboolean (*handle_deactivate) ( UDisksLogicalVolume *object, GDBusMethodInvocation *invocation, GVariant *arg_options); gboolean (*handle_delete) ( UDisksLogicalVolume *object, GDBusMethodInvocation *invocation, GVariant *arg_options); gboolean (*handle_rename) ( UDisksLogicalVolume *object, GDBusMethodInvocation *invocation, const gchar *arg_new_name, GVariant *arg_options); gboolean (*handle_repair) ( UDisksLogicalVolume *object, GDBusMethodInvocation *invocation, const gchar *const *arg_pvs, GVariant *arg_options); gboolean (*handle_resize) ( UDisksLogicalVolume *object, GDBusMethodInvocation *invocation, guint64 arg_new_size, GVariant *arg_options); gboolean (*get_active) (UDisksLogicalVolume *object); const gchar * (*get_block_device) (UDisksLogicalVolume *object); GVariant * (*get_child_configuration) (UDisksLogicalVolume *object); gdouble (*get_data_allocated_ratio) (UDisksLogicalVolume *object); const gchar * (*get_layout) (UDisksLogicalVolume *object); gdouble (*get_metadata_allocated_ratio) (UDisksLogicalVolume *object); const gchar * (*get_name) (UDisksLogicalVolume *object); const gchar * (*get_origin) (UDisksLogicalVolume *object); guint64 (*get_size) (UDisksLogicalVolume *object); GVariant * (*get_structure) (UDisksLogicalVolume *object); gdouble (*get_sync_ratio) (UDisksLogicalVolume *object); const gchar * (*get_thin_pool) (UDisksLogicalVolume *object); const gchar * (*get_type_) (UDisksLogicalVolume *object); const gchar * (*get_uuid) (UDisksLogicalVolume *object); const gchar * (*get_volume_group) (UDisksLogicalVolume *object); }; #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksLogicalVolume, g_object_unref) #endif GType udisks_logical_volume_get_type (void); GDBusInterfaceInfo *udisks_logical_volume_interface_info (void); guint udisks_logical_volume_override_properties (GObjectClass *klass, guint property_id_begin); /* D-Bus method call completion functions: */ void udisks_logical_volume_complete_activate ( UDisksLogicalVolume *object, GDBusMethodInvocation *invocation, const gchar *result); void udisks_logical_volume_complete_deactivate ( UDisksLogicalVolume *object, GDBusMethodInvocation *invocation); void udisks_logical_volume_complete_delete ( UDisksLogicalVolume *object, GDBusMethodInvocation *invocation); void udisks_logical_volume_complete_rename ( UDisksLogicalVolume *object, GDBusMethodInvocation *invocation, const gchar *result); void udisks_logical_volume_complete_resize ( UDisksLogicalVolume *object, GDBusMethodInvocation *invocation); void udisks_logical_volume_complete_repair ( UDisksLogicalVolume *object, GDBusMethodInvocation *invocation); void udisks_logical_volume_complete_create_snapshot ( UDisksLogicalVolume *object, GDBusMethodInvocation *invocation, const gchar *result); void udisks_logical_volume_complete_cache_attach ( UDisksLogicalVolume *object, GDBusMethodInvocation *invocation); void udisks_logical_volume_complete_cache_split ( UDisksLogicalVolume *object, GDBusMethodInvocation *invocation); void udisks_logical_volume_complete_cache_detach ( UDisksLogicalVolume *object, GDBusMethodInvocation *invocation); /* D-Bus method calls: */ void udisks_logical_volume_call_activate ( UDisksLogicalVolume *proxy, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_logical_volume_call_activate_finish ( UDisksLogicalVolume *proxy, gchar ** out_result, GAsyncResult *res, GError **error); gboolean udisks_logical_volume_call_activate_sync ( UDisksLogicalVolume *proxy, GVariant *arg_options, gchar ** out_result, GCancellable *cancellable, GError **error); void udisks_logical_volume_call_deactivate ( UDisksLogicalVolume *proxy, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_logical_volume_call_deactivate_finish ( UDisksLogicalVolume *proxy, GAsyncResult *res, GError **error); gboolean udisks_logical_volume_call_deactivate_sync ( UDisksLogicalVolume *proxy, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_logical_volume_call_delete ( UDisksLogicalVolume *proxy, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_logical_volume_call_delete_finish ( UDisksLogicalVolume *proxy, GAsyncResult *res, GError **error); gboolean udisks_logical_volume_call_delete_sync ( UDisksLogicalVolume *proxy, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_logical_volume_call_rename ( UDisksLogicalVolume *proxy, const gchar *arg_new_name, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_logical_volume_call_rename_finish ( UDisksLogicalVolume *proxy, gchar ** out_result, GAsyncResult *res, GError **error); gboolean udisks_logical_volume_call_rename_sync ( UDisksLogicalVolume *proxy, const gchar *arg_new_name, GVariant *arg_options, gchar ** out_result, GCancellable *cancellable, GError **error); void udisks_logical_volume_call_resize ( UDisksLogicalVolume *proxy, guint64 arg_new_size, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_logical_volume_call_resize_finish ( UDisksLogicalVolume *proxy, GAsyncResult *res, GError **error); gboolean udisks_logical_volume_call_resize_sync ( UDisksLogicalVolume *proxy, guint64 arg_new_size, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_logical_volume_call_repair ( UDisksLogicalVolume *proxy, const gchar *const *arg_pvs, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_logical_volume_call_repair_finish ( UDisksLogicalVolume *proxy, GAsyncResult *res, GError **error); gboolean udisks_logical_volume_call_repair_sync ( UDisksLogicalVolume *proxy, const gchar *const *arg_pvs, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_logical_volume_call_create_snapshot ( UDisksLogicalVolume *proxy, const gchar *arg_name, guint64 arg_size, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_logical_volume_call_create_snapshot_finish ( UDisksLogicalVolume *proxy, gchar ** out_result, GAsyncResult *res, GError **error); gboolean udisks_logical_volume_call_create_snapshot_sync ( UDisksLogicalVolume *proxy, const gchar *arg_name, guint64 arg_size, GVariant *arg_options, gchar ** out_result, GCancellable *cancellable, GError **error); void udisks_logical_volume_call_cache_attach ( UDisksLogicalVolume *proxy, const gchar *arg_cache_name, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_logical_volume_call_cache_attach_finish ( UDisksLogicalVolume *proxy, GAsyncResult *res, GError **error); gboolean udisks_logical_volume_call_cache_attach_sync ( UDisksLogicalVolume *proxy, const gchar *arg_cache_name, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_logical_volume_call_cache_split ( UDisksLogicalVolume *proxy, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_logical_volume_call_cache_split_finish ( UDisksLogicalVolume *proxy, GAsyncResult *res, GError **error); gboolean udisks_logical_volume_call_cache_split_sync ( UDisksLogicalVolume *proxy, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_logical_volume_call_cache_detach ( UDisksLogicalVolume *proxy, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_logical_volume_call_cache_detach_finish ( UDisksLogicalVolume *proxy, GAsyncResult *res, GError **error); gboolean udisks_logical_volume_call_cache_detach_sync ( UDisksLogicalVolume *proxy, GVariant *arg_options, GCancellable *cancellable, GError **error); /* D-Bus property accessors: */ const gchar *udisks_logical_volume_get_volume_group (UDisksLogicalVolume *object); gchar *udisks_logical_volume_dup_volume_group (UDisksLogicalVolume *object); void udisks_logical_volume_set_volume_group (UDisksLogicalVolume *object, const gchar *value); const gchar *udisks_logical_volume_get_name (UDisksLogicalVolume *object); gchar *udisks_logical_volume_dup_name (UDisksLogicalVolume *object); void udisks_logical_volume_set_name (UDisksLogicalVolume *object, const gchar *value); gboolean udisks_logical_volume_get_active (UDisksLogicalVolume *object); void udisks_logical_volume_set_active (UDisksLogicalVolume *object, gboolean value); const gchar *udisks_logical_volume_get_uuid (UDisksLogicalVolume *object); gchar *udisks_logical_volume_dup_uuid (UDisksLogicalVolume *object); void udisks_logical_volume_set_uuid (UDisksLogicalVolume *object, const gchar *value); guint64 udisks_logical_volume_get_size (UDisksLogicalVolume *object); void udisks_logical_volume_set_size (UDisksLogicalVolume *object, guint64 value); gdouble udisks_logical_volume_get_data_allocated_ratio (UDisksLogicalVolume *object); void udisks_logical_volume_set_data_allocated_ratio (UDisksLogicalVolume *object, gdouble value); gdouble udisks_logical_volume_get_metadata_allocated_ratio (UDisksLogicalVolume *object); void udisks_logical_volume_set_metadata_allocated_ratio (UDisksLogicalVolume *object, gdouble value); const gchar *udisks_logical_volume_get_type_ (UDisksLogicalVolume *object); gchar *udisks_logical_volume_dup_type_ (UDisksLogicalVolume *object); void udisks_logical_volume_set_type_ (UDisksLogicalVolume *object, const gchar *value); const gchar *udisks_logical_volume_get_layout (UDisksLogicalVolume *object); gchar *udisks_logical_volume_dup_layout (UDisksLogicalVolume *object); void udisks_logical_volume_set_layout (UDisksLogicalVolume *object, const gchar *value); GVariant *udisks_logical_volume_get_structure (UDisksLogicalVolume *object); GVariant *udisks_logical_volume_dup_structure (UDisksLogicalVolume *object); void udisks_logical_volume_set_structure (UDisksLogicalVolume *object, GVariant *value); gdouble udisks_logical_volume_get_sync_ratio (UDisksLogicalVolume *object); void udisks_logical_volume_set_sync_ratio (UDisksLogicalVolume *object, gdouble value); const gchar *udisks_logical_volume_get_thin_pool (UDisksLogicalVolume *object); gchar *udisks_logical_volume_dup_thin_pool (UDisksLogicalVolume *object); void udisks_logical_volume_set_thin_pool (UDisksLogicalVolume *object, const gchar *value); const gchar *udisks_logical_volume_get_origin (UDisksLogicalVolume *object); gchar *udisks_logical_volume_dup_origin (UDisksLogicalVolume *object); void udisks_logical_volume_set_origin (UDisksLogicalVolume *object, const gchar *value); GVariant *udisks_logical_volume_get_child_configuration (UDisksLogicalVolume *object); GVariant *udisks_logical_volume_dup_child_configuration (UDisksLogicalVolume *object); void udisks_logical_volume_set_child_configuration (UDisksLogicalVolume *object, GVariant *value); const gchar *udisks_logical_volume_get_block_device (UDisksLogicalVolume *object); gchar *udisks_logical_volume_dup_block_device (UDisksLogicalVolume *object); void udisks_logical_volume_set_block_device (UDisksLogicalVolume *object, const gchar *value); /* ---- */ #define UDISKS_TYPE_LOGICAL_VOLUME_PROXY (udisks_logical_volume_proxy_get_type ()) #define UDISKS_LOGICAL_VOLUME_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_LOGICAL_VOLUME_PROXY, UDisksLogicalVolumeProxy)) #define UDISKS_LOGICAL_VOLUME_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UDISKS_TYPE_LOGICAL_VOLUME_PROXY, UDisksLogicalVolumeProxyClass)) #define UDISKS_LOGICAL_VOLUME_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UDISKS_TYPE_LOGICAL_VOLUME_PROXY, UDisksLogicalVolumeProxyClass)) #define UDISKS_IS_LOGICAL_VOLUME_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_LOGICAL_VOLUME_PROXY)) #define UDISKS_IS_LOGICAL_VOLUME_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UDISKS_TYPE_LOGICAL_VOLUME_PROXY)) typedef struct _UDisksLogicalVolumeProxy UDisksLogicalVolumeProxy; typedef struct _UDisksLogicalVolumeProxyClass UDisksLogicalVolumeProxyClass; typedef struct _UDisksLogicalVolumeProxyPrivate UDisksLogicalVolumeProxyPrivate; struct _UDisksLogicalVolumeProxy { /*< private >*/ GDBusProxy parent_instance; UDisksLogicalVolumeProxyPrivate *priv; }; struct _UDisksLogicalVolumeProxyClass { GDBusProxyClass parent_class; }; GType udisks_logical_volume_proxy_get_type (void); #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksLogicalVolumeProxy, g_object_unref) #endif void udisks_logical_volume_proxy_new ( GDBusConnection *connection, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); UDisksLogicalVolume *udisks_logical_volume_proxy_new_finish ( GAsyncResult *res, GError **error); UDisksLogicalVolume *udisks_logical_volume_proxy_new_sync ( GDBusConnection *connection, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GError **error); void udisks_logical_volume_proxy_new_for_bus ( GBusType bus_type, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); UDisksLogicalVolume *udisks_logical_volume_proxy_new_for_bus_finish ( GAsyncResult *res, GError **error); UDisksLogicalVolume *udisks_logical_volume_proxy_new_for_bus_sync ( GBusType bus_type, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GError **error); /* ---- */ #define UDISKS_TYPE_LOGICAL_VOLUME_SKELETON (udisks_logical_volume_skeleton_get_type ()) #define UDISKS_LOGICAL_VOLUME_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_LOGICAL_VOLUME_SKELETON, UDisksLogicalVolumeSkeleton)) #define UDISKS_LOGICAL_VOLUME_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UDISKS_TYPE_LOGICAL_VOLUME_SKELETON, UDisksLogicalVolumeSkeletonClass)) #define UDISKS_LOGICAL_VOLUME_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UDISKS_TYPE_LOGICAL_VOLUME_SKELETON, UDisksLogicalVolumeSkeletonClass)) #define UDISKS_IS_LOGICAL_VOLUME_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_LOGICAL_VOLUME_SKELETON)) #define UDISKS_IS_LOGICAL_VOLUME_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UDISKS_TYPE_LOGICAL_VOLUME_SKELETON)) typedef struct _UDisksLogicalVolumeSkeleton UDisksLogicalVolumeSkeleton; typedef struct _UDisksLogicalVolumeSkeletonClass UDisksLogicalVolumeSkeletonClass; typedef struct _UDisksLogicalVolumeSkeletonPrivate UDisksLogicalVolumeSkeletonPrivate; struct _UDisksLogicalVolumeSkeleton { /*< private >*/ GDBusInterfaceSkeleton parent_instance; UDisksLogicalVolumeSkeletonPrivate *priv; }; struct _UDisksLogicalVolumeSkeletonClass { GDBusInterfaceSkeletonClass parent_class; }; GType udisks_logical_volume_skeleton_get_type (void); #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksLogicalVolumeSkeleton, g_object_unref) #endif UDisksLogicalVolume *udisks_logical_volume_skeleton_new (void); /* ------------------------------------------------------------------------ */ /* Declarations for org.freedesktop.UDisks2.VDOVolume */ #define UDISKS_TYPE_VDO_VOLUME (udisks_vdo_volume_get_type ()) #define UDISKS_VDO_VOLUME(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_VDO_VOLUME, UDisksVDOVolume)) #define UDISKS_IS_VDO_VOLUME(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_VDO_VOLUME)) #define UDISKS_VDO_VOLUME_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), UDISKS_TYPE_VDO_VOLUME, UDisksVDOVolumeIface)) struct _UDisksVDOVolume; typedef struct _UDisksVDOVolume UDisksVDOVolume; typedef struct _UDisksVDOVolumeIface UDisksVDOVolumeIface; struct _UDisksVDOVolumeIface { GTypeInterface parent_iface; gboolean (*handle_enable_compression) ( UDisksVDOVolume *object, GDBusMethodInvocation *invocation, gboolean arg_enable, GVariant *arg_options); gboolean (*handle_enable_deduplication) ( UDisksVDOVolume *object, GDBusMethodInvocation *invocation, gboolean arg_enable, GVariant *arg_options); gboolean (*handle_get_statistics) ( UDisksVDOVolume *object, GDBusMethodInvocation *invocation, GVariant *arg_options); gboolean (*handle_resize_logical) ( UDisksVDOVolume *object, GDBusMethodInvocation *invocation, guint64 arg_size, GVariant *arg_options); gboolean (*handle_resize_physical) ( UDisksVDOVolume *object, GDBusMethodInvocation *invocation, guint64 arg_size, GVariant *arg_options); gboolean (*get_compression) (UDisksVDOVolume *object); const gchar * (*get_compression_state) (UDisksVDOVolume *object); gboolean (*get_deduplication) (UDisksVDOVolume *object); const gchar * (*get_index_state) (UDisksVDOVolume *object); const gchar * (*get_operating_mode) (UDisksVDOVolume *object); guint64 (*get_used_size) (UDisksVDOVolume *object); const gchar * (*get_vdo_pool) (UDisksVDOVolume *object); }; #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksVDOVolume, g_object_unref) #endif GType udisks_vdo_volume_get_type (void); GDBusInterfaceInfo *udisks_vdo_volume_interface_info (void); guint udisks_vdo_volume_override_properties (GObjectClass *klass, guint property_id_begin); /* D-Bus method call completion functions: */ void udisks_vdo_volume_complete_enable_compression ( UDisksVDOVolume *object, GDBusMethodInvocation *invocation); void udisks_vdo_volume_complete_enable_deduplication ( UDisksVDOVolume *object, GDBusMethodInvocation *invocation); void udisks_vdo_volume_complete_resize_logical ( UDisksVDOVolume *object, GDBusMethodInvocation *invocation); void udisks_vdo_volume_complete_resize_physical ( UDisksVDOVolume *object, GDBusMethodInvocation *invocation); void udisks_vdo_volume_complete_get_statistics ( UDisksVDOVolume *object, GDBusMethodInvocation *invocation, GVariant *stats); /* D-Bus method calls: */ void udisks_vdo_volume_call_enable_compression ( UDisksVDOVolume *proxy, gboolean arg_enable, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_vdo_volume_call_enable_compression_finish ( UDisksVDOVolume *proxy, GAsyncResult *res, GError **error); gboolean udisks_vdo_volume_call_enable_compression_sync ( UDisksVDOVolume *proxy, gboolean arg_enable, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_vdo_volume_call_enable_deduplication ( UDisksVDOVolume *proxy, gboolean arg_enable, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_vdo_volume_call_enable_deduplication_finish ( UDisksVDOVolume *proxy, GAsyncResult *res, GError **error); gboolean udisks_vdo_volume_call_enable_deduplication_sync ( UDisksVDOVolume *proxy, gboolean arg_enable, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_vdo_volume_call_resize_logical ( UDisksVDOVolume *proxy, guint64 arg_size, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_vdo_volume_call_resize_logical_finish ( UDisksVDOVolume *proxy, GAsyncResult *res, GError **error); gboolean udisks_vdo_volume_call_resize_logical_sync ( UDisksVDOVolume *proxy, guint64 arg_size, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_vdo_volume_call_resize_physical ( UDisksVDOVolume *proxy, guint64 arg_size, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_vdo_volume_call_resize_physical_finish ( UDisksVDOVolume *proxy, GAsyncResult *res, GError **error); gboolean udisks_vdo_volume_call_resize_physical_sync ( UDisksVDOVolume *proxy, guint64 arg_size, GVariant *arg_options, GCancellable *cancellable, GError **error); void udisks_vdo_volume_call_get_statistics ( UDisksVDOVolume *proxy, GVariant *arg_options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); gboolean udisks_vdo_volume_call_get_statistics_finish ( UDisksVDOVolume *proxy, GVariant ** out_stats, GAsyncResult *res, GError **error); gboolean udisks_vdo_volume_call_get_statistics_sync ( UDisksVDOVolume *proxy, GVariant *arg_options, GVariant ** out_stats, GCancellable *cancellable, GError **error); /* D-Bus property accessors: */ const gchar *udisks_vdo_volume_get_vdo_pool (UDisksVDOVolume *object); gchar *udisks_vdo_volume_dup_vdo_pool (UDisksVDOVolume *object); void udisks_vdo_volume_set_vdo_pool (UDisksVDOVolume *object, const gchar *value); const gchar *udisks_vdo_volume_get_operating_mode (UDisksVDOVolume *object); gchar *udisks_vdo_volume_dup_operating_mode (UDisksVDOVolume *object); void udisks_vdo_volume_set_operating_mode (UDisksVDOVolume *object, const gchar *value); const gchar *udisks_vdo_volume_get_compression_state (UDisksVDOVolume *object); gchar *udisks_vdo_volume_dup_compression_state (UDisksVDOVolume *object); void udisks_vdo_volume_set_compression_state (UDisksVDOVolume *object, const gchar *value); const gchar *udisks_vdo_volume_get_index_state (UDisksVDOVolume *object); gchar *udisks_vdo_volume_dup_index_state (UDisksVDOVolume *object); void udisks_vdo_volume_set_index_state (UDisksVDOVolume *object, const gchar *value); guint64 udisks_vdo_volume_get_used_size (UDisksVDOVolume *object); void udisks_vdo_volume_set_used_size (UDisksVDOVolume *object, guint64 value); gboolean udisks_vdo_volume_get_compression (UDisksVDOVolume *object); void udisks_vdo_volume_set_compression (UDisksVDOVolume *object, gboolean value); gboolean udisks_vdo_volume_get_deduplication (UDisksVDOVolume *object); void udisks_vdo_volume_set_deduplication (UDisksVDOVolume *object, gboolean value); /* ---- */ #define UDISKS_TYPE_VDO_VOLUME_PROXY (udisks_vdo_volume_proxy_get_type ()) #define UDISKS_VDO_VOLUME_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_VDO_VOLUME_PROXY, UDisksVDOVolumeProxy)) #define UDISKS_VDO_VOLUME_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UDISKS_TYPE_VDO_VOLUME_PROXY, UDisksVDOVolumeProxyClass)) #define UDISKS_VDO_VOLUME_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UDISKS_TYPE_VDO_VOLUME_PROXY, UDisksVDOVolumeProxyClass)) #define UDISKS_IS_VDO_VOLUME_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_VDO_VOLUME_PROXY)) #define UDISKS_IS_VDO_VOLUME_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UDISKS_TYPE_VDO_VOLUME_PROXY)) typedef struct _UDisksVDOVolumeProxy UDisksVDOVolumeProxy; typedef struct _UDisksVDOVolumeProxyClass UDisksVDOVolumeProxyClass; typedef struct _UDisksVDOVolumeProxyPrivate UDisksVDOVolumeProxyPrivate; struct _UDisksVDOVolumeProxy { /*< private >*/ GDBusProxy parent_instance; UDisksVDOVolumeProxyPrivate *priv; }; struct _UDisksVDOVolumeProxyClass { GDBusProxyClass parent_class; }; GType udisks_vdo_volume_proxy_get_type (void); #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksVDOVolumeProxy, g_object_unref) #endif void udisks_vdo_volume_proxy_new ( GDBusConnection *connection, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); UDisksVDOVolume *udisks_vdo_volume_proxy_new_finish ( GAsyncResult *res, GError **error); UDisksVDOVolume *udisks_vdo_volume_proxy_new_sync ( GDBusConnection *connection, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GError **error); void udisks_vdo_volume_proxy_new_for_bus ( GBusType bus_type, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); UDisksVDOVolume *udisks_vdo_volume_proxy_new_for_bus_finish ( GAsyncResult *res, GError **error); UDisksVDOVolume *udisks_vdo_volume_proxy_new_for_bus_sync ( GBusType bus_type, GDBusProxyFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GError **error); /* ---- */ #define UDISKS_TYPE_VDO_VOLUME_SKELETON (udisks_vdo_volume_skeleton_get_type ()) #define UDISKS_VDO_VOLUME_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_VDO_VOLUME_SKELETON, UDisksVDOVolumeSkeleton)) #define UDISKS_VDO_VOLUME_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UDISKS_TYPE_VDO_VOLUME_SKELETON, UDisksVDOVolumeSkeletonClass)) #define UDISKS_VDO_VOLUME_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UDISKS_TYPE_VDO_VOLUME_SKELETON, UDisksVDOVolumeSkeletonClass)) #define UDISKS_IS_VDO_VOLUME_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_VDO_VOLUME_SKELETON)) #define UDISKS_IS_VDO_VOLUME_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UDISKS_TYPE_VDO_VOLUME_SKELETON)) typedef struct _UDisksVDOVolumeSkeleton UDisksVDOVolumeSkeleton; typedef struct _UDisksVDOVolumeSkeletonClass UDisksVDOVolumeSkeletonClass; typedef struct _UDisksVDOVolumeSkeletonPrivate UDisksVDOVolumeSkeletonPrivate; struct _UDisksVDOVolumeSkeleton { /*< private >*/ GDBusInterfaceSkeleton parent_instance; UDisksVDOVolumeSkeletonPrivate *priv; }; struct _UDisksVDOVolumeSkeletonClass { GDBusInterfaceSkeletonClass parent_class; }; GType udisks_vdo_volume_skeleton_get_type (void); #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksVDOVolumeSkeleton, g_object_unref) #endif UDisksVDOVolume *udisks_vdo_volume_skeleton_new (void); /* ---- */ #define UDISKS_TYPE_OBJECT (udisks_object_get_type ()) #define UDISKS_OBJECT(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_OBJECT, UDisksObject)) #define UDISKS_IS_OBJECT(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_OBJECT)) #define UDISKS_OBJECT_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), UDISKS_TYPE_OBJECT, UDisksObject)) struct _UDisksObject; typedef struct _UDisksObject UDisksObject; typedef struct _UDisksObjectIface UDisksObjectIface; struct _UDisksObjectIface { GTypeInterface parent_iface; }; GType udisks_object_get_type (void); #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksObject, g_object_unref) #endif UDisksManager *udisks_object_get_manager (UDisksObject *object); UDisksManagerNVMe *udisks_object_get_manager_nvme (UDisksObject *object); UDisksDrive *udisks_object_get_drive (UDisksObject *object); UDisksDriveAta *udisks_object_get_drive_ata (UDisksObject *object); UDisksNVMeController *udisks_object_get_nvme_controller (UDisksObject *object); UDisksNVMeNamespace *udisks_object_get_nvme_namespace (UDisksObject *object); UDisksNVMeFabrics *udisks_object_get_nvme_fabrics (UDisksObject *object); UDisksBlock *udisks_object_get_block (UDisksObject *object); UDisksPartitionTable *udisks_object_get_partition_table (UDisksObject *object); UDisksPartition *udisks_object_get_partition (UDisksObject *object); UDisksFilesystem *udisks_object_get_filesystem (UDisksObject *object); UDisksSwapspace *udisks_object_get_swapspace (UDisksObject *object); UDisksEncrypted *udisks_object_get_encrypted (UDisksObject *object); UDisksLoop *udisks_object_get_loop (UDisksObject *object); UDisksMDRaid *udisks_object_get_mdraid (UDisksObject *object); UDisksJob *udisks_object_get_job (UDisksObject *object); UDisksManagerBTRFS *udisks_object_get_manager_btrfs (UDisksObject *object); UDisksFilesystemBTRFS *udisks_object_get_filesystem_btrfs (UDisksObject *object); UDisksManagerLVM2 *udisks_object_get_manager_lvm2 (UDisksObject *object); UDisksBlockLVM2 *udisks_object_get_block_lvm2 (UDisksObject *object); UDisksPhysicalVolume *udisks_object_get_physical_volume (UDisksObject *object); UDisksVolumeGroup *udisks_object_get_volume_group (UDisksObject *object); UDisksLogicalVolume *udisks_object_get_logical_volume (UDisksObject *object); UDisksVDOVolume *udisks_object_get_vdo_volume (UDisksObject *object); UDisksManager *udisks_object_peek_manager (UDisksObject *object); UDisksManagerNVMe *udisks_object_peek_manager_nvme (UDisksObject *object); UDisksDrive *udisks_object_peek_drive (UDisksObject *object); UDisksDriveAta *udisks_object_peek_drive_ata (UDisksObject *object); UDisksNVMeController *udisks_object_peek_nvme_controller (UDisksObject *object); UDisksNVMeNamespace *udisks_object_peek_nvme_namespace (UDisksObject *object); UDisksNVMeFabrics *udisks_object_peek_nvme_fabrics (UDisksObject *object); UDisksBlock *udisks_object_peek_block (UDisksObject *object); UDisksPartitionTable *udisks_object_peek_partition_table (UDisksObject *object); UDisksPartition *udisks_object_peek_partition (UDisksObject *object); UDisksFilesystem *udisks_object_peek_filesystem (UDisksObject *object); UDisksSwapspace *udisks_object_peek_swapspace (UDisksObject *object); UDisksEncrypted *udisks_object_peek_encrypted (UDisksObject *object); UDisksLoop *udisks_object_peek_loop (UDisksObject *object); UDisksMDRaid *udisks_object_peek_mdraid (UDisksObject *object); UDisksJob *udisks_object_peek_job (UDisksObject *object); UDisksManagerBTRFS *udisks_object_peek_manager_btrfs (UDisksObject *object); UDisksFilesystemBTRFS *udisks_object_peek_filesystem_btrfs (UDisksObject *object); UDisksManagerLVM2 *udisks_object_peek_manager_lvm2 (UDisksObject *object); UDisksBlockLVM2 *udisks_object_peek_block_lvm2 (UDisksObject *object); UDisksPhysicalVolume *udisks_object_peek_physical_volume (UDisksObject *object); UDisksVolumeGroup *udisks_object_peek_volume_group (UDisksObject *object); UDisksLogicalVolume *udisks_object_peek_logical_volume (UDisksObject *object); UDisksVDOVolume *udisks_object_peek_vdo_volume (UDisksObject *object); #define UDISKS_TYPE_OBJECT_PROXY (udisks_object_proxy_get_type ()) #define UDISKS_OBJECT_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_OBJECT_PROXY, UDisksObjectProxy)) #define UDISKS_OBJECT_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UDISKS_TYPE_OBJECT_PROXY, UDisksObjectProxyClass)) #define UDISKS_OBJECT_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UDISKS_TYPE_OBJECT_PROXY, UDisksObjectProxyClass)) #define UDISKS_IS_OBJECT_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_OBJECT_PROXY)) #define UDISKS_IS_OBJECT_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UDISKS_TYPE_OBJECT_PROXY)) typedef struct _UDisksObjectProxy UDisksObjectProxy; typedef struct _UDisksObjectProxyClass UDisksObjectProxyClass; typedef struct _UDisksObjectProxyPrivate UDisksObjectProxyPrivate; struct _UDisksObjectProxy { /*< private >*/ GDBusObjectProxy parent_instance; UDisksObjectProxyPrivate *priv; }; struct _UDisksObjectProxyClass { GDBusObjectProxyClass parent_class; }; GType udisks_object_proxy_get_type (void); #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksObjectProxy, g_object_unref) #endif UDisksObjectProxy *udisks_object_proxy_new (GDBusConnection *connection, const gchar *object_path); #define UDISKS_TYPE_OBJECT_SKELETON (udisks_object_skeleton_get_type ()) #define UDISKS_OBJECT_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_OBJECT_SKELETON, UDisksObjectSkeleton)) #define UDISKS_OBJECT_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UDISKS_TYPE_OBJECT_SKELETON, UDisksObjectSkeletonClass)) #define UDISKS_OBJECT_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UDISKS_TYPE_OBJECT_SKELETON, UDisksObjectSkeletonClass)) #define UDISKS_IS_OBJECT_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_OBJECT_SKELETON)) #define UDISKS_IS_OBJECT_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UDISKS_TYPE_OBJECT_SKELETON)) typedef struct _UDisksObjectSkeleton UDisksObjectSkeleton; typedef struct _UDisksObjectSkeletonClass UDisksObjectSkeletonClass; typedef struct _UDisksObjectSkeletonPrivate UDisksObjectSkeletonPrivate; struct _UDisksObjectSkeleton { /*< private >*/ GDBusObjectSkeleton parent_instance; UDisksObjectSkeletonPrivate *priv; }; struct _UDisksObjectSkeletonClass { GDBusObjectSkeletonClass parent_class; }; GType udisks_object_skeleton_get_type (void); #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksObjectSkeleton, g_object_unref) #endif UDisksObjectSkeleton *udisks_object_skeleton_new (const gchar *object_path); void udisks_object_skeleton_set_manager (UDisksObjectSkeleton *object, UDisksManager *interface_); void udisks_object_skeleton_set_manager_nvme (UDisksObjectSkeleton *object, UDisksManagerNVMe *interface_); void udisks_object_skeleton_set_drive (UDisksObjectSkeleton *object, UDisksDrive *interface_); void udisks_object_skeleton_set_drive_ata (UDisksObjectSkeleton *object, UDisksDriveAta *interface_); void udisks_object_skeleton_set_nvme_controller (UDisksObjectSkeleton *object, UDisksNVMeController *interface_); void udisks_object_skeleton_set_nvme_namespace (UDisksObjectSkeleton *object, UDisksNVMeNamespace *interface_); void udisks_object_skeleton_set_nvme_fabrics (UDisksObjectSkeleton *object, UDisksNVMeFabrics *interface_); void udisks_object_skeleton_set_block (UDisksObjectSkeleton *object, UDisksBlock *interface_); void udisks_object_skeleton_set_partition_table (UDisksObjectSkeleton *object, UDisksPartitionTable *interface_); void udisks_object_skeleton_set_partition (UDisksObjectSkeleton *object, UDisksPartition *interface_); void udisks_object_skeleton_set_filesystem (UDisksObjectSkeleton *object, UDisksFilesystem *interface_); void udisks_object_skeleton_set_swapspace (UDisksObjectSkeleton *object, UDisksSwapspace *interface_); void udisks_object_skeleton_set_encrypted (UDisksObjectSkeleton *object, UDisksEncrypted *interface_); void udisks_object_skeleton_set_loop (UDisksObjectSkeleton *object, UDisksLoop *interface_); void udisks_object_skeleton_set_mdraid (UDisksObjectSkeleton *object, UDisksMDRaid *interface_); void udisks_object_skeleton_set_job (UDisksObjectSkeleton *object, UDisksJob *interface_); void udisks_object_skeleton_set_manager_btrfs (UDisksObjectSkeleton *object, UDisksManagerBTRFS *interface_); void udisks_object_skeleton_set_filesystem_btrfs (UDisksObjectSkeleton *object, UDisksFilesystemBTRFS *interface_); void udisks_object_skeleton_set_manager_lvm2 (UDisksObjectSkeleton *object, UDisksManagerLVM2 *interface_); void udisks_object_skeleton_set_block_lvm2 (UDisksObjectSkeleton *object, UDisksBlockLVM2 *interface_); void udisks_object_skeleton_set_physical_volume (UDisksObjectSkeleton *object, UDisksPhysicalVolume *interface_); void udisks_object_skeleton_set_volume_group (UDisksObjectSkeleton *object, UDisksVolumeGroup *interface_); void udisks_object_skeleton_set_logical_volume (UDisksObjectSkeleton *object, UDisksLogicalVolume *interface_); void udisks_object_skeleton_set_vdo_volume (UDisksObjectSkeleton *object, UDisksVDOVolume *interface_); /* ---- */ #define UDISKS_TYPE_OBJECT_MANAGER_CLIENT (udisks_object_manager_client_get_type ()) #define UDISKS_OBJECT_MANAGER_CLIENT(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_OBJECT_MANAGER_CLIENT, UDisksObjectManagerClient)) #define UDISKS_OBJECT_MANAGER_CLIENT_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), UDISKS_TYPE_OBJECT_MANAGER_CLIENT, UDisksObjectManagerClientClass)) #define UDISKS_OBJECT_MANAGER_CLIENT_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UDISKS_TYPE_OBJECT_MANAGER_CLIENT, UDisksObjectManagerClientClass)) #define UDISKS_IS_OBJECT_MANAGER_CLIENT(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_OBJECT_MANAGER_CLIENT)) #define UDISKS_IS_OBJECT_MANAGER_CLIENT_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UDISKS_TYPE_OBJECT_MANAGER_CLIENT)) typedef struct _UDisksObjectManagerClient UDisksObjectManagerClient; typedef struct _UDisksObjectManagerClientClass UDisksObjectManagerClientClass; typedef struct _UDisksObjectManagerClientPrivate UDisksObjectManagerClientPrivate; struct _UDisksObjectManagerClient { /*< private >*/ GDBusObjectManagerClient parent_instance; UDisksObjectManagerClientPrivate *priv; }; struct _UDisksObjectManagerClientClass { GDBusObjectManagerClientClass parent_class; }; #if GLIB_CHECK_VERSION(2, 44, 0) G_DEFINE_AUTOPTR_CLEANUP_FUNC (UDisksObjectManagerClient, g_object_unref) #endif GType udisks_object_manager_client_get_type (void); GType udisks_object_manager_client_get_proxy_type (GDBusObjectManagerClient *manager, const gchar *object_path, const gchar *interface_name, gpointer user_data); void udisks_object_manager_client_new ( GDBusConnection *connection, GDBusObjectManagerClientFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); GDBusObjectManager *udisks_object_manager_client_new_finish ( GAsyncResult *res, GError **error); GDBusObjectManager *udisks_object_manager_client_new_sync ( GDBusConnection *connection, GDBusObjectManagerClientFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GError **error); void udisks_object_manager_client_new_for_bus ( GBusType bus_type, GDBusObjectManagerClientFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); GDBusObjectManager *udisks_object_manager_client_new_for_bus_finish ( GAsyncResult *res, GError **error); GDBusObjectManager *udisks_object_manager_client_new_for_bus_sync ( GBusType bus_type, GDBusObjectManagerClientFlags flags, const gchar *name, const gchar *object_path, GCancellable *cancellable, GError **error); G_END_DECLS #endif /* __UDISKS_GENERATED_H__ */