wp
/
xed
1
0
Fork 0
Code Issues Pull Requests Projects Releases 1 Wiki Activity
xed/xed/xed-message-bus.c

1159 lines
32 KiB
C
Raw Blame History

#include "xed-message-bus.h"
#include <string.h>
#include <stdarg.h>
#include <gobject/gvaluecollector.h>
/**
* XedMessageCallback:
* @bus: the #XedMessageBus on which the message was sent
* @message: the #XedMessage which was sent
* @userdata: the supplied user data when connecting the callback
*
* Callback signature used for connecting callback functions to be called
* when a message is received (see xed_message_bus_connect()).
*
*/
/**
* SECTION:xed-message-bus
* @short_description: internal message communication bus
* @include: xed/xed-message-bus.h
*
* xed has a communication bus very similar to DBus. Its primary use is to
* allow easy communication between plugins, but it can also be used to expose
* xed functionality to external applications by providing DBus bindings for
* the internal xed message bus.
*
* There are two different communication busses available. The default bus
* (see xed_message_bus_get_default()) is an application wide communication
* bus. In addition, each #XedWindow has a separate, private bus
* (see xed_window_get_message_bus()). This makes it easier for plugins to
* communicate to other plugins in the same window.
*
* The concept of the message bus is very simple. You can register a message
* type on the bus, specified as a Method at a specific Object Path with a
* certain set of Method Arguments. You can then connect callback functions
* for this message type on the bus. Whenever a message with the Object Path
* and Method for which callbacks are connected is sent over the bus, the
* callbacks are called. There is no distinction between Methods and Signals
* (signals are simply messages where sender and receiver have switched places).
*
* <example>
* <title>Registering a message type</title>
* <programlisting>
* XedMessageBus *bus = xed_message_bus_get_default ();
*
* // Register 'method' at '/plugins/example' with one required
* // string argument 'arg1'
* XedMessageType *message_type = xed_message_bus_register ("/plugins/example", "method",
* 0,
* "arg1", G_TYPE_STRING,
* NULL);
* </programlisting>
* </example>
* <example>
* <title>Connecting a callback</title>
* <programlisting>
* static void
* example_method_cb (XedMessageBus *bus,
* XedMessage *message,
* gpointer userdata)
* {
* gchar *arg1 = NULL;
*
* xed_message_get (message, "arg1", &arg1, NULL);
* g_message ("Evoked /plugins/example.method with: %s", arg1);
* g_free (arg1);
* }
*
* XedMessageBus *bus = xed_message_bus_get_default ();
*
* guint id = xed_message_bus_connect (bus,
* "/plugins/example", "method",
* example_method_cb,
* NULL,
* NULL);
*
* </programlisting>
* </example>
* <example>
* <title>Sending a message</title>
* <programlisting>
* XedMessageBus *bus = xed_message_bus_get_default ();
*
* xed_message_bus_send (bus,
* "/plugins/example", "method",
* "arg1", "Hello World",
* NULL);
* </programlisting>
* </example>
*/
#define XED_MESSAGE_BUS_GET_PRIVATE(object)(G_TYPE_INSTANCE_GET_PRIVATE((object), XED_TYPE_MESSAGE_BUS, XedMessageBusPrivate))
typedef struct
{
gchar *object_path;
gchar *method;
GList *listeners;
} Message;
typedef struct
{
guint id;
gboolean blocked;
GDestroyNotify destroy_data;
XedMessageCallback callback;
gpointer userdata;
} Listener;
typedef struct
{
Message *message;
GList *listener;
} IdMap;
struct _XedMessageBusPrivate
{
GHashTable *messages;
GHashTable *idmap;
GList *message_queue;
guint idle_id;
guint next_id;
GHashTable *types; /* mapping from identifier to XedMessageType */
};
/* signals */
enum
{
DISPATCH,
REGISTERED,
UNREGISTERED,
LAST_SIGNAL
};
static guint message_bus_signals[LAST_SIGNAL] = { 0 };
static void xed_message_bus_dispatch_real (XedMessageBus *bus,
XedMessage *message);
G_DEFINE_TYPE (XedMessageBus, xed_message_bus, G_TYPE_OBJECT)
static void
listener_free (Listener *listener)
{
if (listener->destroy_data)
{
listener->destroy_data (listener->userdata);
}
g_free (listener);
}
static void
message_free (Message *message)
{
g_free (message->method);
g_free (message->object_path);
g_list_foreach (message->listeners, (GFunc)listener_free, NULL);
g_list_free (message->listeners);
g_free (message);
}
static void
message_queue_free (GList *queue)
{
g_list_foreach (queue, (GFunc)g_object_unref, NULL);
g_list_free (queue);
}
static void
xed_message_bus_finalize (GObject *object)
{
XedMessageBus *bus = XED_MESSAGE_BUS (object);
if (bus->priv->idle_id != 0)
{
g_source_remove (bus->priv->idle_id);
}
message_queue_free (bus->priv->message_queue);
g_hash_table_destroy (bus->priv->messages);
g_hash_table_destroy (bus->priv->idmap);
g_hash_table_destroy (bus->priv->types);
G_OBJECT_CLASS (xed_message_bus_parent_class)->finalize (object);
}
static void
xed_message_bus_class_init (XedMessageBusClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->finalize = xed_message_bus_finalize;
klass->dispatch = xed_message_bus_dispatch_real;
/**
* XedMessageBus::dispatch:
* @bus: a #XedMessageBus
* @message: the #XedMessage to dispatch
*
* The "dispatch" signal is emitted when a message is to be dispatched.
* The message is dispatched in the default handler of this signal.
* Primary use of this signal is to customize the dispatch of a message
* (for instance to automatically dispatch all messages over DBus).
*2
*/
message_bus_signals[DISPATCH] =
g_signal_new ("dispatch",
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (XedMessageBusClass, dispatch),
NULL, NULL,
g_cclosure_marshal_VOID__OBJECT,
G_TYPE_NONE,
1,
XED_TYPE_MESSAGE);
/**
* XedMessageBus::registered:
* @bus: a #XedMessageBus
* @message_type: the registered #XedMessageType
*
* The "registered" signal is emitted when a message has been registered
* on the bus.
*
*/
message_bus_signals[REGISTERED] =
g_signal_new ("registered",
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (XedMessageBusClass, registered),
NULL, NULL,
g_cclosure_marshal_VOID__BOXED,
G_TYPE_NONE,
1,
XED_TYPE_MESSAGE_TYPE);
/**
* XedMessageBus::unregistered:
* @bus: a #XedMessageBus
* @message_type: the unregistered #XedMessageType
*
* The "unregistered" signal is emitted when a message has been
* unregistered from the bus.
*
*/
message_bus_signals[UNREGISTERED] =
g_signal_new ("unregistered",
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (XedMessageBusClass, unregistered),
NULL, NULL,
g_cclosure_marshal_VOID__BOXED,
G_TYPE_NONE,
1,
XED_TYPE_MESSAGE_TYPE);
g_type_class_add_private (object_class, sizeof(XedMessageBusPrivate));
}
static Message *
message_new (XedMessageBus *bus,
const gchar *object_path,
const gchar *method)
{
Message *message = g_new (Message, 1);
message->object_path = g_strdup (object_path);
message->method = g_strdup (method);
message->listeners = NULL;
g_hash_table_insert (bus->priv->messages, xed_message_type_identifier (object_path, method), message);
return message;
}
static Message *
lookup_message (XedMessageBus *bus,
const gchar *object_path,
const gchar *method,
gboolean create)
{
gchar *identifier;
Message *message;
identifier = xed_message_type_identifier (object_path, method);
message = (Message *)g_hash_table_lookup (bus->priv->messages, identifier);
g_free (identifier);
if (!message && !create)
{
return NULL;
}
if (!message)
{
message = message_new (bus, object_path, method);
}
return message;
}
static guint
add_listener (XedMessageBus *bus,
Message *message,
XedMessageCallback callback,
gpointer userdata,
GDestroyNotify destroy_data)
{
Listener *listener;
IdMap *idmap;
listener = g_new (Listener, 1);
listener->id = ++bus->priv->next_id;
listener->callback = callback;
listener->userdata = userdata;
listener->blocked = FALSE;
listener->destroy_data = destroy_data;
message->listeners = g_list_append (message->listeners, listener);
idmap = g_new (IdMap, 1);
idmap->message = message;
idmap->listener = g_list_last (message->listeners);
g_hash_table_insert (bus->priv->idmap, GINT_TO_POINTER (listener->id), idmap);
return listener->id;
}
static void
remove_listener (XedMessageBus *bus,
Message *message,
GList *listener)
{
Listener *lst;
lst = (Listener *)listener->data;
/* remove from idmap */
g_hash_table_remove (bus->priv->idmap, GINT_TO_POINTER (lst->id));
listener_free (lst);
/* remove from list of listeners */
message->listeners = g_list_delete_link (message->listeners, listener);
if (!message->listeners)
{
/* remove message because it does not have any listeners */
g_hash_table_remove (bus->priv->messages, message);
}
}
static void
block_listener (XedMessageBus *bus,
Message *message,
GList *listener)
{
Listener *lst;
lst = (Listener *)listener->data;
lst->blocked = TRUE;
}
static void
unblock_listener (XedMessageBus *bus,
Message *message,
GList *listener)
{
Listener *lst;
lst = (Listener *)listener->data;
lst->blocked = FALSE;
}
static void
dispatch_message_real (XedMessageBus *bus,
Message *msg,
XedMessage *message)
{
GList *item;
for (item = msg->listeners; item; item = item->next)
{
Listener *listener = (Listener *)item->data;
if (!listener->blocked)
{
listener->callback (bus, message, listener->userdata);
}
}
}
static void
xed_message_bus_dispatch_real (XedMessageBus *bus,
XedMessage *message)
{
const gchar *object_path;
const gchar *method;
Message *msg;
object_path = xed_message_get_object_path (message);
method = xed_message_get_method (message);
msg = lookup_message (bus, object_path, method, FALSE);
if (msg)
{
dispatch_message_real (bus, msg, message);
}
}
static void
dispatch_message (XedMessageBus *bus,
XedMessage *message)
{
g_signal_emit (bus, message_bus_signals[DISPATCH], 0, message);
}
static gboolean
idle_dispatch (XedMessageBus *bus)
{
GList *list;
GList *item;
/* make sure to set idle_id to 0 first so that any new async messages
will be queued properly */
bus->priv->idle_id = 0;
/* reverse queue to get correct delivery order */
list = g_list_reverse (bus->priv->message_queue);
bus->priv->message_queue = NULL;
for (item = list; item; item = item->next)
{
XedMessage *msg = XED_MESSAGE (item->data);
dispatch_message (bus, msg);
}
message_queue_free (list);
return FALSE;
}
typedef void (*MatchCallback) (XedMessageBus *, Message *, GList *);
static void
process_by_id (XedMessageBus *bus,
guint id,
MatchCallback processor)
{
IdMap *idmap;
idmap = (IdMap *)g_hash_table_lookup (bus->priv->idmap, GINT_TO_POINTER (id));
if (idmap == NULL)
{
g_warning ("No handler registered with id `%d'", id);
return;
}
processor (bus, idmap->message, idmap->listener);
}
static void
process_by_match (XedMessageBus *bus,
const gchar *object_path,
const gchar *method,
XedMessageCallback callback,
gpointer userdata,
MatchCallback processor)
{
Message *message;
GList *item;
message = lookup_message (bus, object_path, method, FALSE);
if (!message)
{
g_warning ("No such handler registered for %s.%s", object_path, method);
return;
}
for (item = message->listeners; item; item = item->next)
{
Listener *listener = (Listener *)item->data;
if (listener->callback == callback && listener->userdata == userdata)
{
processor (bus, message, item);
return;
}
}
g_warning ("No such handler registered for %s.%s", object_path, method);
}
static void
xed_message_bus_init (XedMessageBus *self)
{
self->priv = XED_MESSAGE_BUS_GET_PRIVATE (self);
self->priv->messages = g_hash_table_new_full (g_str_hash,
g_str_equal,
(GDestroyNotify)g_free,
(GDestroyNotify)message_free);
self->priv->idmap = g_hash_table_new_full (g_direct_hash,
g_direct_equal,
NULL,
(GDestroyNotify)g_free);
self->priv->types = g_hash_table_new_full (g_str_hash,
g_str_equal,
(GDestroyNotify)g_free,
(GDestroyNotify)xed_message_type_unref);
}
/**
* xed_message_bus_get_default:
*
* Get the default application #XedMessageBus.
*
* Return value: (transfer none): the default #XedMessageBus
*
*/
XedMessageBus *
xed_message_bus_get_default (void)
{
static XedMessageBus *default_bus = NULL;
if (G_UNLIKELY (default_bus == NULL))
{
default_bus = g_object_new (XED_TYPE_MESSAGE_BUS, NULL);
g_object_add_weak_pointer (G_OBJECT (default_bus), (gpointer) &default_bus);
}
return default_bus;
}
/**
* xed_message_bus_new:
*
* Create a new message bus. Use xed_message_bus_get_default() to get the
* default, application wide, message bus. Creating a new bus is useful for
* associating a specific bus with for instance a #XedWindow.
*
* Return value: a new #XedMessageBus
*
*/
XedMessageBus *
xed_message_bus_new (void)
{
return XED_MESSAGE_BUS (g_object_new (XED_TYPE_MESSAGE_BUS, NULL));
}
/**
* xed_message_bus_lookup:
* @bus: a #XedMessageBus
* @object_path: the object path
* @method: the method
*
* Get the registered #XedMessageType for @method at @object_path. The
* returned #XedMessageType is owned by the bus and should not be unreffed.
*
* Return value: the registered #XedMessageType or %NULL if no message type
* is registered for @method at @object_path
*
*/
XedMessageType *
xed_message_bus_lookup (XedMessageBus *bus,
const gchar *object_path,
const gchar *method)
{
gchar *identifier;
XedMessageType *message_type;
g_return_val_if_fail (XED_IS_MESSAGE_BUS (bus), NULL);
g_return_val_if_fail (object_path != NULL, NULL);
g_return_val_if_fail (method != NULL, NULL);
identifier = xed_message_type_identifier (object_path, method);
message_type = XED_MESSAGE_TYPE (g_hash_table_lookup (bus->priv->types, identifier));
g_free (identifier);
return message_type;
}
/**
* xed_message_bus_register:
* @bus: a #XedMessageBus
* @object_path: the object path
* @method: the method to register
* @num_optional: the number of optional arguments
* @...: NULL terminated list of key/gtype method argument pairs
*
* Register a message on the bus. A message must be registered on the bus before
* it can be send. This function registers the type arguments for @method at
* @object_path. The arguments are specified with the variable arguments which
* should contain pairs of const gchar *key and GType terminated by %NULL. The
* last @num_optional arguments are registered as optional (and are thus not
* required when sending a message).
*
* This function emits a #XedMessageBus::registered signal.
*
* Return value: the registered #XedMessageType. The returned reference is
* owned by the bus. If you want to keep it alive after
* unregistering, use xed_message_type_ref().
*
*/
XedMessageType *
xed_message_bus_register (XedMessageBus *bus,
const gchar *object_path,
const gchar *method,
guint num_optional,
...)
{
gchar *identifier;
va_list var_args;
XedMessageType *message_type;
g_return_val_if_fail (XED_IS_MESSAGE_BUS (bus), NULL);
g_return_val_if_fail (xed_message_type_is_valid_object_path (object_path), NULL);
if (xed_message_bus_is_registered (bus, object_path, method))
{
g_warning ("Message type for '%s.%s' is already registered", object_path, method);
return NULL;
}
identifier = xed_message_type_identifier (object_path, method);
va_start (var_args, num_optional);
message_type = xed_message_type_new_valist (object_path, method, num_optional, var_args);
va_end (var_args);
if (message_type)
{
g_hash_table_insert (bus->priv->types, identifier, message_type);
g_signal_emit (bus, message_bus_signals[REGISTERED], 0, message_type);
}
else
{
g_free (identifier);
}
return message_type;
}
static void
xed_message_bus_unregister_real (XedMessageBus *bus,
XedMessageType *message_type,
gboolean remove_from_store)
{
gchar *identifier;
g_return_if_fail (XED_IS_MESSAGE_BUS (bus));
identifier = xed_message_type_identifier (xed_message_type_get_object_path (message_type),
xed_message_type_get_method (message_type));
/* Keep message type alive for signal emission */
xed_message_type_ref (message_type);
if (!remove_from_store || g_hash_table_remove (bus->priv->types, identifier))
{
g_signal_emit (bus, message_bus_signals[UNREGISTERED], 0, message_type);
}
xed_message_type_unref (message_type);
g_free (identifier);
}
/**
* xed_message_bus_unregister:
* @bus: a #XedMessageBus
* @message_type: the #XedMessageType to unregister
*
* Unregisters a previously registered message type. This is especially useful
* for plugins which should unregister message types when they are deactivated.
*
* This function emits the #XedMessageBus::unregistered signal.
*
*/
void
xed_message_bus_unregister (XedMessageBus *bus,
XedMessageType *message_type)
{
g_return_if_fail (XED_IS_MESSAGE_BUS (bus));
xed_message_bus_unregister_real (bus, message_type, TRUE);
}
typedef struct
{
XedMessageBus *bus;
const gchar *object_path;
} UnregisterInfo;
static gboolean
unregister_each (const gchar *identifier,
XedMessageType *message_type,
UnregisterInfo *info)
{
if (strcmp (xed_message_type_get_object_path (message_type),
info->object_path) == 0)
{
xed_message_bus_unregister_real (info->bus, message_type, FALSE);
return TRUE;
}
return FALSE;
}
/**
* xed_message_bus_unregister_all:
* @bus: a #XedMessageBus
* @object_path: the object path
*
* Unregisters all message types for @object_path. This is especially useful for
* plugins which should unregister message types when they are deactivated.
*
* This function emits the #XedMessageBus::unregistered signal for all
* unregistered message types.
*
*/
void
xed_message_bus_unregister_all (XedMessageBus *bus,
const gchar *object_path)
{
UnregisterInfo info = {bus, object_path};
g_return_if_fail (XED_IS_MESSAGE_BUS (bus));
g_return_if_fail (object_path != NULL);
g_hash_table_foreach_remove (bus->priv->types, (GHRFunc)unregister_each, &info);
}
/**
* xed_message_bus_is_registered:
* @bus: a #XedMessageBus
* @object_path: the object path
* @method: the method
*
* Check whether a message type @method at @object_path is registered on the
* bus.
*
* Return value: %TRUE if the @method at @object_path is a registered message
* type on the bus
*
*/
gboolean
xed_message_bus_is_registered (XedMessageBus *bus,
const gchar *object_path,
const gchar *method)
{
gchar *identifier;
gboolean ret;
g_return_val_if_fail (XED_IS_MESSAGE_BUS (bus), FALSE);
g_return_val_if_fail (object_path != NULL, FALSE);
g_return_val_if_fail (method != NULL, FALSE);
identifier = xed_message_type_identifier (object_path, method);
ret = g_hash_table_lookup (bus->priv->types, identifier) != NULL;
g_free(identifier);
return ret;
}
typedef struct
{
XedMessageBusForeach func;
gpointer userdata;
} ForeachInfo;
static void
foreach_type (const gchar *key,
XedMessageType *message_type,
ForeachInfo *info)
{
xed_message_type_ref (message_type);
info->func (message_type, info->userdata);
xed_message_type_unref (message_type);
}
/**
* xed_message_bus_foreach:
* @bus: the #XedMessagebus
* @func: (scope call): the callback function
* @userdata: the user data to supply to the callback function
*
* Calls @func for each message type registered on the bus
*
*/
void
xed_message_bus_foreach (XedMessageBus *bus,
XedMessageBusForeach func,
gpointer userdata)
{
ForeachInfo info = {func, userdata};
g_return_if_fail (XED_IS_MESSAGE_BUS (bus));
g_return_if_fail (func != NULL);
g_hash_table_foreach (bus->priv->types, (GHFunc)foreach_type, &info);
}
/**
* xed_message_bus_connect:
* @bus: a #XedMessageBus
* @object_path: the object path
* @method: the method
* @callback: function to be called when message @method at @object_path is sent
* @userdata: userdata to use for the callback
* @destroy_data: function to evoke with @userdata as argument when @userdata
* needs to be freed
*
* Connect a callback handler to be evoked when message @method at @object_path
* is sent over the bus.
*
* Return value: the callback identifier
*
*/
guint
xed_message_bus_connect (XedMessageBus *bus,
const gchar *object_path,
const gchar *method,
XedMessageCallback callback,
gpointer userdata,
GDestroyNotify destroy_data)
{
Message *message;
g_return_val_if_fail (XED_IS_MESSAGE_BUS (bus), 0);
g_return_val_if_fail (object_path != NULL, 0);
g_return_val_if_fail (method != NULL, 0);
g_return_val_if_fail (callback != NULL, 0);
/* lookup the message and create if it does not exist yet */
message = lookup_message (bus, object_path, method, TRUE);
return add_listener (bus, message, callback, userdata, destroy_data);
}
/**
* xed_message_bus_disconnect:
* @bus: a #XedMessageBus
* @id: the callback id as returned by xed_message_bus_connect()
*
* Disconnects a previously connected message callback.
*
*/
void
xed_message_bus_disconnect (XedMessageBus *bus,
guint id)
{
g_return_if_fail (XED_IS_MESSAGE_BUS (bus));
process_by_id (bus, id, remove_listener);
}
/**
* xed_message_bus_disconnect_by_func:
* @bus: a #XedMessageBus
* @object_path: the object path
* @method: the method
* @callback: (scope call): the connected callback
* @userdata: the userdata with which the callback was connected
*
* Disconnects a previously connected message callback by matching the
* provided callback function and userdata. See also
* xed_message_bus_disconnect().
*
*/
void
xed_message_bus_disconnect_by_func (XedMessageBus *bus,
const gchar *object_path,
const gchar *method,
XedMessageCallback callback,
gpointer userdata)
{
g_return_if_fail (XED_IS_MESSAGE_BUS (bus));
process_by_match (bus, object_path, method, callback, userdata, remove_listener);
}
/**
* xed_message_bus_block:
* @bus: a #XedMessageBus
* @id: the callback id
*
* Blocks evoking the callback specified by @id. Unblock the callback by
* using xed_message_bus_unblock().
*
*/
void
xed_message_bus_block (XedMessageBus *bus,
guint id)
{
g_return_if_fail (XED_IS_MESSAGE_BUS (bus));
process_by_id (bus, id, block_listener);
}
/**
* xed_message_bus_block_by_func:
* @bus: a #XedMessageBus
* @object_path: the object path
* @method: the method
* @callback: (scope call): the callback to block
* @userdata: the userdata with which the callback was connected
*
* Blocks evoking the callback that matches provided @callback and @userdata.
* Unblock the callback using xed_message_unblock_by_func().
*
*/
void
xed_message_bus_block_by_func (XedMessageBus *bus,
const gchar *object_path,
const gchar *method,
XedMessageCallback callback,
gpointer userdata)
{
g_return_if_fail (XED_IS_MESSAGE_BUS (bus));
process_by_match (bus, object_path, method, callback, userdata, block_listener);
}
/**
* xed_message_bus_unblock:
* @bus: a #XedMessageBus
* @id: the callback id
*
* Unblocks the callback specified by @id.
*
*/
void
xed_message_bus_unblock (XedMessageBus *bus,
guint id)
{
g_return_if_fail (XED_IS_MESSAGE_BUS (bus));
process_by_id (bus, id, unblock_listener);
}
/**
* xed_message_bus_unblock_by_func:
* @bus: a #XedMessageBus
* @object_path: the object path
* @method: the method
* @callback: (scope call): the callback to block
* @userdata: the userdata with which the callback was connected
*
* Unblocks the callback that matches provided @callback and @userdata.
*
*/
void
xed_message_bus_unblock_by_func (XedMessageBus *bus,
const gchar *object_path,
const gchar *method,
XedMessageCallback callback,
gpointer userdata)
{
g_return_if_fail (XED_IS_MESSAGE_BUS (bus));
process_by_match (bus, object_path, method, callback, userdata, unblock_listener);
}
static gboolean
validate_message (XedMessage *message)
{
if (!xed_message_validate (message))
{
g_warning ("Message '%s.%s' is invalid", xed_message_get_object_path (message),
xed_message_get_method (message));
return FALSE;
}
return TRUE;
}
static void
send_message_real (XedMessageBus *bus,
XedMessage *message)
{
if (!validate_message (message))
{
return;
}
bus->priv->message_queue = g_list_prepend (bus->priv->message_queue, g_object_ref (message));
if (bus->priv->idle_id == 0)
{
bus->priv->idle_id = g_idle_add_full (G_PRIORITY_HIGH,
(GSourceFunc)idle_dispatch,
bus,
NULL);
}
}
/**
* xed_message_bus_send_message:
* @bus: a #XedMessageBus
* @message: the message to send
*
* This sends the provided @message asynchronously over the bus. To send
* a message synchronously, use xed_message_bus_send_message_sync(). The
* convenience function xed_message_bus_send() can be used to easily send
* a message without constructing the message object explicitly first.
*
*/
void
xed_message_bus_send_message (XedMessageBus *bus,
XedMessage *message)
{
g_return_if_fail (XED_IS_MESSAGE_BUS (bus));
g_return_if_fail (XED_IS_MESSAGE (message));
send_message_real (bus, message);
}
static void
send_message_sync_real (XedMessageBus *bus,
XedMessage *message)
{
if (!validate_message (message))
{
return;
}
dispatch_message (bus, message);
}
/**
* xed_message_bus_send_message_sync:
* @bus: a #XedMessageBus
* @message: the message to send
*
* This sends the provided @message synchronously over the bus. To send
* a message asynchronously, use xed_message_bus_send_message(). The
* convenience function xed_message_bus_send_sync() can be used to easily send
* a message without constructing the message object explicitly first.
*
*/
void
xed_message_bus_send_message_sync (XedMessageBus *bus,
XedMessage *message)
{
g_return_if_fail (XED_IS_MESSAGE_BUS (bus));
g_return_if_fail (XED_IS_MESSAGE (message));
send_message_sync_real (bus, message);
}
static XedMessage *
create_message (XedMessageBus *bus,
const gchar *object_path,
const gchar *method,
va_list var_args)
{
XedMessageType *message_type;
message_type = xed_message_bus_lookup (bus, object_path, method);
if (!message_type)
{
g_warning ("Could not find message type for '%s.%s'", object_path, method);
return NULL;
}
return xed_message_type_instantiate_valist (message_type, var_args);
}
/**
* xed_message_bus_send:
* @bus: a #XedMessageBus
* @object_path: the object path
* @method: the method
* @...: NULL terminated list of key/value pairs
*
* This provides a convenient way to quickly send a message @method at
* @object_path asynchronously over the bus. The variable argument list
* specifies key (string) value pairs used to construct the message arguments.
* To send a message synchronously use xed_message_bus_send_sync().
*
*/
void
xed_message_bus_send (XedMessageBus *bus,
const gchar *object_path,
const gchar *method,
...)
{
va_list var_args;
XedMessage *message;
va_start (var_args, method);
message = create_message (bus, object_path, method, var_args);
if (message)
{
send_message_real (bus, message);
g_object_unref (message);
}
else
{
g_warning ("Could not instantiate message");
}
va_end (var_args);
}
/**
* xed_message_bus_send_sync:
* @bus: a #XedMessageBus
* @object_path: the object path
* @method: the method
* @...: NULL terminated list of key/value pairs
*
* This provides a convenient way to quickly send a message @method at
* @object_path synchronously over the bus. The variable argument list
* specifies key (string) value pairs used to construct the message
* arguments. To send a message asynchronously use xed_message_bus_send().
*
* Return value: (transfer full): the constructed #XedMessage. The caller owns a reference
* to the #XedMessage and should call g_object_unref() when
* it is no longer needed
*/
XedMessage *
xed_message_bus_send_sync (XedMessageBus *bus,
const gchar *object_path,
const gchar *method,
...)
{
va_list var_args;
XedMessage *message;
va_start (var_args, method);
message = create_message (bus, object_path, method, var_args);
if (message)
send_message_sync_real (bus, message);
va_end (var_args);
return message;
}
// ex:ts=8:noet:
Reference in New Issue View Git Blame Copy Permalink