GeditMessageCallback ()

void
(*GeditMessageCallback) (GeditMessageBus *bus,
                         GeditMessage *message,
                         gpointer user_data);

Callback signature used for connecting callback functions to be called when a message is received (see gedit_message_bus_connect()).

GeditMessageBusForeach ()

void
(*GeditMessageBusForeach) (gchar const *object_path,
                           gchar const *method,
                           gpointer user_data);

gedit_message_bus_get_default ()

GeditMessageBus *
gedit_message_bus_get_default (void);

Get the default application GeditMessageBus.

gedit_message_bus_new ()

GeditMessageBus *
gedit_message_bus_new (void);

Create a new message bus. Use gedit_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 GeditWindow.

gedit_message_bus_lookup ()

GType
gedit_message_bus_lookup (GeditMessageBus *bus,
                          const gchar *object_path,
                          const gchar *method);

Get the registered GeditMessageType for method at object_path . The returned GeditMessageType is owned by the bus and should not be unreffed.

gedit_message_bus_register ()

void
gedit_message_bus_register (GeditMessageBus *bus,
                            GType message_type,
                            const gchar *object_path,
                            const gchar *method);

Register a message on the bus. A message must be registered on the bus before it can be send. This function registers the type for method at object_path .

This function emits a “registered” signal.

gedit_message_bus_unregister ()

void
gedit_message_bus_unregister (GeditMessageBus *bus,
                              const gchar *object_path,
                              const gchar *method);

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 “unregistered” signal.

gedit_message_bus_unregister_all ()

void
gedit_message_bus_unregister_all (GeditMessageBus *bus,
                                  const gchar *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 “unregistered” signal for all unregistered message types.

gedit_message_bus_is_registered ()

gboolean
gedit_message_bus_is_registered (GeditMessageBus *bus,
                                 const gchar *object_path,
                                 const gchar *method);

Check whether a message type method at object_path is registered on the bus.

gedit_message_bus_foreach ()

void
gedit_message_bus_foreach (GeditMessageBus *bus,
                           GeditMessageBusForeach func,
                           gpointer user_data);

Calls func for each message type registered on the bus

gedit_message_bus_connect ()

guint
gedit_message_bus_connect (GeditMessageBus *bus,
                           const gchar *object_path,
                           const gchar *method,
                           GeditMessageCallback callback,
                           gpointer user_data,
                           GDestroyNotify destroy_data);

Connect a callback handler to be evoked when message method at object_path is sent over the bus.

gedit_message_bus_disconnect ()

void
gedit_message_bus_disconnect (GeditMessageBus *bus,
                              guint id);

Disconnects a previously connected message callback.

gedit_message_bus_disconnect_by_func ()

void
gedit_message_bus_disconnect_by_func (GeditMessageBus *bus,
                                      const gchar *object_path,
                                      const gchar *method,
                                      GeditMessageCallback callback,
                                      gpointer user_data);

Disconnects a previously connected message callback by matching the provided callback function and user_data. See also gedit_message_bus_disconnect().

gedit_message_bus_block ()

void
gedit_message_bus_block (GeditMessageBus *bus,
                         guint id);

Blocks evoking the callback specified by id . Unblock the callback by using gedit_message_bus_unblock().

gedit_message_bus_block_by_func ()

void
gedit_message_bus_block_by_func (GeditMessageBus *bus,
                                 const gchar *object_path,
                                 const gchar *method,
                                 GeditMessageCallback callback,
                                 gpointer user_data);

Blocks evoking the callback that matches provided callback and user_data . Unblock the callback using gedit_message_bus_unblock_by_func().

gedit_message_bus_unblock ()

void
gedit_message_bus_unblock (GeditMessageBus *bus,
                           guint id);

Unblocks the callback specified by id .

gedit_message_bus_unblock_by_func ()

void
gedit_message_bus_unblock_by_func (GeditMessageBus *bus,
                                   const gchar *object_path,
                                   const gchar *method,
                                   GeditMessageCallback callback,
                                   gpointer user_data);

Unblocks the callback that matches provided callback and user_data .

gedit_message_bus_send_message ()

void
gedit_message_bus_send_message (GeditMessageBus *bus,
                                GeditMessage *message);

This sends the provided message asynchronously over the bus. To send a message synchronously, use gedit_message_bus_send_message_sync(). The convenience function gedit_message_bus_send() can be used to easily send a message without constructing the message object explicitly first.

gedit_message_bus_send_message_sync ()

void
gedit_message_bus_send_message_sync (GeditMessageBus *bus,
                                     GeditMessage *message);

This sends the provided message synchronously over the bus. To send a message asynchronously, use gedit_message_bus_send_message(). The convenience function gedit_message_bus_send_sync() can be used to easily send a message without constructing the message object explicitly first.

gedit_message_bus_send ()

void
gedit_message_bus_send (GeditMessageBus *bus,
                        const gchar *object_path,
                        const gchar *method,
                        const gchar *first_property,
                        ...);

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 gedit_message_bus_send_sync().

gedit_message_bus_send_sync ()

GeditMessage *
gedit_message_bus_send_sync (GeditMessageBus *bus,
                             const gchar *object_path,
                             const gchar *method,
                             const gchar *first_property,
                             ...);

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 gedit_message_bus_send().

struct GeditMessageBus

struct GeditMessageBus;

The “dispatch” signal

void
user_function (GeditMessageBus *bus,
               GeditMessage    *message,
               gpointer         user_data)

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

Flags: Run Last

The “registered” signal

void
user_function (GeditMessageBus *bus,
               gchar           *object_path,
               gchar           *method,
               gpointer         user_data)

The "registered" signal is emitted when a message has been registered on the bus.

Flags: Run Last

The “unregistered” signal

void
user_function (GeditMessageBus *bus,
               gchar           *object_path,
               gchar           *method,
               gpointer         user_data)

The "unregistered" signal is emitted when a message has been unregistered from the bus.

Flags: Run Last