*

* // Register 'method' at '/plugins/example' with one required

* // string argument 'arg1'

* "arg1", G_TYPE_STRING,

* NULL);

* </programlisting>

* gpointer userdata)

* {

* gchar *arg1 = NULL;

* pluma_message_get (message, "arg1", &arg1, NULL);

* g_message ("Evoked /plugins/example.method with: %s", arg1);

* g_free (arg1);

* }

*

* PlumaMessageBus *bus = pluma_message_bus_get_default ();

* "/plugins/example", "method",

* example_method_cb,

* NULL,

* NULL);

* </programlisting>

* </example>

* <example>

* <programlisting>

* PlumaMessageBus *bus = pluma_message_bus_get_default ();

*

* NULL);

* </programlisting>

* </example>

*/

#define PLUMA_MESSAGE_BUS_GET_PRIVATE(object)(G_TYPE_INSTANCE_GET_PRIVATE((object), PLUMA_TYPE_MESSAGE_BUS, PlumaMessageBusPrivate))

typedef struct

guint idle_id;

guint next_id;

GHashTable *types; /* mapping from identifier to PlumaMessageType */

};

{

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

}

pluma_message_bus_finalize (GObject *object)

{

PlumaMessageBus *bus = PLUMA_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 (pluma_message_bus_parent_class)->finalize (object);

}

pluma_message_bus_class_init (PlumaMessageBusClass *klass)

{

GObjectClass *object_class = G_OBJECT_CLASS (klass);

object_class->finalize = pluma_message_bus_finalize;

klass->dispatch = pluma_message_bus_dispatch_real;

/**

* @message: the #PlumaMessage to dispatch

*

* The "dispatch" signal is emitted when a message is to be dispatched.

* Primary use of this signal is to customize the dispatch of a message

* (for instance to automatically dispatch all messages over DBus).

*2

* @bus: a #PlumaMessageBus

* @message_type: the unregistered #PlumaMessageType

*

* unregistered from the bus.

*

*/

const gchar *method)

{

Message *message = g_new (Message, 1);

message->object_path = g_strdup (object_path);

message->method = g_strdup (method);

message->listeners = NULL;

pluma_message_type_identifier (object_path, method),

message);

return message;

{

gchar *identifier;

Message *message;

identifier = pluma_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;

}

{

Listener *listener;

IdMap *idmap;

listener = g_new (Listener, 1);

listener->id = ++bus->priv->next_id;

listener->callback = callback;

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

return listener->id;

}

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 */

GList *listener)

{

Listener *lst;

lst = (Listener *)listener->data;

lst->blocked = TRUE;

}

GList *listener)

{

Listener *lst;

lst = (Listener *)listener->data;

lst->blocked = FALSE;

}

PlumaMessage *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);

}

const gchar *object_path;

const gchar *method;

Message *msg;

object_path = pluma_message_get_object_path (message);

method = pluma_message_get_method (message);

msg = lookup_message (bus, object_path, method, FALSE);

if (msg)

dispatch_message_real (bus, msg, message);

}

dispatch_message (PlumaMessageBus *bus,

PlumaMessage *message)

{

}

static gboolean

{

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)

{

PlumaMessage *msg = PLUMA_MESSAGE (item->data);

dispatch_message (bus, msg);

}

message_queue_free (list);

return FALSE;

}

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

}

{

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;

listener->userdata == userdata)

{

processor (bus, message, item);

return;

}

}

g_warning ("No such handler registered for %s.%s", object_path, method);

}

pluma_message_bus_init (PlumaMessageBus *self)

{

self->priv = PLUMA_MESSAGE_BUS_GET_PRIVATE (self);

self->priv->messages = g_hash_table_new_full (g_str_hash,

g_str_equal,

(GDestroyNotify)g_free,

g_direct_equal,

NULL,

(GDestroyNotify)g_free);

self->priv->types = g_hash_table_new_full (g_str_hash,

g_str_equal,

(GDestroyNotify)g_free,

pluma_message_bus_get_default (void)

{

static PlumaMessageBus *default_bus = NULL;

if (G_UNLIKELY (default_bus == NULL))

{

default_bus = g_object_new (PLUMA_TYPE_MESSAGE_BUS, NULL);

g_object_add_weak_pointer (G_OBJECT (default_bus),

(gpointer) &default_bus);

}

return default_bus;

}

/**

* pluma_message_bus_new:

* Create a new message bus. Use pluma_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 #PlumaWindow.

* @object_path: the object path

* @method: the method

*

* returned #PlumaMessageType is owned by the bus and should not be unreffed.

*

* Return value: the registered #PlumaMessageType or %NULL if no message type

{

gchar *identifier;

PlumaMessageType *message_type;

g_return_val_if_fail (PLUMA_IS_MESSAGE_BUS (bus), NULL);

g_return_val_if_fail (object_path != NULL, NULL);

g_return_val_if_fail (method != NULL, NULL);

identifier = pluma_message_type_identifier (object_path, method);

message_type = PLUMA_MESSAGE_TYPE (g_hash_table_lookup (bus->priv->types, identifier));

g_free (identifier);

return message_type;

}

* @...: NULL terminated list of key/gtype method argument pairs

*

* Register a message on the bus. A message must be registered on the bus before

* last @num_optional arguments are registered as optional (and are thus not

* required when sending a message).

*

g_return_val_if_fail (PLUMA_IS_MESSAGE_BUS (bus), NULL);

g_return_val_if_fail (pluma_message_type_is_valid_object_path (object_path), NULL);

if (pluma_message_bus_is_registered (bus, object_path, method))

{

g_warning ("Message type for '%s.%s' is already registered", object_path, method);

identifier = pluma_message_type_identifier (object_path, method);

g_hash_table_lookup (bus->priv->types, identifier);

va_start (var_args, num_optional);

method,

num_optional,

var_args);

va_end (var_args);

if (message_type)

{

g_hash_table_insert (bus->priv->types, identifier, message_type);

{

g_free (identifier);

}

}

static void

gboolean remove_from_store)

{

gchar *identifier;

g_return_if_fail (PLUMA_IS_MESSAGE_BUS (bus));

pluma_message_type_get_method (message_type));

/* Keep message type alive for signal emission */

pluma_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);

pluma_message_type_unref (message_type);

g_free (identifier);

}

* @bus: a #PlumaMessageBus

* @message_type: the #PlumaMessageType to unregister

*

* for plugins which should unregister message types when they are deactivated.

*

* This function emits the #PlumaMessageBus::unregistered signal.

pluma_message_bus_unregister_real (bus, message_type, TRUE);

}

{

PlumaMessageBus *bus;

const gchar *object_path;

{

if (strcmp (pluma_message_type_get_object_path (message_type),

info->object_path) == 0)

pluma_message_bus_unregister_real (info->bus, message_type, FALSE);

return TRUE;

}

return FALSE;

}

g_return_if_fail (PLUMA_IS_MESSAGE_BUS (bus));

g_return_if_fail (object_path != NULL);

(GHRFunc)unregister_each,

&info);

}

* @object_path: the object path

* @method: the method

*

* bus.

*

* type on the bus

*

*/

{

gchar *identifier;

gboolean ret;

g_return_val_if_fail (PLUMA_IS_MESSAGE_BUS (bus), FALSE);

g_return_val_if_fail (object_path != NULL, FALSE);

g_return_val_if_fail (method != NULL, FALSE);

identifier = pluma_message_type_identifier (object_path, method);

ret = g_hash_table_lookup (bus->priv->types, identifier) != NULL;

g_free(identifier);

return ret;

}

* Calls @func for each message type registered on the bus

*

*/

pluma_message_bus_foreach (PlumaMessageBus *bus,

PlumaMessageBusForeach func,

gpointer userdata)

{

ForeachInfo info = {func, userdata};

g_return_if_fail (PLUMA_IS_MESSAGE_BUS (bus));

g_return_if_fail (func != NULL);

*

*/

guint

const gchar *object_path,

const gchar *method,

PlumaMessageCallback callback,

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

}

guint id)

{

g_return_if_fail (PLUMA_IS_MESSAGE_BUS (bus));

process_by_id (bus, id, remove_listener);

}

* @callback: (scope call): the connected callback

* @userdata: the userdata with which the callback was connected

*

* pluma_message_bus_disconnect().

*

*/

gpointer userdata)

{

g_return_if_fail (PLUMA_IS_MESSAGE_BUS (bus));

process_by_match (bus, object_path, method, callback, userdata, remove_listener);

}

guint id)

{

g_return_if_fail (PLUMA_IS_MESSAGE_BUS (bus));

process_by_id (bus, id, block_listener);

}

gpointer userdata)

{

g_return_if_fail (PLUMA_IS_MESSAGE_BUS (bus));

process_by_match (bus, object_path, method, callback, userdata, block_listener);

}

guint id)

{

g_return_if_fail (PLUMA_IS_MESSAGE_BUS (bus));

process_by_id (bus, id, unblock_listener);

}

gpointer userdata)

{

g_return_if_fail (PLUMA_IS_MESSAGE_BUS (bus));

process_by_match (bus, object_path, method, callback, userdata, unblock_listener);

}

pluma_message_get_method (message));

return FALSE;

}

return TRUE;

}

{

return;

}

g_object_ref (message));

if (bus->priv->idle_id == 0)

* @message: the message to send

*

* This sends the provided @message asynchronously over the bus. To send

* convenience function pluma_message_bus_send() can be used to easily send

* a message without constructing the message object explicitly first.

*

{

g_return_if_fail (PLUMA_IS_MESSAGE_BUS (bus));

g_return_if_fail (PLUMA_IS_MESSAGE (message));

send_message_real (bus, message);

}

{

return;

}

dispatch_message (bus, message);

}

* @message: the message to send

*

* This sends the provided @message synchronously over the bus. To send

* convenience function pluma_message_bus_send_sync() can be used to easily send

* a message without constructing the message object explicitly first.

*

g_return_if_fail (PLUMA_IS_MESSAGE_BUS (bus));

g_return_if_fail (PLUMA_IS_MESSAGE (message));

}

static PlumaMessage *

va_list var_args)

{

PlumaMessageType *message_type;

message_type = pluma_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;

}

var_args);

}

* @method: the method

* @...: NULL terminated list of key/value pairs

*

* To send a message synchronously use pluma_message_bus_send_sync().

*

*/

{

va_list var_args;

PlumaMessage *message;

va_start (var_args, method);

message = create_message (bus, object_path, method, var_args);

if (message)

{

send_message_real (bus, message);

* @method: the method

* @...: NULL terminated list of key/value pairs

*

* arguments. To send a message asynchronously use pluma_message_bus_send().

*

* Return value: (transfer full): the constructed #PlumaMessage. The caller owns a reference

{

va_list var_args;

PlumaMessage *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;

}