gt_signal_logger_new ()

GtSignalLogger *
gt_signal_logger_new (void);

Create a new GtSignalLogger. Add signals to it to log using gt_signal_logger_connect().

Since: 0.1.0

gt_signal_logger_free ()

void
gt_signal_logger_free (GtSignalLogger *self);

Free a GtSignalLogger. This will disconnect all its closures from the signals they are connected to.

This function may be called when there are signal emissions left in the logged stack, but typically you will want to call gt_signal_logger_assert_no_emissions() first.

Since: 0.1.0

gt_signal_logger_connect ()

gulong
gt_signal_logger_connect (GtSignalLogger *self,
                          gpointer obj,
                          const gchar *signal_name);

A convenience wrapper around g_signal_connect() which connects the GtSignalLogger to the given signal_name on obj so that emissions of it will be logged.

The closure will be disconnected (and the returned signal connection ID invalidated) when:

This does not keep a strong reference to obj .

Since: 0.1.0

gt_signal_logger_get_n_emissions ()

gsize
gt_signal_logger_get_n_emissions (GtSignalLogger *self);

Get the number of signal emissions which have been logged (and not popped) since the logger was initialised.

Since: 0.1.0

gt_signal_logger_pop_emission ()

gboolean
gt_signal_logger_pop_emission (GtSignalLogger *self,
                               gpointer *out_obj,
                               gchar **out_obj_type_name,
                               gchar **out_signal_name,
                               GtSignalLoggerEmission **out_emission);

Pop the oldest signal emission off the stack of logged emissions, and return its object, signal name and parameters in the given return locations. All return locations are optional: if they are all NULL, this function just performs a pop.

If there are no signal emissions on the logged stack, FALSE is returned.

out_obj does not return a reference to the object instance, as it may have been finalised since the signal emission was logged. It should be treated as an opaque pointer. The type name of the object is given as out_obj_type_name , which is guaranteed to be valid.

Since: 0.1.0

gt_signal_logger_format_emission ()

gchar *
gt_signal_logger_format_emission (gpointer obj,
                                  const gchar *obj_type_name,
                                  const gchar *signal_name,
                                  const GtSignalLoggerEmission *emission);

Format a signal emission in a human readable form, typically for logging it to some debug output.

The returned string does not have a trailing newline character (\n).

obj may have been finalised, and is just treated as an opaque pointer.

Since: 0.1.0

gt_signal_logger_format_emissions ()

gchar *
gt_signal_logger_format_emissions (GtSignalLogger *self);

Format all the signal emissions on the logging stack in the GtSignalLogger, in a human readable format, one per line. The returned string does not end in a newline character (\n). Each signal emission is formatted using gt_signal_logger_format_emission().

Since: 0.1.0

gt_signal_logger_assert_no_emissions()

#define             gt_signal_logger_assert_no_emissions(self)

Assert that there are no signal emissions currently in the logged stack.

Since: 0.1.0

gt_signal_logger_assert_emission_pop()

#define             gt_signal_logger_assert_emission_pop(self, obj, signal_name, ...)

Assert that a signal emission can be popped off the log (using gt_signal_logger_pop_emission()) and that it is an emission of signal_name on obj . The parameters from the emission will be returned in the return locations given in the varargs, as with gt_signal_logger_emission_get_params().

If a signal emission can’t be popped, or if it doesn’t match signal_name and obj , an assertion fails, and some debug output is printed.

Since: 0.1.0

gt_signal_logger_assert_notify_emission_pop()

#define             gt_signal_logger_assert_notify_emission_pop(self, obj, property_name)

Assert that a signal emission can be popped off the log (using gt_signal_logger_pop_emission()) and that it is an emission of “notify” for property_name on obj . To examine the GParamSpec for the notify emission, use gt_signal_logger_assert_emission_pop() instead.

If a signal emission can’t be popped, or if it doesn’t match “notify”, property_name and obj , an assertion fails, and some debug output is printed.

Since: 0.1.0

gt_signal_logger_emission_get_params ()

void
gt_signal_logger_emission_get_params (GtSignalLoggerEmission *self,
                                      ...);

Get the parameters emitted in this signal emission. They are returned in the return locations provided as varargs. These locations must have the right type for the parameters of the signal which was emitted.

To ignore a particular parameter, pass NULL as the one (or more) return locations for that parameter.

Since: 0.1.0

gt_signal_logger_emission_free ()

void
gt_signal_logger_emission_free (GtSignalLoggerEmission *emission);

Free a GtSignalLoggerEmission.

Since: 0.1.0

GtSignalLogger

typedef struct _GtSignalLogger GtSignalLogger;

An object which allows signal emissions from zero or more GObjects to be logged easily, without needing to write specific callback functions for any of them.

Since: 0.1.0

GtSignalLoggerEmission

typedef struct _GtSignalLoggerEmission GtSignalLoggerEmission;

The details of a particular signal emission, including its parameter values.

param_values does not include the object instance.

Since: 0.1.0