gboolean
ibus_bus_register_component (IBusBus *bus,
IBusComponent *component)
{
g_assert (IBUS_IS_BUS (bus));
g_assert (IBUS_IS_COMPONENT (component));
gboolean result;
result = ibus_bus_call (bus,
IBUS_SERVICE_IBUS,
IBUS_PATH_IBUS,
IBUS_INTERFACE_IBUS,
"RegisterComponent",
IBUS_TYPE_COMPONENT, &component,
G_TYPE_INVALID,
G_TYPE_INVALID);
return result;
#if 0
IBusMessage *message, *reply;
IBusError *error;
IBusBusPrivate *priv;
priv = IBUS_BUS_GET_PRIVATE (bus);
message = ibus_message_new_method_call (IBUS_SERVICE_IBUS,
IBUS_PATH_IBUS,
IBUS_INTERFACE_IBUS,
"RegisterComponent");
ibus_message_append_args (message,
IBUS_TYPE_COMPONENT, &component,
G_TYPE_INVALID);
reply = ibus_connection_send_with_reply_and_block (
priv->connection,
message,
-1,
&error);
ibus_message_unref (message);
if (reply == NULL) {
g_warning ("%s : %s", error->name, error->message);
ibus_error_free (error);
return FALSE;
}
if ((error = ibus_error_from_message (reply)) != NULL) {
g_warning ("%s : %s", error->name, error->message);
ibus_error_free (error);
ibus_message_unref (reply);
return FALSE;
}
return TRUE;
#endif
}
IBusEngineDesc *
ibus_input_context_get_engine (IBusInputContext *context)
{
g_assert (IBUS_IS_INPUT_CONTEXT (context));
IBusMessage *reply_message;
IBusError *error = NULL;
IBusSerializable *object = NULL;
reply_message = ibus_proxy_call_with_reply_and_block ((IBusProxy *) context,
"GetEngine",
-1,
&error,
G_TYPE_INVALID);
if (!reply_message) {
g_debug ("%s: %s", error->name, error->message);
ibus_error_free (error);
return NULL;
}
if (!ibus_message_get_args (reply_message,
&error,
IBUS_TYPE_ENGINE_DESC, &object,
G_TYPE_INVALID)) {
g_debug ("%s: %s", error->name, error->message);
ibus_error_free (error);
ibus_message_unref (reply_message);
return NULL;
}
ibus_message_unref (reply_message);
return IBUS_ENGINE_DESC (object);
}
IBusInputContext *
ibus_bus_create_input_context (IBusBus *bus,
const gchar *client_name)
{
g_assert (IBUS_IS_BUS (bus));
g_assert (client_name != NULL);
g_return_val_if_fail (ibus_bus_is_connected (bus), NULL);
gchar *path;
DBusMessage *call = NULL;
DBusMessage *reply = NULL;
IBusError *error;
IBusInputContext *context = NULL;
IBusBusPrivate *priv;
priv = IBUS_BUS_GET_PRIVATE (bus);
call = ibus_message_new_method_call (IBUS_SERVICE_IBUS,
IBUS_PATH_IBUS,
IBUS_INTERFACE_IBUS,
"CreateInputContext");
ibus_message_append_args (call,
G_TYPE_STRING, &client_name,
G_TYPE_INVALID);
reply = ibus_connection_send_with_reply_and_block (priv->connection,
call,
-1,
&error);
ibus_message_unref (call);
if (reply == NULL) {
g_warning ("%s: %s", error->name, error->message);
ibus_error_free (error);
return NULL;
}
if ((error = ibus_error_new_from_message (reply)) != NULL) {
g_warning ("%s: %s", error->name, error->message);
ibus_message_unref (reply);
ibus_error_free (error);
return NULL;
}
if (!ibus_message_get_args (reply,
&error,
IBUS_TYPE_OBJECT_PATH, &path,
G_TYPE_INVALID)) {
g_warning ("%s: %s", error->name, error->message);
ibus_message_unref (reply);
ibus_error_free (error);
return NULL;
}
context = ibus_input_context_new (path, priv->connection);
ibus_message_unref (reply);
return context;
}
gboolean
ibus_input_context_is_enabled (IBusInputContext *context)
{
g_assert (IBUS_IS_INPUT_CONTEXT (context));
gboolean retval = FALSE;
IBusMessage *reply_message;
IBusError *error = NULL;
reply_message = ibus_proxy_call_with_reply_and_block ((IBusProxy *) context,
"IsEnabled",
-1,
&error,
G_TYPE_INVALID);
if (!reply_message) {
g_debug ("%s: %s", error->name, error->message);
ibus_error_free (error);
return FALSE;
}
if (!ibus_message_get_args (reply_message,
&error,
G_TYPE_BOOLEAN, &retval,
G_TYPE_INVALID)) {
g_debug ("%s: %s", error->name, error->message);
ibus_error_free (error);
retval = FALSE;
}
ibus_message_unref (reply_message);
return retval;
}
IBusMessage *
ibus_bus_call_with_reply_valist (IBusBus *bus,
const gchar *name,
const gchar *path,
const gchar *interface,
const gchar *member,
GType first_arg_type,
va_list va_args)
{
g_assert (IBUS_IS_BUS (bus));
g_assert (name != NULL);
g_assert (path != NULL);
g_assert (interface != NULL);
g_assert (member);
IBusMessage *message, *reply;
IBusError *error;
IBusBusPrivate *priv;
g_return_val_if_fail (ibus_bus_is_connected (bus), FALSE);
priv = IBUS_BUS_GET_PRIVATE (bus);
message = ibus_message_new_method_call (name, path, interface, member);
ibus_message_append_args_valist (message, first_arg_type, va_args);
reply = ibus_connection_send_with_reply_and_block (
priv->connection,
message,
-1,
&error);
ibus_message_unref (message);
if (reply == NULL) {
g_warning ("%s : %s", error->name, error->message);
ibus_error_free (error);
return NULL;
}
if ((error = ibus_error_new_from_message (reply)) != NULL) {
g_warning ("%s : %s", error->name, error->message);
ibus_error_free (error);
ibus_message_unref (reply);
return NULL;
}
return reply;
}
static void
bus_engine_proxy_process_key_event_reply_cb (IBusPendingCall *pending,
CallData *call_data)
{
IBusMessage *reply_message;
IBusError *error;
gboolean retval = FALSE;
reply_message = dbus_pending_call_steal_reply (pending);
if (reply_message == NULL) {
/* reply timeout */
IBusObject *connection;
connection = (IBusObject *) ibus_proxy_get_connection ((IBusProxy *)call_data->engine);
ibus_object_destroy (connection);
goto _out;
}
else if ((error = ibus_error_new_from_message (reply_message)) != NULL) {
if (g_strcmp0 (error->name, DBUS_ERROR_NO_REPLY) == 0) {
/* reply timeout */
IBusObject *connection;
connection = (IBusObject *) ibus_proxy_get_connection ((IBusProxy *)call_data->engine);
if (connection) {
ibus_object_destroy (connection);
}
}
g_warning ("%s: %s", error->name, error->message);
ibus_error_free (error);
goto _out;
}
if (!ibus_message_get_args (reply_message,
&error,
G_TYPE_BOOLEAN, &retval,
G_TYPE_INVALID)) {
g_warning ("%s: %s", error->name, error->message);
ibus_error_free (error);
goto _out;
}
_out:
if (reply_message) {
ibus_message_unref (reply_message);
}
g_object_unref (call_data->engine);
call_data->func (GINT_TO_POINTER (retval), call_data->user_data);
g_slice_free (CallData, call_data);
}
gboolean
ibus_bus_get_use_global_engine (IBusBus *bus)
{
g_assert (IBUS_IS_BUS (bus));
IBusMessage *reply = NULL;
IBusError *error = NULL;
gboolean use_global_engine = FALSE;
reply = ibus_bus_call_with_reply (bus,
IBUS_SERVICE_IBUS,
IBUS_PATH_IBUS,
IBUS_INTERFACE_IBUS,
"GetUseGlobalEngine",
G_TYPE_INVALID);
if (reply) {
if (!ibus_message_get_args (reply, &error, G_TYPE_BOOLEAN,
&use_global_engine, G_TYPE_INVALID)) {
g_warning ("%s: %s", error->name, error->message);
ibus_error_free (error);
}
ibus_message_unref (reply);
}
return use_global_engine;
}
gchar *
ibus_bus_get_name_owner (IBusBus *bus,
const gchar *name)
{
g_assert (IBUS_IS_BUS (bus));
gchar *owner = NULL;
IBusMessage *reply = NULL;
IBusError *error = NULL;
reply = ibus_bus_call_with_reply (bus,
DBUS_SERVICE_DBUS,
DBUS_PATH_DBUS,
DBUS_INTERFACE_DBUS,
"GetNameOwner",
G_TYPE_STRING, &name,
G_TYPE_INVALID);
if (reply) {
if (ibus_message_get_args (reply, &error, G_TYPE_STRING, &owner,
G_TYPE_INVALID)) {
owner = g_strdup (owner);
} else {
g_warning ("%s: %s", error->name, error->message);
ibus_error_free (error);
}
ibus_message_unref (reply);
}
return owner;
}
guint
ibus_bus_release_name (IBusBus *bus,
const gchar *name)
{
g_assert (IBUS_IS_BUS (bus));
IBusMessage *reply = NULL;
IBusError *error = NULL;
guint retval = 0;
reply = ibus_bus_call_with_reply (bus,
DBUS_SERVICE_DBUS,
DBUS_PATH_DBUS,
DBUS_INTERFACE_DBUS,
"ReleaseName",
G_TYPE_STRING, &name,
G_TYPE_INVALID);
if (reply) {
if (!ibus_message_get_args (reply, &error, G_TYPE_UINT, &retval,
G_TYPE_INVALID)) {
g_warning ("%s: %s", error->name, error->message);
ibus_error_free (error);
}
ibus_message_unref (reply);
}
return retval;
}
gchar *
ibus_bus_current_input_context(IBusBus *bus)
{
g_assert (IBUS_IS_BUS (bus));
g_return_val_if_fail (ibus_bus_is_connected (bus), NULL);
gchar *path = NULL;
IBusMessage *reply = NULL;
IBusError *error = NULL;
reply = ibus_bus_call_with_reply (bus,
IBUS_SERVICE_IBUS,
IBUS_PATH_IBUS,
IBUS_INTERFACE_IBUS,
"CurrentInputContext",
G_TYPE_INVALID);
if (reply) {
if (ibus_message_get_args (reply, &error,
IBUS_TYPE_OBJECT_PATH, &path,
G_TYPE_INVALID)) {
path = g_strdup (path);
} else {
g_warning ("%s: %s", error->name, error->message);
ibus_error_free (error);
}
ibus_message_unref (reply);
}
return path;
}
IBusEngineDesc *
ibus_bus_get_global_engine (IBusBus *bus)
{
g_assert (IBUS_IS_BUS (bus));
IBusMessage *reply = NULL;
IBusError *error = NULL;
IBusEngineDesc *global_engine = NULL;
reply = ibus_bus_call_with_reply (bus,
IBUS_SERVICE_IBUS,
IBUS_PATH_IBUS,
IBUS_INTERFACE_IBUS,
"GetGlobalEngine",
G_TYPE_INVALID);
if (reply) {
if (!ibus_message_get_args (reply, &error, IBUS_TYPE_ENGINE_DESC,
&global_engine, G_TYPE_INVALID)) {
g_warning ("%s: %s", error->name, error->message);
ibus_error_free (error);
}
ibus_message_unref (reply);
}
return global_engine;
}
const gchar *
ibus_proxy_get_unique_name (IBusProxy *proxy)
{
IBusProxyPrivate *priv;
priv = IBUS_PROXY_GET_PRIVATE (proxy);
if (priv->unique_name == NULL && priv->connection != NULL) {
IBusError *error;
gchar *owner;
if (!ibus_connection_call (priv->connection,
DBUS_SERVICE_DBUS,
DBUS_PATH_DBUS,
DBUS_INTERFACE_DBUS,
"GetNameOwner",
&error,
G_TYPE_STRING, &(priv->name),
G_TYPE_INVALID,
G_TYPE_STRING, &owner,
G_TYPE_INVALID)) {
g_warning ("%s: %s", error->name, error->message);
ibus_error_free (error);
}
priv->unique_name = g_strdup (owner);
}
return priv->unique_name;
}
static IBusMessage *
_dbus_release_name (BusDBusImpl *dbus,
IBusMessage *message,
BusConnection *connection)
{
IBusMessage *reply_message;
IBusError *error;
gchar *name;
guint retval;
if (!ibus_message_get_args (message,
&error,
G_TYPE_STRING, &name,
G_TYPE_INVALID)) {
reply_message = ibus_message_new_error (message,
error->name,
error->message);
ibus_error_free (error);
return reply_message;
}
reply_message = ibus_message_new_method_return (message);
if (bus_connection_remove_name (connection, name)) {
retval = 1;
}
else {
retval = 2;
}
ibus_message_append_args (message,
G_TYPE_UINT, &retval,
G_TYPE_INVALID);
return reply_message;
}
gboolean
ibus_bus_name_has_owner (IBusBus *bus,
const gchar *name)
{
g_assert (IBUS_IS_BUS (bus));
IBusMessage *reply = NULL;
IBusError *error = NULL;
gboolean retval = FALSE;
reply = ibus_bus_call_with_reply (bus,
DBUS_SERVICE_DBUS,
DBUS_PATH_DBUS,
DBUS_INTERFACE_DBUS,
"NameHasOwner",
G_TYPE_STRING, &name,
G_TYPE_INVALID);
if (reply) {
if (!ibus_message_get_args (reply, &error, G_TYPE_BOOLEAN, &retval,
G_TYPE_INVALID)) {
g_warning ("%s: %s", error->name, error->message);
ibus_error_free (error);
}
ibus_message_unref (reply);
}
return retval;
}
gboolean
ibus_config_get_value (IBusConfig *config,
const gchar *section,
const gchar *name,
GValue *value)
{
g_assert (IBUS_IS_CONFIG (config));
g_assert (section != NULL);
g_assert (name != NULL);
g_assert (value != NULL);
IBusMessage *reply;
IBusError *error;
gboolean retval;
reply = ibus_proxy_call_with_reply_and_block ((IBusProxy *) config,
"GetValue",
-1,
&error,
G_TYPE_STRING, §ion,
G_TYPE_STRING, &name,
G_TYPE_INVALID);
if (reply == NULL) {
g_warning ("%s: %s", error->name, error->message);
ibus_error_free (error);
return FALSE;
}
if ((error = ibus_error_new_from_message (reply)) != NULL) {
g_warning ("%s: %s", error->name, error->message);
ibus_error_free (error);
ibus_message_unref (reply);
return FALSE;
}
retval = ibus_message_get_args (reply,
&error,
G_TYPE_VALUE, value,
G_TYPE_INVALID);
ibus_message_unref (reply);
if (!retval) {
g_warning ("%s: %s", error->name, error->message);
return FALSE;
}
return TRUE;
}
void
bus_engine_proxy_process_key_event (BusEngineProxy *engine,
guint keyval,
guint keycode,
guint state,
GFunc return_cb,
gpointer user_data)
{
g_assert (BUS_IS_ENGINE_PROXY (engine));
g_assert (return_cb);
IBusPendingCall *pending = NULL;
CallData *call_data;
IBusError *error;
gboolean retval;
if (keycode != 0 && !BUS_DEFAULT_IBUS->use_sys_layout && engine->keymap != NULL) {
guint t = ibus_keymap_lookup_keysym (engine->keymap, keycode, state);
if (t != IBUS_VoidSymbol) {
keyval = t;
}
}
retval = ibus_proxy_call_with_reply ((IBusProxy *) engine,
"ProcessKeyEvent",
&pending,
g_dbus_timeout,
&error,
G_TYPE_UINT, &keyval,
G_TYPE_UINT, &keycode,
G_TYPE_UINT, &state,
G_TYPE_INVALID);
if (!retval) {
g_warning ("%s: %s", error->name, error->message);
ibus_error_free (error);
return_cb (GINT_TO_POINTER (FALSE), user_data);
return;
}
call_data = g_slice_new0 (CallData);
call_data->func = return_cb;
call_data->user_data = user_data;
g_object_ref (engine);
call_data->engine = engine;
retval = ibus_pending_call_set_notify (pending,
(IBusPendingCallNotifyFunction) bus_engine_proxy_process_key_event_reply_cb,
call_data,
NULL);
ibus_pending_call_unref (pending);
if (!retval) {
g_object_unref (call_data->engine);
g_slice_free (CallData, call_data);
g_warning ("%s : ProcessKeyEvent", DBUS_ERROR_NO_MEMORY);
return_cb (GINT_TO_POINTER (FALSE), user_data);
return;
}
}
static IBusMessage *
_dbus_add_match (BusDBusImpl *dbus,
IBusMessage *message,
BusConnection *connection)
{
IBusMessage *reply_message;
IBusError *error;
gboolean retval;
gchar *rule_text;
BusMatchRule *rule;
GList *link;
retval = ibus_message_get_args (message,
&error,
G_TYPE_STRING, &rule_text,
G_TYPE_INVALID);
if (!retval) {
reply_message = ibus_message_new_error (message,
error->name,
error->message);
ibus_error_free (error);
return reply_message;
}
rule = bus_match_rule_new (rule_text);
if (rule == NULL) {
reply_message = ibus_message_new_error_printf (message,
DBUS_ERROR_MATCH_RULE_INVALID,
"Parse rule [%s] failed",
rule_text);
return reply_message;
}
for (link = dbus->rules; link != NULL; link = link->next) {
if (bus_match_rule_is_equal (rule, BUS_MATCH_RULE (link->data))) {
bus_match_rule_add_recipient (BUS_MATCH_RULE (link->data), connection);
g_object_unref (rule);
rule = NULL;
break;
}
}
if (rule) {
bus_match_rule_add_recipient (rule, connection);
dbus->rules = g_list_append (dbus->rules, rule);
g_signal_connect (rule, "destroy", G_CALLBACK (_rule_destroy_cb), dbus);
}
reply_message = ibus_message_new_method_return (message);
return reply_message;
}
static IBusMessage *
_dbus_request_name (BusDBusImpl *dbus,
IBusMessage *message,
BusConnection *connection)
{
IBusMessage *reply_message;
IBusError *error;
gchar *name;
guint flags;
guint retval;
if (!ibus_message_get_args (message,
&error,
G_TYPE_STRING, &name,
G_TYPE_UINT, &flags,
G_TYPE_INVALID)) {
reply_message = ibus_message_new_error (message,
error->name,
error->message);
ibus_error_free (error);
return reply_message;
}
if (g_hash_table_lookup (dbus->names, name) != NULL) {
reply_message = ibus_message_new_error_printf (message,
DBUS_ERROR_FAILED,
"Name %s has owner",
name);
return reply_message;
}
retval = 1;
g_hash_table_insert (dbus->names,
(gpointer )bus_connection_add_name (connection, name),
connection);
reply_message = ibus_message_new_method_return (message);
ibus_message_append_args (reply_message,
G_TYPE_UINT, &retval,
G_TYPE_INVALID);
ibus_connection_send ((IBusConnection *) connection, reply_message);
ibus_message_unref (reply_message);
ibus_connection_flush ((IBusConnection *) connection);
g_signal_emit (dbus,
dbus_signals[NAME_OWNER_CHANGED],
0,
name,
"",
bus_connection_get_unique_name (connection));
return NULL;
}
IBusMessage *
ibus_connection_send_with_reply_and_block (IBusConnection *connection,
IBusMessage *message,
gint timeout_milliseconds,
IBusError **error)
{
g_assert (IBUS_IS_CONNECTION (connection));
g_assert (message != NULL);
g_assert (timeout_milliseconds > 0 || timeout_milliseconds == -1);
IBusError *_error;
IBusMessage *reply;
IBusConnectionPrivate *priv;
priv = IBUS_CONNECTION_GET_PRIVATE (connection);
_error = ibus_error_new ();
reply = dbus_connection_send_with_reply_and_block (priv->connection,
message,
timeout_milliseconds,
_error);
if (reply != NULL) {
g_signal_emit (connection,
connection_signals[IBUS_MESSAGE_SENT],
0,
message);
ibus_error_free (_error);
}
else {
if (error != NULL) {
*error = _error;
}
else {
ibus_error_free (_error);
}
}
return reply;
}
static IBusMessage *
ibus_connection_call_with_reply_valist (IBusConnection *connection,
const gchar *name,
const gchar *path,
const gchar *interface,
const gchar *member,
IBusError **error,
GType first_arg_type,
va_list va_args)
{
g_assert (IBUS_IS_CONNECTION (connection));
g_assert (name != NULL);
g_assert (path != NULL);
g_assert (interface != NULL);
g_assert (member != NULL);
g_assert (ibus_connection_is_connected (connection));
IBusConnectionPrivate *priv;
priv = IBUS_CONNECTION_GET_PRIVATE (connection);
IBusMessage *message, *reply;
IBusError *tmp_error;
message = ibus_message_new_method_call (name, path, interface, member);
ibus_message_append_args_valist (message, first_arg_type, va_args);
reply = ibus_connection_send_with_reply_and_block (
connection,
message,
-1,
error);
ibus_message_unref (message);
if (reply == NULL) {
return NULL;
}
if ((tmp_error = ibus_error_new_from_message (reply)) != NULL) {
if (error) {
*error = tmp_error;
}
else {
ibus_error_free (tmp_error);
}
ibus_message_unref (reply);
return NULL;
}
return reply;
}
static IBusMessage *
_dbus_get_name_owner (BusDBusImpl *dbus,
IBusMessage *message,
BusConnection *connection)
{
gchar *name;
BusConnection *owner;
gboolean retval;
const gchar *owner_name = NULL;
IBusMessage *reply_message;
IBusError *error;
retval = ibus_message_get_args (message,
&error,
G_TYPE_STRING, &name,
G_TYPE_INVALID);
if (! retval) {
reply_message = ibus_message_new_error (message,
error->name,
error->message);
ibus_error_free (error);
return reply_message;
}
if (g_strcmp0 (name, DBUS_SERVICE_DBUS) == 0 ||
g_strcmp0 (name, IBUS_SERVICE_IBUS) == 0) {
owner_name = name;
}
else {
owner = bus_dbus_impl_get_connection_by_name (dbus, name);
if (owner != NULL) {
owner_name = bus_connection_get_unique_name (owner);
}
}
if (owner_name != NULL) {
reply_message = ibus_message_new_method_return (message);
ibus_message_append_args (reply_message,
G_TYPE_STRING, &owner_name,
G_TYPE_INVALID);
}
else {
reply_message = ibus_message_new_error_printf (message,
DBUS_ERROR_NAME_HAS_NO_OWNER,
"Name '%s' does have owner",
name);
}
return reply_message;
}
static IBusMessage *
_dbus_remove_match (BusDBusImpl *dbus,
IBusMessage *message,
BusConnection *connection)
{
IBusMessage *reply_message;
IBusError *error;
gchar *rule_text;
BusMatchRule *rule;
GList *link;
if (!ibus_message_get_args (message,
&error,
G_TYPE_STRING, &rule_text,
G_TYPE_INVALID)) {
reply_message = ibus_message_new_error (message,
error->name,
error->message);
ibus_error_free (error);
return reply_message;
}
rule = bus_match_rule_new (rule_text);
if (rule == NULL ) {
reply_message = ibus_message_new_error_printf (message,
DBUS_ERROR_MATCH_RULE_INVALID,
"Parse rule [%s] failed",
rule_text);
return reply_message;
}
for (link = dbus->rules; link != NULL; link = link->next) {
if (bus_match_rule_is_equal (rule, BUS_MATCH_RULE (link->data))) {
bus_match_rule_remove_recipient (BUS_MATCH_RULE (link->data), connection);
break;
}
}
g_object_unref (rule);
reply_message = ibus_message_new_method_return (message);
return reply_message;
}
static IBusMessage *
_dbus_name_has_owner (BusDBusImpl *dbus,
IBusMessage *message,
BusConnection *connection)
{
gchar *name;
gboolean retval;
gboolean has_owner;
IBusMessage *reply_message;
IBusError *error;
retval = ibus_message_get_args (message,
&error,
G_TYPE_STRING, &name,
G_TYPE_INVALID);
if (! retval) {
reply_message = ibus_message_new_error (message,
error->name,
error->message);
ibus_error_free (error);
return reply_message;
}
if (name[0] == ':') {
has_owner = g_hash_table_lookup (dbus->unique_names, name) != NULL;
}
else {
has_owner = g_hash_table_lookup (dbus->names, name) != NULL;
}
reply_message = ibus_message_new_method_return (message);
ibus_message_append_args (reply_message,
G_TYPE_BOOLEAN, &has_owner,
G_TYPE_INVALID);
return reply_message;
}
gboolean
ibus_proxy_handle_signal (IBusProxy *proxy,
DBusMessage *message)
{
g_assert (IBUS_IS_PROXY (proxy));
g_assert (message != NULL);
gboolean retval = FALSE;
IBusProxyPrivate *priv;
priv = IBUS_PROXY_GET_PRIVATE (proxy);
if (ibus_message_is_signal (message, DBUS_SERVICE_DBUS, "NameOwnerChanged")) {
gchar *name, *old_name, *new_name;
IBusError *error;
if (!ibus_message_get_args (message,
&error,
G_TYPE_STRING, &name,
G_TYPE_STRING, &old_name,
G_TYPE_STRING, &new_name,
G_TYPE_INVALID)) {
g_warning ("%s :%s", error->name, error->message);
ibus_error_free (error);
}
if (g_strcmp0 (priv->unique_name, old_name) == 0) {
ibus_object_destroy (IBUS_OBJECT (proxy));
return FALSE;
}
}
if (g_strcmp0 (ibus_message_get_path (message), priv->path) == 0) {
g_signal_emit (proxy, proxy_signals[IBUS_SIGNAL], 0, message, &retval);
}
return retval;
}
const gchar *
ibus_bus_hello (IBusBus *bus)
{
g_assert (IBUS_IS_BUS (bus));
gchar *unique_name = NULL;
IBusMessage *reply = NULL;
IBusError *error = NULL;
IBusBusPrivate *priv;
priv = IBUS_BUS_GET_PRIVATE (bus);
g_free (priv->unique_name);
priv->unique_name = NULL;
reply = ibus_bus_call_with_reply (bus,
DBUS_SERVICE_DBUS,
DBUS_PATH_DBUS,
DBUS_INTERFACE_DBUS,
"Hello",
G_TYPE_INVALID);
if (reply) {
if (ibus_message_get_args (reply, &error, G_TYPE_STRING, &unique_name,
G_TYPE_INVALID)) {
priv->unique_name = g_strdup (unique_name);
} else {
g_warning ("%s: %s", error->name, error->message);
ibus_error_free (error);
}
ibus_message_unref (reply);
}
return priv->unique_name;
}
static gboolean
ibus_config_service_ibus_message (IBusConfigService *config,
IBusConnection *connection,
IBusMessage *message)
{
g_assert (IBUS_IS_CONFIG_SERVICE (config));
g_assert (IBUS_IS_CONNECTION (connection));
g_assert (message != NULL);
IBusMessage *reply = NULL;
if (ibus_message_is_method_call (message, IBUS_INTERFACE_CONFIG, "SetValue")) {
gchar *section;
gchar *name;
GValue value = { 0 };
IBusError *error = NULL;
gboolean retval;
retval = ibus_message_get_args (message,
&error,
G_TYPE_STRING, §ion,
G_TYPE_STRING, &name,
G_TYPE_VALUE, &value,
G_TYPE_INVALID);
if (!retval) {
reply = ibus_message_new_error_printf (message,
DBUS_ERROR_INVALID_ARGS,
"Can not parse arguments 1 of SetValue");
ibus_error_free (error);
}
else if (!IBUS_CONFIG_SERVICE_GET_CLASS (config)->set_value (config, section, name, &value, &error)) {
reply = ibus_message_new_error (message,
error->name,
error->message);
ibus_error_free (error);
}
else {
reply = ibus_message_new_method_return (message);
}
}
else if (ibus_message_is_method_call (message, IBUS_INTERFACE_CONFIG, "GetValue")) {
gchar *section;
gchar *name;
GValue value = { 0 };
IBusError *error = NULL;
gboolean retval;
retval = ibus_message_get_args (message,
&error,
G_TYPE_STRING, §ion,
G_TYPE_STRING, &name,
G_TYPE_INVALID);
if (!retval) {
reply = ibus_message_new_error (message,
error->name,
error->message);
ibus_error_free (error);
}
else if (!IBUS_CONFIG_SERVICE_GET_CLASS (config)->get_value (config, section, name, &value, &error)) {
reply = ibus_message_new_error (message,
error->name,
error->message);
ibus_error_free (error);
}
else {
reply = ibus_message_new_method_return (message);
ibus_message_append_args (reply,
G_TYPE_VALUE, &value,
G_TYPE_INVALID);
g_value_unset (&value);
}
}
if (reply) {
ibus_connection_send (connection, reply);
ibus_message_unref (reply);
return TRUE;
}
return parent_class->ibus_message ((IBusService *) config, connection, message);
}
static gboolean
bus_engine_proxy_ibus_signal (IBusProxy *proxy,
IBusMessage *message)
{
g_assert (BUS_IS_ENGINE_PROXY (proxy));
g_assert (message != NULL);
g_assert (ibus_message_get_type (message) == DBUS_MESSAGE_TYPE_SIGNAL);
const gchar *interface;
const gchar *name;
BusEngineProxy *engine;
IBusError *error;
gint i;
static const struct {
const gchar *member;
const guint signal_id;
} signals [] = {
{ "ShowPreeditText", SHOW_PREEDIT_TEXT },
{ "HidePreeditText", HIDE_PREEDIT_TEXT },
{ "ShowAuxiliaryText", SHOW_AUXILIARY_TEXT },
{ "HideAuxiliaryText", HIDE_AUXILIARY_TEXT },
{ "ShowLookupTable", SHOW_LOOKUP_TABLE },
{ "HideLookupTable", HIDE_LOOKUP_TABLE },
{ "PageUpLookupTable", PAGE_UP_LOOKUP_TABLE },
{ "PageDownLookupTable", PAGE_DOWN_LOOKUP_TABLE },
{ "CursorUpLookupTable", CURSOR_UP_LOOKUP_TABLE },
{ "CursorDownLookupTable", CURSOR_DOWN_LOOKUP_TABLE },
};
engine = BUS_ENGINE_PROXY (proxy);
interface = ibus_message_get_interface (message);
name = ibus_message_get_member (message);
if (interface != NULL && g_strcmp0 (interface, IBUS_INTERFACE_ENGINE) != 0)
return FALSE;
for (i = 0; i < G_N_ELEMENTS (signals); i++) {
if (g_strcmp0 (name, signals[i].member) == 0) {
g_signal_emit (engine, engine_signals[signals[i].signal_id], 0);
goto handled;
}
}
if (g_strcmp0 (name, "CommitText") == 0) {
IBusText *text;
gboolean retval;
retval = ibus_message_get_args (message,
&error,
IBUS_TYPE_TEXT, &text,
G_TYPE_INVALID);
if (!retval)
goto failed;
g_signal_emit (engine, engine_signals[COMMIT_TEXT], 0, text);
g_object_unref (text);
}
else if (g_strcmp0 (name, "ForwardKeyEvent") == 0) {
guint32 keyval;
guint32 keycode;
guint32 states;
gboolean retval;
retval = ibus_message_get_args (message,
&error,
G_TYPE_UINT, &keyval,
G_TYPE_UINT, &keycode,
G_TYPE_UINT, &states,
G_TYPE_INVALID);
if (!retval)
goto failed;
g_signal_emit (engine,
engine_signals[FORWARD_KEY_EVENT],
0,
keyval,
keycode,
states);
}
else if (g_strcmp0 (name, "DeleteSurroundingText") == 0) {
gint offset_from_cursor;
guint nchars;
gboolean retval;
retval = ibus_message_get_args (message,
&error,
G_TYPE_INT, &offset_from_cursor,
G_TYPE_UINT, &nchars,
G_TYPE_INVALID);
if (!retval)
goto failed;
g_signal_emit (engine, engine_signals[DELETE_SURROUNDING_TEXT], 0, offset_from_cursor, nchars);
}
else if (g_strcmp0 (name, "UpdatePreeditText") == 0) {
IBusText *text;
gint cursor_pos;
gboolean visible;
gboolean retval;
guint mode;
retval = ibus_message_get_args (message,
&error,
IBUS_TYPE_TEXT, &text,
G_TYPE_UINT, &cursor_pos,
G_TYPE_BOOLEAN, &visible,
G_TYPE_UINT, &mode,
G_TYPE_INVALID);
if (!retval)
goto failed;
g_signal_emit (engine, engine_signals[UPDATE_PREEDIT_TEXT], 0,
text, cursor_pos, visible, mode);
if (g_object_is_floating (text))
g_object_unref (text);
}
else if (g_strcmp0 (name, "UpdateAuxiliaryText") == 0) {
IBusText *text;
gboolean visible;
gboolean retval;
retval = ibus_message_get_args (message,
&error,
IBUS_TYPE_TEXT, &text,
G_TYPE_BOOLEAN, &visible,
G_TYPE_INVALID);
if (!retval)
goto failed;
g_signal_emit (engine, engine_signals[UPDATE_AUXILIARY_TEXT], 0, text, visible);
if (g_object_is_floating (text))
g_object_unref (text);
}
else if (g_strcmp0 (name, "UpdateLookupTable") == 0) {
IBusLookupTable *table;
gboolean visible;
gboolean retval;
retval = ibus_message_get_args (message,
&error,
IBUS_TYPE_LOOKUP_TABLE, &table,
G_TYPE_BOOLEAN, &visible,
G_TYPE_INVALID);
if (!retval)
goto failed;
g_signal_emit (engine, engine_signals[UPDATE_LOOKUP_TABLE], 0, table, visible);
if (g_object_is_floating (table))
g_object_unref (table);
}
else if (g_strcmp0 (name, "RegisterProperties") == 0) {
gboolean retval;
IBusPropList *prop_list;
retval = ibus_message_get_args (message,
&error,
IBUS_TYPE_PROP_LIST, &prop_list,
G_TYPE_INVALID);
if (!retval) {
goto failed;
}
g_signal_emit (engine, engine_signals[REGISTER_PROPERTIES], 0, prop_list);
if (g_object_is_floating (prop_list))
g_object_unref (prop_list);
}
else if (g_strcmp0 (name, "UpdateProperty") == 0) {
IBusProperty *prop;
gboolean retval;
retval = ibus_message_get_args (message,
&error,
IBUS_TYPE_PROPERTY, &prop,
G_TYPE_INVALID);
if (!retval)
goto failed;
g_signal_emit (engine, engine_signals[UPDATE_PROPERTY], 0, prop);
if (g_object_is_floating (prop))
g_object_unref (prop);
}
else
return FALSE;
handled:
g_signal_stop_emission_by_name (engine, "ibus-signal");
return TRUE;
failed:
g_warning ("%s: %s", error->name, error->message);
ibus_error_free (error);
return FALSE;
}
static gboolean
bus_panel_proxy_ibus_signal (IBusProxy *proxy,
IBusMessage *message)
{
g_assert (BUS_IS_PANEL_PROXY (proxy));
g_assert (message != NULL);
BusPanelProxy *panel;
IBusError *error;
gint i;
static const struct {
const gchar *member;
const guint signal_id;
} signals [] = {
{ "PageUp", PAGE_UP },
{ "PageDown", PAGE_DOWN },
{ "CursorUp", CURSOR_UP },
{ "CursorDown", CURSOR_DOWN },
};
panel = BUS_PANEL_PROXY (proxy);
for (i = 0; i < G_N_ELEMENTS (signals); i++) {
if (ibus_message_is_signal (message, IBUS_INTERFACE_PANEL, signals[i].member)) {
g_signal_emit (panel, panel_signals[signals[i].signal_id], 0);
goto handled;
}
}
if (ibus_message_is_signal (message, IBUS_INTERFACE_PANEL, "CandidateClicked")) {
guint index, button, state;
gboolean retval;
retval = ibus_message_get_args (message,
&error,
G_TYPE_UINT, &index,
G_TYPE_UINT, &button,
G_TYPE_UINT, &state,
G_TYPE_INVALID);
if (!retval)
goto failed;
g_signal_emit (panel, panel_signals[CANDIDATE_CLICKED], 0, index, button, state);
}
else if (ibus_message_is_signal (message, IBUS_INTERFACE_PANEL, "PropertyActivate")) {
gchar *prop_name;
gint prop_state;
gboolean retval;
retval = ibus_message_get_args (message,
&error,
G_TYPE_STRING, &prop_name,
G_TYPE_INT, &prop_state,
G_TYPE_INVALID);
if (!retval)
goto failed;
g_signal_emit (panel, panel_signals[PROPERTY_ACTIVATE], 0, prop_name, prop_state);
}
else if (ibus_message_is_signal (message, IBUS_INTERFACE_PANEL, "PropertyShow")) {
gchar *prop_name;
gboolean retval;
retval = ibus_message_get_args (message,
&error,
G_TYPE_STRING, &prop_name,
G_TYPE_INVALID);
if (!retval)
goto failed;
g_signal_emit (panel, panel_signals[PROPERTY_SHOW], 0, prop_name);
}
else if (ibus_message_is_signal (message, IBUS_INTERFACE_PANEL, "PropertyHide")) {
gchar *prop_name;
gboolean retval;
retval = ibus_message_get_args (message,
&error,
G_TYPE_STRING, &prop_name,
G_TYPE_INVALID);
if (!retval)
goto failed;
g_signal_emit (panel, panel_signals[PROPERTY_HIDE], 0, prop_name);
}
handled:
g_signal_stop_emission_by_name (panel, "ibus-signal");
return TRUE;
failed:
g_warning ("%s: %s", error->name, error->message);
ibus_error_free (error);
return FALSE;
}
static void
ibus_proxy_destroy (IBusProxy *proxy)
{
IBusProxyPrivate *priv;
priv = IBUS_PROXY_GET_PRIVATE (proxy);
if (priv->connection) {
g_signal_handlers_disconnect_by_func (priv->connection,
(GCallback) _connection_ibus_signal_cb,
proxy);
g_signal_handlers_disconnect_by_func (priv->connection,
(GCallback) _connection_destroy_cb,
proxy);
if (priv->name != NULL) {
IBusError *error;
gchar *rule;
rule = g_strdup_printf ("type='signal',"
"sender='" DBUS_SERVICE_DBUS "',"
"path='" DBUS_PATH_DBUS "',"
"interface='" DBUS_INTERFACE_DBUS "',"
"member='NameOwnerChanged',"
"arg0='%s'",
priv->unique_name);
if (!ibus_connection_call (priv->connection,
DBUS_SERVICE_DBUS,
DBUS_PATH_DBUS,
DBUS_INTERFACE_DBUS,
"RemoveMatch",
&error,
G_TYPE_STRING, &rule,
G_TYPE_INVALID,
G_TYPE_INVALID)) {
g_warning ("%s: %s", error->name, error->message);
ibus_error_free (error);
}
g_free (rule);
rule = g_strdup_printf ("type='signal',"
"sender='%s',"
"path='%s'",
priv->unique_name,
priv->path);
if (!ibus_connection_call (priv->connection,
DBUS_SERVICE_DBUS,
DBUS_PATH_DBUS,
DBUS_INTERFACE_DBUS,
"RemoveMatch",
&error,
G_TYPE_STRING, &rule,
G_TYPE_INVALID,
G_TYPE_INVALID)) {
g_warning ("%s: %s", error->name, error->message);
ibus_error_free (error);
}
g_free (rule);
}
}
g_free (priv->name);
g_free (priv->unique_name);
g_free (priv->path);
g_free (priv->interface);
priv->name = NULL;
priv->path = NULL;
priv->interface = NULL;
if (priv->connection) {
g_object_unref (priv->connection);
priv->connection = NULL;
}
IBUS_OBJECT_CLASS(ibus_proxy_parent_class)->destroy (IBUS_OBJECT (proxy));
}
static GObject *
ibus_proxy_constructor (GType type,
guint n_construct_params,
GObjectConstructParam *construct_params)
{
GObject *obj;
IBusProxy *proxy;
IBusProxyPrivate *priv;
obj = G_OBJECT_CLASS (ibus_proxy_parent_class)->constructor (type, n_construct_params, construct_params);
proxy = IBUS_PROXY (obj);
priv = IBUS_PROXY_GET_PRIVATE (proxy);
if (priv->connection == NULL) {
g_object_unref (proxy);
return NULL;
}
if (priv->name != NULL) {
IBusError *error;
gchar *rule;
if (ibus_proxy_get_unique_name (proxy) == NULL) {
g_object_unref (proxy);
return NULL;
}
rule = g_strdup_printf ("type='signal',"
"sender='" DBUS_SERVICE_DBUS "',"
"path='" DBUS_PATH_DBUS "',"
"interface='" DBUS_INTERFACE_DBUS "',"
"member='NameOwnerChanged',"
"arg0='%s'",
priv->unique_name);
if (!ibus_connection_call (priv->connection,
DBUS_SERVICE_DBUS,
DBUS_PATH_DBUS,
DBUS_INTERFACE_DBUS,
"AddMatch",
&error,
G_TYPE_STRING, &rule,
G_TYPE_INVALID,
G_TYPE_INVALID)) {
g_warning ("%s: %s", error->name, error->message);
ibus_error_free (error);
}
g_free (rule);
rule = g_strdup_printf ("type='signal',"
"sender='%s',"
"path='%s'",
priv->unique_name,
priv->path);
if (!ibus_connection_call (priv->connection,
DBUS_SERVICE_DBUS,
DBUS_PATH_DBUS,
DBUS_INTERFACE_DBUS,
"AddMatch",
&error,
G_TYPE_STRING, &rule,
G_TYPE_INVALID,
G_TYPE_INVALID)) {
g_warning ("%s: %s", error->name, error->message);
ibus_error_free (error);
}
g_free (rule);
}
g_signal_connect (priv->connection,
"ibus-signal",
(GCallback) _connection_ibus_signal_cb,
proxy);
g_signal_connect (priv->connection,
"destroy",
(GCallback) _connection_destroy_cb,
proxy);
return obj;
}
