e_dbus_subprocess_backend_interface_info ()

GDBusInterfaceInfo *
e_dbus_subprocess_backend_interface_info
                               (void);

Gets a machine-readable description of the org.gnome.evolution.dataserver.Subprocess.Backend D-Bus interface.

Since: 3.16

e_dbus_subprocess_backend_override_properties ()

guint
e_dbus_subprocess_backend_override_properties
                               (GObjectClass *klass,
                                guint property_id_begin);

Overrides all GObject properties in the EDBusSubprocessBackend interface for a concrete class. The properties are overridden in the order they are defined.

Since: 3.16

e_dbus_subprocess_backend_complete_create ()

void
e_dbus_subprocess_backend_complete_create
                               (EDBusSubprocessBackend *object,
                                GDBusMethodInvocation *invocation,
                                const gchar *object_path);

Helper function used in service implementations to finish handling invocations of the Create() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.

This method will free invocation , you cannot use it afterwards.

Since: 3.16

e_dbus_subprocess_backend_complete_close ()

void
e_dbus_subprocess_backend_complete_close
                               (EDBusSubprocessBackend *object,
                                GDBusMethodInvocation *invocation);

Helper function used in service implementations to finish handling invocations of the Close() D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.

This method will free invocation , you cannot use it afterwards.

Since: 3.16

e_dbus_subprocess_backend_emit_backend_closed ()

void
e_dbus_subprocess_backend_emit_backend_closed
                               (EDBusSubprocessBackend *object,
                                const gchar *arg_sender);

Emits the "BackendClosed" D-Bus signal.

Since: 3.16

e_dbus_subprocess_backend_call_create ()

void
e_dbus_subprocess_backend_call_create (EDBusSubprocessBackend *proxy,
                                       const gchar *arg_source_id,
                                       const gchar *arg_backend_factory_type_name,
                                       const gchar *arg_module_filename,
                                       GCancellable *cancellable,
                                       GAsyncReadyCallback callback,
                                       gpointer user_data);

Asynchronously invokes the Create() D-Bus method on proxy . When the operation is finished, callback will be invoked in the thread-default main loop of the thread you are calling this method from. You can then call e_dbus_subprocess_backend_call_create_finish() to get the result of the operation.

See e_dbus_subprocess_backend_call_create_sync() for the synchronous, blocking version of this method.

Since: 3.16

e_dbus_subprocess_backend_call_create_finish ()

gboolean
e_dbus_subprocess_backend_call_create_finish
                               (EDBusSubprocessBackend *proxy,
                                gchar **out_object_path,
                                GAsyncResult *res,
                                GError **error);

Finishes an operation started with e_dbus_subprocess_backend_call_create().

Since: 3.16

e_dbus_subprocess_backend_call_create_sync ()

gboolean
e_dbus_subprocess_backend_call_create_sync
                               (EDBusSubprocessBackend *proxy,
                                const gchar *arg_source_id,
                                const gchar *arg_backend_factory_type_name,
                                const gchar *arg_module_filename,
                                gchar **out_object_path,
                                GCancellable *cancellable,
                                GError **error);

Synchronously invokes the Create() D-Bus method on proxy . The calling thread is blocked until a reply is received.

See e_dbus_subprocess_backend_call_create() for the asynchronous version of this method.

Since: 3.16

e_dbus_subprocess_backend_call_close ()

void
e_dbus_subprocess_backend_call_close (EDBusSubprocessBackend *proxy,
                                      GCancellable *cancellable,
                                      GAsyncReadyCallback callback,
                                      gpointer user_data);

Asynchronously invokes the Close() D-Bus method on proxy . When the operation is finished, callback will be invoked in the thread-default main loop of the thread you are calling this method from. You can then call e_dbus_subprocess_backend_call_close_finish() to get the result of the operation.

See e_dbus_subprocess_backend_call_close_sync() for the synchronous, blocking version of this method.

Since: 3.16

e_dbus_subprocess_backend_call_close_finish ()

gboolean
e_dbus_subprocess_backend_call_close_finish
                               (EDBusSubprocessBackend *proxy,
                                GAsyncResult *res,
                                GError **error);

Finishes an operation started with e_dbus_subprocess_backend_call_close().

Since: 3.16

e_dbus_subprocess_backend_call_close_sync ()

gboolean
e_dbus_subprocess_backend_call_close_sync
                               (EDBusSubprocessBackend *proxy,
                                GCancellable *cancellable,
                                GError **error);

Synchronously invokes the Close() D-Bus method on proxy . The calling thread is blocked until a reply is received.

See e_dbus_subprocess_backend_call_close() for the asynchronous version of this method.

Since: 3.16

e_dbus_subprocess_backend_proxy_new ()

void
e_dbus_subprocess_backend_proxy_new (GDBusConnection *connection,
                                     GDBusProxyFlags flags,
                                     const gchar *name,
                                     const gchar *object_path,
                                     GCancellable *cancellable,
                                     GAsyncReadyCallback callback,
                                     gpointer user_data);

Asynchronously creates a proxy for the D-Bus interface org.gnome.evolution.dataserver.Subprocess.Backend. See g_dbus_proxy_new() for more details.

When the operation is finished, callback will be invoked in the thread-default main loop of the thread you are calling this method from. You can then call e_dbus_subprocess_backend_proxy_new_finish() to get the result of the operation.

See e_dbus_subprocess_backend_proxy_new_sync() for the synchronous, blocking version of this constructor.

Since: 3.16

e_dbus_subprocess_backend_proxy_new_finish ()

EDBusSubprocessBackend *
e_dbus_subprocess_backend_proxy_new_finish
                               (GAsyncResult *res,
                                GError **error);

Finishes an operation started with e_dbus_subprocess_backend_proxy_new().

Since: 3.16

e_dbus_subprocess_backend_proxy_new_sync ()

EDBusSubprocessBackend *
e_dbus_subprocess_backend_proxy_new_sync
                               (GDBusConnection *connection,
                                GDBusProxyFlags flags,
                                const gchar *name,
                                const gchar *object_path,
                                GCancellable *cancellable,
                                GError **error);

Synchronously creates a proxy for the D-Bus interface org.gnome.evolution.dataserver.Subprocess.Backend. See g_dbus_proxy_new_sync() for more details.

The calling thread is blocked until a reply is received.

See e_dbus_subprocess_backend_proxy_new() for the asynchronous version of this constructor.

Since: 3.16

e_dbus_subprocess_backend_proxy_new_for_bus ()

void
e_dbus_subprocess_backend_proxy_new_for_bus
                               (GBusType bus_type,
                                GDBusProxyFlags flags,
                                const gchar *name,
                                const gchar *object_path,
                                GCancellable *cancellable,
                                GAsyncReadyCallback callback,
                                gpointer user_data);

Like e_dbus_subprocess_backend_proxy_new() but takes a GBusType instead of a GDBusConnection.

When the operation is finished, callback will be invoked in the thread-default main loop of the thread you are calling this method from. You can then call e_dbus_subprocess_backend_proxy_new_for_bus_finish() to get the result of the operation.

See e_dbus_subprocess_backend_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.

Since: 3.16

e_dbus_subprocess_backend_proxy_new_for_bus_finish ()

EDBusSubprocessBackend *
e_dbus_subprocess_backend_proxy_new_for_bus_finish
                               (GAsyncResult *res,
                                GError **error);

Finishes an operation started with e_dbus_subprocess_backend_proxy_new_for_bus().

Since: 3.16

e_dbus_subprocess_backend_proxy_new_for_bus_sync ()

EDBusSubprocessBackend *
e_dbus_subprocess_backend_proxy_new_for_bus_sync
                               (GBusType bus_type,
                                GDBusProxyFlags flags,
                                const gchar *name,
                                const gchar *object_path,
                                GCancellable *cancellable,
                                GError **error);

Like e_dbus_subprocess_backend_proxy_new_sync() but takes a GBusType instead of a GDBusConnection.

The calling thread is blocked until a reply is received.

See e_dbus_subprocess_backend_proxy_new_for_bus() for the asynchronous version of this constructor.

Since: 3.16

e_dbus_subprocess_backend_skeleton_new ()

EDBusSubprocessBackend *
e_dbus_subprocess_backend_skeleton_new
                               (void);

Creates a skeleton object for the D-Bus interface org.gnome.evolution.dataserver.Subprocess.Backend.

Since: 3.16

e_dbus_subprocess_object_get_backend ()

EDBusSubprocessBackend *
e_dbus_subprocess_object_get_backend (EDBusSubprocessObject *object);

Gets the EDBusSubprocessBackend instance for the D-Bus interface org.gnome.evolution.dataserver.Subprocess.Backend on object , if any.

Since: 3.16

e_dbus_subprocess_object_peek_backend ()

EDBusSubprocessBackend *
e_dbus_subprocess_object_peek_backend (EDBusSubprocessObject *object);

Like e_dbus_subprocess_object_get_backend() but doesn't increase the reference count on the returned object.

[skip]

Since: 3.16

e_dbus_subprocess_object_proxy_new ()

EDBusSubprocessObjectProxy *
e_dbus_subprocess_object_proxy_new (GDBusConnection *connection,
                                    const gchar *object_path);

Creates a new proxy object.

e_dbus_subprocess_object_skeleton_new ()

EDBusSubprocessObjectSkeleton *
e_dbus_subprocess_object_skeleton_new (const gchar *object_path);

Creates a new skeleton object.

e_dbus_subprocess_object_skeleton_set_backend ()

void
e_dbus_subprocess_object_skeleton_set_backend
                               (EDBusSubprocessObjectSkeleton *object,
                                EDBusSubprocessBackend *interface_);

Sets the EDBusSubprocessBackend instance for the D-Bus interface org.gnome.evolution.dataserver.Subprocess.Backend on object .

Since: 3.16

e_dbus_subprocess_object_manager_client_get_proxy_type ()

GType
e_dbus_subprocess_object_manager_client_get_proxy_type
                               (GDBusObjectManagerClient *manager,
                                const gchar *object_path,
                                const gchar *interface_name,
                                gpointer user_data);

A GDBusProxyTypeFunc that maps interface_name to the generated GDBusObjectProxy- and GDBusProxy-derived types.

e_dbus_subprocess_object_manager_client_new ()

void
e_dbus_subprocess_object_manager_client_new
                               (GDBusConnection *connection,
                                GDBusObjectManagerClientFlags flags,
                                const gchar *name,
                                const gchar *object_path,
                                GCancellable *cancellable,
                                GAsyncReadyCallback callback,
                                gpointer user_data);

Asynchronously creates GDBusObjectManagerClient using e_dbus_subprocess_object_manager_client_get_proxy_type() as the GDBusProxyTypeFunc. See g_dbus_object_manager_client_new() for more details.

When the operation is finished, callback will be invoked in the thread-default main loop of the thread you are calling this method from. You can then call e_dbus_subprocess_object_manager_client_new_finish() to get the result of the operation.

See e_dbus_subprocess_object_manager_client_new_sync() for the synchronous, blocking version of this constructor.

e_dbus_subprocess_object_manager_client_new_finish ()

GDBusObjectManager *
e_dbus_subprocess_object_manager_client_new_finish
                               (GAsyncResult *res,
                                GError **error);

Finishes an operation started with e_dbus_subprocess_object_manager_client_new().

e_dbus_subprocess_object_manager_client_new_sync ()

GDBusObjectManager *
e_dbus_subprocess_object_manager_client_new_sync
                               (GDBusConnection *connection,
                                GDBusObjectManagerClientFlags flags,
                                const gchar *name,
                                const gchar *object_path,
                                GCancellable *cancellable,
                                GError **error);

Synchronously creates GDBusObjectManagerClient using e_dbus_subprocess_object_manager_client_get_proxy_type() as the GDBusProxyTypeFunc. See g_dbus_object_manager_client_new_sync() for more details.

The calling thread is blocked until a reply is received.

See e_dbus_subprocess_object_manager_client_new() for the asynchronous version of this constructor.

e_dbus_subprocess_object_manager_client_new_for_bus ()

void
e_dbus_subprocess_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);

Like e_dbus_subprocess_object_manager_client_new() but takes a GBusType instead of a GDBusConnection.

When the operation is finished, callback will be invoked in the thread-default main loop of the thread you are calling this method from. You can then call e_dbus_subprocess_object_manager_client_new_for_bus_finish() to get the result of the operation.

See e_dbus_subprocess_object_manager_client_new_for_bus_sync() for the synchronous, blocking version of this constructor.

e_dbus_subprocess_object_manager_client_new_for_bus_finish ()

GDBusObjectManager *
e_dbus_subprocess_object_manager_client_new_for_bus_finish
                               (GAsyncResult *res,
                                GError **error);

Finishes an operation started with e_dbus_subprocess_object_manager_client_new_for_bus().

e_dbus_subprocess_object_manager_client_new_for_bus_sync ()

GDBusObjectManager *
e_dbus_subprocess_object_manager_client_new_for_bus_sync
                               (GBusType bus_type,
                                GDBusObjectManagerClientFlags flags,
                                const gchar *name,
                                const gchar *object_path,
                                GCancellable *cancellable,
                                GError **error);

Like e_dbus_subprocess_object_manager_client_new_sync() but takes a GBusType instead of a GDBusConnection.

The calling thread is blocked until a reply is received.

See e_dbus_subprocess_object_manager_client_new_for_bus() for the asynchronous version of this constructor.

struct EDBusSubprocessBackendIface

struct EDBusSubprocessBackendIface {
  GTypeInterface parent_iface;


  gboolean (*handle_close) (
    EDBusSubprocessBackend *object,
    GDBusMethodInvocation *invocation);

  gboolean (*handle_create) (
    EDBusSubprocessBackend *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_source_id,
    const gchar *arg_backend_factory_type_name,
    const gchar *arg_module_filename);

  void (*backend_closed) (
    EDBusSubprocessBackend *object,
    const gchar *arg_sender);
};

Virtual table for the D-Bus interface org.gnome.evolution.dataserver.Subprocess.Backend.

Since: 3.16

struct EDBusSubprocessBackendProxy

struct EDBusSubprocessBackendProxy;

The EDBusSubprocessBackendProxy structure contains only private data and should only be accessed using the provided API.

Since: 3.16

struct EDBusSubprocessBackendProxyClass

struct EDBusSubprocessBackendProxyClass {
  GDBusProxyClass parent_class;
};

Class structure for EDBusSubprocessBackendProxy.

Since: 3.16

struct EDBusSubprocessBackendSkeleton

struct EDBusSubprocessBackendSkeleton;

The EDBusSubprocessBackendSkeleton structure contains only private data and should only be accessed using the provided API.

Since: 3.16

struct EDBusSubprocessBackendSkeletonClass

struct EDBusSubprocessBackendSkeletonClass {
  GDBusInterfaceSkeletonClass parent_class;
};

Class structure for EDBusSubprocessBackendSkeleton.

Since: 3.16

struct EDBusSubprocessObjectIface

struct EDBusSubprocessObjectIface {
  GTypeInterface parent_iface;
};

Virtual table for the EDBusSubprocessObject interface.

struct EDBusSubprocessObjectProxy

struct EDBusSubprocessObjectProxy;

The EDBusSubprocessObjectProxy structure contains only private data and should only be accessed using the provided API.

struct EDBusSubprocessObjectProxyClass

struct EDBusSubprocessObjectProxyClass {
  GDBusObjectProxyClass parent_class;
};

Class structure for EDBusSubprocessObjectProxy.

struct EDBusSubprocessObjectSkeleton

struct EDBusSubprocessObjectSkeleton;

The EDBusSubprocessObjectSkeleton structure contains only private data and should only be accessed using the provided API.

struct EDBusSubprocessObjectSkeletonClass

struct EDBusSubprocessObjectSkeletonClass {
  GDBusObjectSkeletonClass parent_class;
};

Class structure for EDBusSubprocessObjectSkeleton.

struct EDBusSubprocessObjectManagerClient

struct EDBusSubprocessObjectManagerClient;

The EDBusSubprocessObjectManagerClient structure contains only private data and should only be accessed using the provided API.

struct EDBusSubprocessObjectManagerClientClass

struct EDBusSubprocessObjectManagerClientClass {
  GDBusObjectManagerClientClass parent_class;
};

Class structure for EDBusSubprocessObjectManagerClient.

EDBusSubprocessBackend

typedef struct _EDBusSubprocessBackend EDBusSubprocessBackend;

Abstract interface type for the D-Bus interface org.gnome.evolution.dataserver.Subprocess.Backend.

Since: 3.16

EDBusSubprocessBackendProxyPrivate

typedef struct _EDBusSubprocessBackendProxyPrivate EDBusSubprocessBackendProxyPrivate;

EDBusSubprocessBackendSkeletonPrivate

typedef struct _EDBusSubprocessBackendSkeletonPrivate EDBusSubprocessBackendSkeletonPrivate;

EDBusSubprocessObject

typedef struct _EDBusSubprocessObject EDBusSubprocessObject;

The EDBusSubprocessObject type is a specialized container of interfaces.

EDBusSubprocessObjectManagerClientPrivate

typedef struct _EDBusSubprocessObjectManagerClientPrivate EDBusSubprocessObjectManagerClientPrivate;

EDBusSubprocessObjectProxyPrivate

typedef struct _EDBusSubprocessObjectProxyPrivate EDBusSubprocessObjectProxyPrivate;

EDBusSubprocessObjectSkeletonPrivate

typedef struct _EDBusSubprocessObjectSkeletonPrivate EDBusSubprocessObjectSkeletonPrivate;

The “backend” property

  “backend”                  EDBusSubprocessBackend *

The EDBusSubprocessBackend instance corresponding to the D-Bus interface org.gnome.evolution.dataserver.Subprocess.Backend, if any.

Connect to the “notify” signal to get informed of property changes.

Flags: Read / Write

Since: 3.16

The “backend-closed” signal

void
user_function (EDBusSubprocessBackend *object,
               gchar                  *arg_sender,
               gpointer                user_data)

On the client-side, this signal is emitted whenever the D-Bus signal "BackendClosed" is received.

On the service-side, this signal can be used with e.g. g_signal_emit_by_name() to make the object emit the D-Bus signal.

Flags: Run Last

Since: 3.16

The “handle-close” signal

gboolean
user_function (EDBusSubprocessBackend *object,
               GDBusMethodInvocation  *invocation,
               gpointer                user_data)

Signal emitted when a remote caller is invoking the Close() D-Bus method.

If a signal handler returns TRUE, it means the signal handler will handle the invocation (e.g. take a reference to invocation and eventually call e_dbus_subprocess_backend_complete_close() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the G_DBUS_ERROR_UNKNOWN_METHOD error is returned.

Flags: Run Last

Since: 3.16

The “handle-create” signal

gboolean
user_function (EDBusSubprocessBackend *object,
               GDBusMethodInvocation  *invocation,
               gchar                  *arg_source_id,
               gchar                  *arg_backend_factory_type_name,
               gchar                  *arg_module_filename,
               gpointer                user_data)

Signal emitted when a remote caller is invoking the Create() D-Bus method.

If a signal handler returns TRUE, it means the signal handler will handle the invocation (e.g. take a reference to invocation and eventually call e_dbus_subprocess_backend_complete_create() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the G_DBUS_ERROR_UNKNOWN_METHOD error is returned.

Flags: Run Last

Since: 3.16