IBusBus

## IBusBus IBusBus — Connect with IBus daemon. |

## Stability Level

Stable, unless otherwise indicated

## Synopsis

    struct              IBusBus;
    struct              IBusBusClass;
    IBusBus *           ibus_bus_new                        (void);
    gboolean            ibus_bus_is_connected               (IBusBus *bus);
    GDBusConnection *   ibus_bus_get_connection             (IBusBus *bus);
    const gchar *       ibus_bus_hello                      (IBusBus *bus);
    guint32             ibus_bus_request_name               (IBusBus *bus,
                                                             const gchar *name,
                                                             guint32 flags);
    void                ibus_bus_request_name_async         (IBusBus *bus,
                                                             const gchar *name,
                                                             guint flags,
                                                             gint timeout_msec,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    guint               ibus_bus_request_name_async_finish  (IBusBus *bus,
                                                             GAsyncResult *res,
                                                             GError **error);
    guint               ibus_bus_release_name               (IBusBus *bus,
                                                             const gchar *name);
    void                ibus_bus_release_name_async         (IBusBus *bus,
                                                             const gchar *name,
                                                             gint timeout_msec,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    guint               ibus_bus_release_name_async_finish  (IBusBus *bus,
                                                             GAsyncResult *res,
                                                             GError **error);
    GList *             ibus_bus_list_queued_owners         (IBusBus *bus,
                                                             const gchar *name);
    gboolean            ibus_bus_name_has_owner             (IBusBus *bus,
                                                             const gchar *name);
    void                ibus_bus_name_has_owner_async       (IBusBus *bus,
                                                             const gchar *name,
                                                             gint timeout_msec,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    gboolean            ibus_bus_name_has_owner_async_finish
                                                            (IBusBus *bus,
                                                             GAsyncResult *res,
                                                             GError **error);
    GList *             ibus_bus_list_names                 (IBusBus *bus);
    gboolean            ibus_bus_add_match                  (IBusBus *bus,
                                                             const gchar *rule);
    void                ibus_bus_add_match_async            (IBusBus *bus,
                                                             const gchar *rule,
                                                             gint timeout_msec,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    gboolean            ibus_bus_add_match_async_finish     (IBusBus *bus,
                                                             GAsyncResult *res,
                                                             GError **error);
    gboolean            ibus_bus_remove_match               (IBusBus *bus,
                                                             const gchar *rule);
    void                ibus_bus_remove_match_async         (IBusBus *bus,
                                                             const gchar *rule,
                                                             gint timeout_msec,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    gboolean            ibus_bus_remove_match_async_finish  (IBusBus *bus,
                                                             GAsyncResult *res,
                                                             GError **error);
    gchar *             ibus_bus_get_name_owner             (IBusBus *bus,
                                                             const gchar *name);
    void                ibus_bus_get_name_owner_async       (IBusBus *bus,
                                                             const gchar *name,
                                                             gint timeout_msec,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    gchar *             ibus_bus_get_name_owner_async_finish
                                                            (IBusBus *bus,
                                                             GAsyncResult *res,
                                                             GError **error);
    gboolean            ibus_bus_exit                       (IBusBus *bus,
                                                             gboolean restart);
    void                ibus_bus_exit_async                 (IBusBus *bus,
                                                             gboolean restart,
                                                             gint timeout_msec,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    gboolean            ibus_bus_exit_async_finish          (IBusBus *bus,
                                                             GAsyncResult *res,
                                                             GError **error);
    IBusInputContext *  ibus_bus_create_input_context       (IBusBus *bus,
                                                             const gchar *client_name);
    void                ibus_bus_create_input_context_async (IBusBus *bus,
                                                             const gchar *client_name,
                                                             gint timeout_msec,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    IBusInputContext *  ibus_bus_create_input_context_async_finish
                                                            (IBusBus *bus,
                                                             GAsyncResult *res,
                                                             GError **error);
    gchar *             ibus_bus_current_input_context      (IBusBus *bus);
    void                ibus_bus_current_input_context_async
                                                            (IBusBus *bus,
                                                             gint timeout_msec,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    gchar *             ibus_bus_current_input_context_async_finish
                                                            (IBusBus *bus,
                                                             GAsyncResult *res,
                                                             GError **error);
    gboolean            ibus_bus_register_component         (IBusBus *bus,
                                                             IBusComponent *component);
    void                ibus_bus_register_component_async   (IBusBus *bus,
                                                             IBusComponent *component,
                                                             gint timeout_msec,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    gboolean            ibus_bus_register_component_async_finish
                                                            (IBusBus *bus,
                                                             GAsyncResult *res,
                                                             GError **error);
    GList *             ibus_bus_list_engines               (IBusBus *bus);
    void                ibus_bus_list_engines_async         (IBusBus *bus,
                                                             gint timeout_msec,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    GList *             ibus_bus_list_engines_async_finish  (IBusBus *bus,
                                                             GAsyncResult *res,
                                                             GError **error);
    GList *             ibus_bus_list_active_engines        (IBusBus *bus);
    void                ibus_bus_list_active_engines_async  (IBusBus *bus,
                                                             gint timeout_msec,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    GList *             ibus_bus_list_active_engines_async_finish
                                                            (IBusBus *bus,
                                                             GAsyncResult *res,
                                                             GError **error);
    gboolean            ibus_bus_get_use_sys_layout         (IBusBus *bus);
    void                ibus_bus_get_use_sys_layout_async   (IBusBus *bus,
                                                             gint timeout_msec,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    gboolean            ibus_bus_get_use_sys_layout_async_finish
                                                            (IBusBus *bus,
                                                             GAsyncResult *res,
                                                             GError **error);
    gboolean            ibus_bus_get_use_global_engine      (IBusBus *bus);
    void                ibus_bus_get_use_global_engine_async
                                                            (IBusBus *bus,
                                                             gint timeout_msec,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    gboolean            ibus_bus_get_use_global_engine_async_finish
                                                            (IBusBus *bus,
                                                             GAsyncResult *res,
                                                             GError **error);
    gboolean            ibus_bus_is_global_engine_enabled   (IBusBus *bus);
    void                ibus_bus_is_global_engine_enabled_async
                                                            (IBusBus *bus,
                                                             gint timeout_msec,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    gboolean            ibus_bus_is_global_engine_enabled_async_finish
                                                            (IBusBus *bus,
                                                             GAsyncResult *res,
                                                             GError **error);
    IBusEngineDesc *    ibus_bus_get_global_engine          (IBusBus *bus);
    void                ibus_bus_get_global_engine_async    (IBusBus *bus,
                                                             gint timeout_msec,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    IBusEngineDesc *    ibus_bus_get_global_engine_async_finish
                                                            (IBusBus *bus,
                                                             GAsyncResult *res,
                                                             GError **error);
    gboolean            ibus_bus_set_global_engine          (IBusBus *bus,
                                                             const gchar *global_engine);
    void                ibus_bus_set_global_engine_async    (IBusBus *bus,
                                                             const gchar *global_engine,
                                                             gint timeout_msec,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    gboolean            ibus_bus_set_global_engine_async_finish
                                                            (IBusBus *bus,
                                                             GAsyncResult *res,
                                                             GError **error);
    void                ibus_bus_set_watch_dbus_signal      (IBusBus *bus,
                                                             gboolean watch);
    void                ibus_bus_set_watch_ibus_signal      (IBusBus *bus,
                                                             gboolean watch);
    IBusConfig *        ibus_bus_get_config                 (IBusBus *bus);

## Object Hierarchy

      GObject
       +----GInitiallyUnowned
             +----IBusObject
                   +----IBusBus

## Signals

      "connected"                                      : Run Last
      "disconnected"                                   : Run Last
      "global-engine-changed"                          : Run Last
      "name-owner-changed"                             : Run Last

## Description

An IBusBus connects with IBus daemon.

## Details

### struct IBusBus

    struct IBusBus;

An opaque data type representing IBus bus (daemon communication) status.

### struct IBusBusClass

    struct IBusBusClass {
        IBusObjectClass parent;
        /* class members */
    };

### ibus_bus_new ()

    IBusBus *           ibus_bus_new                        (void);

New an IBusBus instance.

Returns : | A newly allocated IBusBus instance, and the instance is not floating.

### ibus_bus_is_connected ()

    gboolean            ibus_bus_is_connected               (IBusBus *bus);

Return `TRUE` if `bus` is connected to IBus daemon.

`bus` : | An IBusBus.
Returns : | `TRUE` if `bus` is connected, `FALSE` otherwise.

### ibus_bus_get_connection ()

    GDBusConnection *   ibus_bus_get_connection             (IBusBus *bus);

Return GDBusConnection of an IBusIBus instance.

`bus` : | An IBusBus.
Returns : | A GDBusConnection of an IBusIBus instance. [transfer none]

### ibus_bus_hello ()

    const gchar *       ibus_bus_hello                      (IBusBus *bus);

This function sends a "HELLO" message to DBus daemon, which replies the unique name of current IBus process.

`bus` : | An IBusBus.
Returns : | The unique name of IBus process in DBus.

### ibus_bus_request_name ()

    guint32             ibus_bus_request_name               (IBusBus *bus,
                                                             const gchar *name,
                                                             guint32 flags);

Request a name from IBus daemon synchronously.

`bus` : | the IBusBus instance to be processed.
`name` : | Name to be requested.
`flags` : | IBusBusNameFlag.
Returns : | 0 if failed; IBusBusRequestNameReply otherwise.

### ibus_bus_request_name_async ()

    void                ibus_bus_request_name_async         (IBusBus *bus,
                                                             const gchar *name,
                                                             guint flags,
                                                             gint timeout_msec,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

Request a name from IBus daemon asynchronously.

`bus` : | An IBusBus.
`name` : | Name to be requested.
`flags` : | Flags (FixMe).
`timeout_msec` : | The timeout in milliseconds or -1 to use the default timeout.
`cancellable` : | A GCancellable or `NULL`.
`callback` : | A GAsyncReadyCallback to call when the request is satisfied or `NULL` if you don't care about the result of the method invocation.
`user_data` : | The data to pass to callback.

### ibus_bus_request_name_async_finish ()

    guint               ibus_bus_request_name_async_finish  (IBusBus *bus,
                                                             GAsyncResult *res,
                                                             GError **error);

Finishes an operation started with `ibus_bus_request_name_async()`.

`bus` : | An IBusBus.
`res` : | A GAsyncResult obtained from the GAsyncReadyCallback passed to `ibus_bus_request_name_async()`.
`error` : | Return location for error or `NULL`.
Returns : | 0 if failed; positive number otherwise.

### ibus_bus_release_name ()

    guint               ibus_bus_release_name               (IBusBus *bus,
                                                             const gchar *name);

Release a name to IBus daemon synchronously.

`bus` : | An IBusBus.
`name` : | Name to be released.
Returns : | 0 if failed; positive number otherwise.

### ibus_bus_release_name_async ()

    void                ibus_bus_release_name_async         (IBusBus *bus,
                                                             const gchar *name,
                                                             gint timeout_msec,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

Release a name to IBus daemon asynchronously.

`bus` : | An IBusBus.
`name` : | Name to be released.
`timeout_msec` : | The timeout in milliseconds or -1 to use the default timeout.
`cancellable` : | A GCancellable or `NULL`.
`callback` : | A GAsyncReadyCallback to call when the request is satisfied or `NULL` if you don't care about the result of the method invocation.
`user_data` : | The data to pass to callback.

### ibus_bus_release_name_async_finish ()

    guint               ibus_bus_release_name_async_finish  (IBusBus *bus,
                                                             GAsyncResult *res,
                                                             GError **error);

Finishes an operation started with `ibus_bus_release_name_async()`.

`bus` : | An IBusBus.
`res` : | A GAsyncResult obtained from the GAsyncReadyCallback passed to `ibus_bus_release_name_async()`.
`error` : | Return location for error or `NULL`.
Returns : | 0 if failed; positive number otherwise.

### ibus_bus_list_queued_owners ()

    GList *             ibus_bus_list_queued_owners         (IBusBus *bus,
                                                             const gchar *name);

Lists the unique bus names of connections currently queued for a bus name.

FIXME add an asynchronous version.

`bus` : | An IBusBus.
`name` : | Name to be queried.
Returns : | The unique bus names of connections currently queued for `name`. [transfer full][element-type utf8]

### ibus_bus_name_has_owner ()

    gboolean            ibus_bus_name_has_owner             (IBusBus *bus,
                                                             const gchar *name);

Checks whether the name has owner synchronously.

`bus` : | An IBusBus.
`name` : | Name to be checked.
Returns : | `TRUE` if the name has owner, `FALSE` otherwise.

### ibus_bus_name_has_owner_async ()

    void                ibus_bus_name_has_owner_async       (IBusBus *bus,
                                                             const gchar *name,
                                                             gint timeout_msec,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

Checks whether the name has owner asynchronously.

`bus` : | An IBusBus.
`name` : | Name to be checked.
`timeout_msec` : | The timeout in milliseconds or -1 to use the default timeout.
`cancellable` : | A GCancellable or `NULL`.
`callback` : | A GAsyncReadyCallback to call when the request is satisfied or `NULL` if you don't care about the result of the method invocation.
`user_data` : | The data to pass to callback.

### ibus_bus_name_has_owner_async_finish ()

    gboolean            ibus_bus_name_has_owner_async_finish
                                                            (IBusBus *bus,
                                                             GAsyncResult *res,
                                                             GError **error);

Finishes an operation started with `ibus_bus_name_has_owner_async()`.

`bus` : | An IBusBus.
`res` : | A GAsyncResult obtained from the GAsyncReadyCallback passed to `ibus_bus_name_has_owner_async()`.
`error` : | Return location for error or `NULL`.
Returns : | `TRUE` if the name has owner, `FALSE` otherwise.

### ibus_bus_list_names ()

    GList *             ibus_bus_list_names                 (IBusBus *bus);

Return lists that attached to `bus`.

### Note

[FixMe] Not implemented yet, only return NULL.

### Note

[FixMe] Add async version.

`bus` : | An IBusBus.
Returns : | Lists that attached to `bus`. [transfer full][element-type utf8]

### ibus_bus_add_match ()

    gboolean            ibus_bus_add_match                  (IBusBus *bus,
                                                             const gchar *rule);

Add a match rule to an IBusBus synchronously.

`bus` : | An IBusBus.
`rule` : | Match rule.
Returns : | `TRUE` if the rule is added. `FALSE` otherwise.

### ibus_bus_add_match_async ()

    void                ibus_bus_add_match_async            (IBusBus *bus,
                                                             const gchar *rule,
                                                             gint timeout_msec,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

Add a match rule to an IBusBus asynchronously.

`bus` : | An IBusBus.
`rule` : | Match rule.
`timeout_msec` : | The timeout in milliseconds or -1 to use the default timeout.
`cancellable` : | A GCancellable or `NULL`.
`callback` : | A GAsyncReadyCallback to call when the request is satisfied or `NULL` if you don't care about the result of the method invocation.
`user_data` : | The data to pass to callback.

### ibus_bus_add_match_async_finish ()

    gboolean            ibus_bus_add_match_async_finish     (IBusBus *bus,
                                                             GAsyncResult *res,
                                                             GError **error);

Finishes an operation started with `ibus_bus_add_match_async()`.

`bus` : | An IBusBus.
`res` : | A GAsyncResult obtained from the GAsyncReadyCallback passed to `ibus_bus_add_match_async()`.
`error` : | Return location for error or `NULL`.
Returns : | `TRUE` if the rule is added. `FALSE` otherwise.

### ibus_bus_remove_match ()

    gboolean            ibus_bus_remove_match               (IBusBus *bus,
                                                             const gchar *rule);

Remove a match rule to an IBusBus synchronously.

`bus` : | An IBusBus.
`rule` : | Match rule.
Returns : | `TRUE` if the rule is removed. `FALSE` otherwise.

### ibus_bus_remove_match_async ()

    void                ibus_bus_remove_match_async         (IBusBus *bus,
                                                             const gchar *rule,
                                                             gint timeout_msec,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

Remove a match rule to an IBusBus asynchronously.

`bus` : | An IBusBus.
`rule` : | Match rule.
`timeout_msec` : | The timeout in milliseconds or -1 to use the default timeout.
`cancellable` : | A GCancellable or `NULL`.
`callback` : | A GAsyncReadyCallback to call when the request is satisfied or `NULL` if you don't care about the result of the method invocation.
`user_data` : | The data to pass to callback.

### ibus_bus_remove_match_async_finish ()

    gboolean            ibus_bus_remove_match_async_finish  (IBusBus *bus,
                                                             GAsyncResult *res,
                                                             GError **error);

Finishes an operation started with `ibus_bus_remove_match_async()`.

`bus` : | An IBusBus.
`res` : | A GAsyncResult obtained from the GAsyncReadyCallback passed to `ibus_bus_remove_match_async()`.
`error` : | Return location for error or `NULL`.
Returns : | `TRUE` if the rule is removed. `FALSE` otherwise.

### ibus_bus_get_name_owner ()

    gchar *             ibus_bus_get_name_owner             (IBusBus *bus,
                                                             const gchar *name);

Return the name owner synchronously.

`bus` : | An IBusBus.
`name` : | Name.
Returns : | Owner of the name. The returned value must be freed with `g_free()`.

### ibus_bus_get_name_owner_async ()

    void                ibus_bus_get_name_owner_async       (IBusBus *bus,
                                                             const gchar *name,
                                                             gint timeout_msec,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

Return the name owner asynchronously.

`bus` : | An IBusBus.
`name` : | Name.
`timeout_msec` : | The timeout in milliseconds or -1 to use the default timeout.
`cancellable` : | A GCancellable or `NULL`.
`callback` : | A GAsyncReadyCallback to call when the request is satisfied or `NULL` if you don't care about the result of the method invocation.
`user_data` : | The data to pass to callback.

### ibus_bus_get_name_owner_async_finish ()

    gchar *             ibus_bus_get_name_owner_async_finish
                                                            (IBusBus *bus,
                                                             GAsyncResult *res,
                                                             GError **error);

Finishes an operation started with `ibus_bus_get_name_owner_async()`.

`bus` : | An IBusBus.
`res` : | A GAsyncResult obtained from the GAsyncReadyCallback passed to `ibus_bus_get_name_owner_async()`.
`error` : | Return location for error or `NULL`.
Returns : | Owner of the name. The returned value must be freed with `g_free()`.

### ibus_bus_exit ()

    gboolean            ibus_bus_exit                       (IBusBus *bus,
                                                             gboolean restart);

Exit or restart ibus-daemon synchronously.

`bus` : | An IBusBus.
`restart` : | Whether restarting the ibus.
Returns : | `TRUE` if the "Exit" call is suceeded, `FALSE` otherwise.

### ibus_bus_exit_async ()

    void                ibus_bus_exit_async                 (IBusBus *bus,
                                                             gboolean restart,
                                                             gint timeout_msec,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

Exit or restart ibus-daemon asynchronously.

`bus` : | An IBusBus.
`restart` : | Whether restarting the ibus.
`timeout_msec` : | The timeout in milliseconds or -1 to use the default timeout.
`cancellable` : | A GCancellable or `NULL`.
`callback` : | A GAsyncReadyCallback to call when the request is satisfied or `NULL` if you don't care about the result of the method invocation.
`user_data` : | The data to pass to callback.

### ibus_bus_exit_async_finish ()

    gboolean            ibus_bus_exit_async_finish          (IBusBus *bus,
                                                             GAsyncResult *res,
                                                             GError **error);

Finishes an operation started with `ibus_bus_exit_async()`.

`bus` : | An IBusBus.
`res` : | A GAsyncResult obtained from the GAsyncReadyCallback passed to `ibus_bus_exit_async()`.
`error` : | Return location for error or `NULL`.
Returns : | `TRUE` if the "Exit" call is suceeded, `FALSE` otherwise.

### ibus_bus_create_input_context ()

    IBusInputContext *  ibus_bus_create_input_context       (IBusBus *bus,
                                                             const gchar *client_name);

Create an input context for client synchronously.

`bus` : | An IBusBus.
`client_name` : | Name of client.
Returns : | An newly allocated IBusInputContext if the "CreateInputContext" call is suceeded, `NULL` otherwise.

### ibus_bus_create_input_context_async ()

    void                ibus_bus_create_input_context_async (IBusBus *bus,
                                                             const gchar *client_name,
                                                             gint timeout_msec,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

Create an input context for client asynchronously.

`bus` : | An IBusBus.
`client_name` : | Name of client.
`timeout_msec` : | The timeout in milliseconds or -1 to use the default timeout.
`cancellable` : | A GCancellable or `NULL`.
`callback` : | A GAsyncReadyCallback to call when the request is satisfied. It should not be `NULL`.
`user_data` : | The data to pass to callback.

### ibus_bus_create_input_context_async_finish ()

    IBusInputContext *  ibus_bus_create_input_context_async_finish
                                                            (IBusBus *bus,
                                                             GAsyncResult *res,
                                                             GError **error);

Finishes an operation started with `ibus_bus_create_input_context_async()`.

`bus` : | An IBusBus.
`res` : | A GAsyncResult obtained from the GAsyncReadyCallback passed to `ibus_bus_create_input_context_async()`.
`error` : | Return location for error or `NULL`.
Returns : | An newly allocated IBusInputContext if the "CreateInputContext" call is suceeded, `NULL` otherwise.

### ibus_bus_current_input_context ()

    gchar *             ibus_bus_current_input_context      (IBusBus *bus);

Get the current focused input context synchronously.

`bus` : | An IBusBus.
Returns : | The named of currently focued IBusInputContext if the "CurrentInputContext" call suceeded, `NULL` otherwise. The return value must be freed with `g_free()`.

### ibus_bus_current_input_context_async ()

    void                ibus_bus_current_input_context_async
                                                            (IBusBus *bus,
                                                             gint timeout_msec,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

Get the current focused input context asynchronously.

`bus` : | An IBusBus.
`timeout_msec` : | The timeout in milliseconds or -1 to use the default timeout.
`cancellable` : | A GCancellable or `NULL`.
`callback` : | A GAsyncReadyCallback to call when the request is satisfied or `NULL` if you don't care about the result of the method invocation.
`user_data` : | The data to pass to callback.

### ibus_bus_current_input_context_async_finish ()

    gchar *             ibus_bus_current_input_context_async_finish
                                                            (IBusBus *bus,
                                                             GAsyncResult *res,
                                                             GError **error);

Finishes an operation started with `ibus_bus_current_input_context_async()`.

`bus` : | An IBusBus.
`res` : | A GAsyncResult obtained from the GAsyncReadyCallback passed to `ibus_bus_current_input_context_async()`.
`error` : | Return location for error or `NULL`.
Returns : | The named of currently focued IBusInputContext if the "CurrentInputContext" call suceeded, `NULL` otherwise. The return value must be freed with `g_free()`.

### ibus_bus_register_component ()

    gboolean            ibus_bus_register_component         (IBusBus *bus,
                                                             IBusComponent *component);

Register a componet to an IBusBus synchronously.

`bus` : | An IBusBus.
`component` : | A input engine component.
Returns : | `TRUE` if the "RegisterComponent" call is suceeded, `FALSE` otherwise.

### ibus_bus_register_component_async ()

    void                ibus_bus_register_component_async   (IBusBus *bus,
                                                             IBusComponent *component,
                                                             gint timeout_msec,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

Register a componet to an IBusBus asynchronously.

`bus` : | An IBusBus.
`component` : | A input engine component.
`timeout_msec` : | The timeout in milliseconds or -1 to use the default timeout.
`cancellable` : | A GCancellable or `NULL`.
`callback` : | A GAsyncReadyCallback to call when the request is satisfied or `NULL` if you don't care about the result of the method invocation.
`user_data` : | The data to pass to callback.

### ibus_bus_register_component_async_finish ()

    gboolean            ibus_bus_register_component_async_finish
                                                            (IBusBus *bus,
                                                             GAsyncResult *res,
                                                             GError **error);

Finishes an operation started with `ibus_bus_register_component_async()`.

`bus` : | An IBusBus.
`res` : | A GAsyncResult obtained from the GAsyncReadyCallback passed to `ibus_bus_register_component_async()`.
`error` : | Return location for error or `NULL`.
Returns : | `TRUE` if the "RegisterComponent" call is suceeded, `FALSE` otherwise.

### ibus_bus_list_engines ()

    GList *             ibus_bus_list_engines               (IBusBus *bus);

List engines synchronously.

`bus` : | An IBusBus.
Returns : | A List of engines. [transfer container][element-type IBusEngineDesc]

### ibus_bus_list_engines_async ()

    void                ibus_bus_list_engines_async         (IBusBus *bus,
                                                             gint timeout_msec,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

List engines asynchronously.

`bus` : | An IBusBus.
`timeout_msec` : | The timeout in milliseconds or -1 to use the default timeout.
`cancellable` : | A GCancellable or `NULL`.
`callback` : | A GAsyncReadyCallback to call when the request is satisfied or `NULL` if you don't care about the result of the method invocation.
`user_data` : | The data to pass to callback.

### ibus_bus_list_engines_async_finish ()

    GList *             ibus_bus_list_engines_async_finish  (IBusBus *bus,
                                                             GAsyncResult *res,
                                                             GError **error);

Finishes an operation started with `ibus_bus_list_engines_async()`.

`bus` : | An IBusBus.
`res` : | A GAsyncResult obtained from the GAsyncReadyCallback passed to `ibus_bus_list_engines_async()`.
`error` : | Return location for error or `NULL`.
Returns : | A List of engines. [transfer container][element-type IBusEngineDesc]

### ibus_bus_list_active_engines ()

    GList *             ibus_bus_list_active_engines        (IBusBus *bus);

List active engines synchronously.

`bus` : | An IBusBus.
Returns : | A List of active engines. [transfer container][element-type IBusEngineDesc]

### ibus_bus_list_active_engines_async ()

    void                ibus_bus_list_active_engines_async  (IBusBus *bus,
                                                             gint timeout_msec,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

List active engines asynchronously.

`bus` : | An IBusBus.
`timeout_msec` : | The timeout in milliseconds or -1 to use the default timeout.
`cancellable` : | A GCancellable or `NULL`.
`callback` : | A GAsyncReadyCallback to call when the request is satisfied or `NULL` if you don't care about the result of the method invocation.
`user_data` : | The data to pass to callback.

### ibus_bus_list_active_engines_async_finish ()

    GList *             ibus_bus_list_active_engines_async_finish
                                                            (IBusBus *bus,
                                                             GAsyncResult *res,
                                                             GError **error);

Finishes an operation started with `ibus_bus_list_active_engines_async()`.

`bus` : | An IBusBus.
`res` : | A GAsyncResult obtained from the GAsyncReadyCallback passed to `ibus_bus_list_active_engines_async()`.
`error` : | Return location for error or `NULL`.
Returns : | A List of active engines. [transfer container][element-type IBusEngineDesc]

### ibus_bus_get_use_sys_layout ()

    gboolean            ibus_bus_get_use_sys_layout         (IBusBus *bus);

Check if the bus's "use_sys_layout" option is enabled or not synchronously.

`bus` : | An IBusBus.
Returns : | `TRUE` if "use_sys_layout" option is enabled.

### ibus_bus_get_use_sys_layout_async ()

    void                ibus_bus_get_use_sys_layout_async   (IBusBus *bus,
                                                             gint timeout_msec,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

Check if the bus's "use_sys_layout" option is enabled or not asynchronously.

`bus` : | An IBusBus.
`timeout_msec` : | The timeout in milliseconds or -1 to use the default timeout.
`cancellable` : | A GCancellable or `NULL`.
`callback` : | A GAsyncReadyCallback to call when the request is satisfied or `NULL` if you don't care about the result of the method invocation.
`user_data` : | The data to pass to callback.

### ibus_bus_get_use_sys_layout_async_finish ()

    gboolean            ibus_bus_get_use_sys_layout_async_finish
                                                            (IBusBus *bus,
                                                             GAsyncResult *res,
                                                             GError **error);

Finishes an operation started with `ibus_bus_get_use_sys_layout_async()`.

`bus` : | An IBusBus.
`res` : | A GAsyncResult obtained from the GAsyncReadyCallback passed to `ibus_bus_get_use_sys_layout_async()`.
`error` : | Return location for error or `NULL`.
Returns : | TRUE if "use_sys_layout" option is enabled.

### ibus_bus_get_use_global_engine ()

    gboolean            ibus_bus_get_use_global_engine      (IBusBus *bus);

Check if the bus's "use_global_engine" option is enabled or not synchronously.

`bus` : | An IBusBus.
Returns : | TRUE if "use_global_engine" option is enabled.

### ibus_bus_get_use_global_engine_async ()

    void                ibus_bus_get_use_global_engine_async
                                                            (IBusBus *bus,
                                                             gint timeout_msec,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

Check if the bus's "use_global_engine" option is enabled or not asynchronously.

`bus` : | An IBusBus.
`timeout_msec` : | The timeout in milliseconds or -1 to use the default timeout.
`cancellable` : | A GCancellable or `NULL`.
`callback` : | A GAsyncReadyCallback to call when the request is satisfied or `NULL` if you don't care about the result of the method invocation.
`user_data` : | The data to pass to callback.

### ibus_bus_get_use_global_engine_async_finish ()

    gboolean            ibus_bus_get_use_global_engine_async_finish
                                                            (IBusBus *bus,
                                                             GAsyncResult *res,
                                                             GError **error);

Finishes an operation started with `ibus_bus_get_use_global_engine_async()`.

`bus` : | An IBusBus.
`res` : | A GAsyncResult obtained from the GAsyncReadyCallback passed to `ibus_bus_get_use_global_engine_async()`.
`error` : | Return location for error or `NULL`.
Returns : | `TRUE` if "use_global_engine" option is enabled.

### ibus_bus_is_global_engine_enabled ()

    gboolean            ibus_bus_is_global_engine_enabled   (IBusBus *bus);

Check if the current global engine is enabled or not synchronously.

`bus` : | An IBusBus.
Returns : | `TRUE` if the current global engine is enabled.

### ibus_bus_is_global_engine_enabled_async ()

    void                ibus_bus_is_global_engine_enabled_async
                                                            (IBusBus *bus,
                                                             gint timeout_msec,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

Check if the current global engine is enabled or not asynchronously.

`bus` : | An IBusBus.
`timeout_msec` : | The timeout in milliseconds or -1 to use the default timeout.
`cancellable` : | A GCancellable or `NULL`.
`callback` : | A GAsyncReadyCallback to call when the request is satisfied or `NULL` if you don't care about the result of the method invocation.
`user_data` : | The data to pass to callback.

### ibus_bus_is_global_engine_enabled_async_finish ()

    gboolean            ibus_bus_is_global_engine_enabled_async_finish
                                                            (IBusBus *bus,
                                                             GAsyncResult *res,
                                                             GError **error);

Finishes an operation started with `ibus_bus_is_global_engine_enabled_async()`.

`bus` : | An IBusBus.
`res` : | A GAsyncResult obtained from the GAsyncReadyCallback passed to `ibus_bus_is_global_engine_enabled_async()`.
`error` : | Return location for error or `NULL`.
Returns : | `TRUE` if the current global engine is enabled.

### ibus_bus_get_global_engine ()

    IBusEngineDesc *    ibus_bus_get_global_engine          (IBusBus *bus);

Get the description of current global engine synchronously.

`bus` : | An IBusBus.
Returns : | The description of current global engine, or `NULL` if there is no global engine.

### ibus_bus_get_global_engine_async ()

    void                ibus_bus_get_global_engine_async    (IBusBus *bus,
                                                             gint timeout_msec,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

Get the description of current global engine asynchronously.

`bus` : | An IBusBus.
`timeout_msec` : | The timeout in milliseconds or -1 to use the default timeout.
`cancellable` : | A GCancellable or `NULL`.
`callback` : | A GAsyncReadyCallback to call when the request is satisfied or `NULL` if you don't care about the result of the method invocation.
`user_data` : | The data to pass to callback.

### ibus_bus_get_global_engine_async_finish ()

    IBusEngineDesc *    ibus_bus_get_global_engine_async_finish
                                                            (IBusBus *bus,
                                                             GAsyncResult *res,
                                                             GError **error);

Finishes an operation started with `ibus_bus_get_global_engine_async_finish()`.

`bus` : | An IBusBus.
`res` : | A GAsyncResult obtained from the GAsyncReadyCallback passed to `ibus_bus_get_global_engine_async_finish()`.
`error` : | Return location for error or `NULL`.
Returns : | The description of current global engine, or `NULL` if there is no global engine.

### ibus_bus_set_global_engine ()

    gboolean            ibus_bus_set_global_engine          (IBusBus *bus,
                                                             const gchar *global_engine);

Set current global engine synchronously.

`bus` : | An IBusBus.
`global_engine` : | A new engine name.
Returns : | `TRUE` if the global engine was set successfully.

### ibus_bus_set_global_engine_async ()

    void                ibus_bus_set_global_engine_async    (IBusBus *bus,
                                                             const gchar *global_engine,
                                                             gint timeout_msec,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

Set current global engine asynchronously.

`bus` : | An IBusBus.
`global_engine` : | A new engine name.
`timeout_msec` : | The timeout in milliseconds or -1 to use the default timeout.
`cancellable` : | A GCancellable or `NULL`.
`callback` : | A GAsyncReadyCallback to call when the request is satisfied or `NULL` if you don't care about the result of the method invocation.
`user_data` : | The data to pass to callback.

### ibus_bus_set_global_engine_async_finish ()

    gboolean            ibus_bus_set_global_engine_async_finish
                                                            (IBusBus *bus,
                                                             GAsyncResult *res,
                                                             GError **error);

Finishes an operation started with `ibus_bus_set_global_engine_async()`.

`bus` : | An IBusBus.
`res` : | A GAsyncResult obtained from the GAsyncReadyCallback passed to `ibus_bus_set_global_engine_async()`.
`error` : | Return location for error or `NULL`.
Returns : | `TRUE` if no IPC errros. `FALSE` otherwise.

### ibus_bus_set_watch_dbus_signal ()

    void                ibus_bus_set_watch_dbus_signal      (IBusBus *bus,
                                                             gboolean watch);

Start or stop watching the NameOwnerChanged DBus signal.

`bus` : | An IBusBus.
`watch` : | `TRUE` if you want ibusbus to emit "name-owner-changed" signal when ibus-daemon emits the NameOwnerChanged DBus signal.

### ibus_bus_set_watch_ibus_signal ()

    void                ibus_bus_set_watch_ibus_signal      (IBusBus *bus,
                                                             gboolean watch);

Start or stop watching the GlobalEngineChanged IBus signal.

`bus` : | An IBusBus.
`watch` : | `TRUE` if you want ibusbus to emit "global-engine-changed" signal when ibus-daemon emits the GlobalEngineChanged IBus signal.

### ibus_bus_get_config ()

    IBusConfig *        ibus_bus_get_config                 (IBusBus *bus);

Get the config instance from IBusBus.

`bus` : | An IBusBus.
Returns : | An IBusConfig object which is configurable with `bus`. [transfer none]

## Signal Details

### The `"connected"` signal

    void                user_function                      (IBusBus *bus,
                                                            gpointer user_data)      : Run Last

Emitted when IBusBus is connected to ibus-daemon.

`bus` : | The IBusBus object which recevied the signal
`user_data` : | user data set when the signal handler was connected.

### The `"disconnected"` signal

    void                user_function                      (IBusBus *bus,
                                                            gpointer user_data)      : Run Last

Emitted when IBusBus is disconnected from ibus-daemon.

`bus` : | The IBusBus object which recevied the signal
`user_data` : | user data set when the signal handler was connected.

### The `"global-engine-changed"` signal

    void                user_function                      (IBusBus *bus,
                                                            gchar   *name,
                                                            gpointer user_data)      : Run Last

Emitted when global engine is changed.

`bus` : | The IBusBus object which recevied the signal
`name` : | The name of the new global engine.
`user_data` : | user data set when the signal handler was connected.

### The `"name-owner-changed"` signal

    void                user_function                      (IBusBus *bus,
                                                            gchar   *name,
                                                            gchar   *old_owner,
                                                            gchar   *new_owner,
                                                            gpointer user_data)      : Run Last

Emitted when D-Bus name owner is changed.

`bus` : | The IBusBus object which recevied the signal
`name` : | The name which ower is changed.
`old_owner` : | The unique bus name of the old owner.
`new_owner` : | The unique bus name of the new owner.
`user_data` : | user data set when the signal handler was connected.