enum TpDBusPropertiesMixinFlags

typedef enum { /*< flags >*/
    TP_DBUS_PROPERTIES_MIXIN_FLAG_READ = 1,
    TP_DBUS_PROPERTIES_MIXIN_FLAG_WRITE = 2
} TpDBusPropertiesMixinFlags;

Bitfield representing allowed access to a property.

Since 0.11.5, there is a corresponding GFlagsClass type, TP_TYPE_DBUS_PROPERTIES_MIXIN_FLAGS.

Since 0.7.3

TP_TYPE_DBUS_PROPERTIES_MIXIN_FLAGS

#define TP_TYPE_DBUS_PROPERTIES_MIXIN_FLAGS (tp_dbus_properties_mixin_flags_get_type ())

The GFlagsClass type of TpDBusPropertiesMixinFlags.

Since 0.11.5

TpDBusPropertiesMixinIfaceInfo

typedef struct {
    GQuark dbus_interface;
    TpDBusPropertiesMixinPropInfo *props;
} TpDBusPropertiesMixinIfaceInfo;

Semi-abstract description of an interface. Each service GInterface that has properties must have one of these attached to it via tp_svc_interface_set_dbus_properties_info() in its base_init function; service GInterfaces that do not have properties may have one of these with no properties.

This structure must either be statically allocated, or duplicated and never freed, so it always remains valid.

In addition to the documented members, there are two private pointers for future expansion, which must always be initialized to NULL.

Since 0.7.3

TpDBusPropertiesMixinPropInfo

typedef struct {
    GQuark name;
    TpDBusPropertiesMixinFlags flags;
    gchar *dbus_signature;
    GType type;
} TpDBusPropertiesMixinPropInfo;

Semi-abstract description of a property, as attached to a service GInterface. This structure must either be statically allocated, or duplicated and never freed, so it always remains valid.

In addition to the documented members, there are two private pointers for future expansion, which must always be initialized to NULL.

Since 0.7.3

tp_svc_interface_set_dbus_properties_info ()

void                tp_svc_interface_set_dbus_properties_info
                                                        (GType g_interface,
                                                         TpDBusPropertiesMixinIfaceInfo *info);

Declare that g_interface implements the given D-Bus interface, with the given properties. This may only be called once per GInterface, usually from a section of its base_init function that only runs once.

Since 0.7.3

TpDBusPropertiesMixinClass

typedef struct {
    TpDBusPropertiesMixinIfaceImpl *interfaces;
} TpDBusPropertiesMixinClass;

Structure representing all of a class's property implementations. One of these structures may be placed in the layout of an object class structure.

In addition to the documented fields, there are 7 pointers reserved for future use, which must be initialized to NULL.

Since 0.7.3

TpDBusPropertiesMixinIfaceImpl

typedef struct {
    const gchar *name;
    TpDBusPropertiesMixinGetter getter;
    TpDBusPropertiesMixinSetter setter;
    TpDBusPropertiesMixinPropImpl *props;
} TpDBusPropertiesMixinIfaceImpl;

Structure representing an implementation of an interface's properties.

In addition to the documented fields, there are four pointers which must be initialized to NULL.

This structure must either be statically allocated, or duplicated and never freed, so it always remains valid.

Since 0.7.3

TpDBusPropertiesMixinPropImpl

typedef struct {
    const gchar *name;
    gpointer getter_data;
    gpointer setter_data;
} TpDBusPropertiesMixinPropImpl;

Structure representing an implementation of a property.

In addition to the documented fields, there are three pointers which must be initialized to NULL.

This structure must either be statically allocated, or duplicated and never freed, so it always remains valid.

Since 0.7.3

TpDBusPropertiesMixinGetter ()

void                (*TpDBusPropertiesMixinGetter)      (GObject *object,
                                                         GQuark iface,
                                                         GQuark name,
                                                         GValue *value,
                                                         gpointer getter_data);

Signature of a callback used to get the value of a property.

For simplicity, in this mixin we don't allow getting a property to fail; implementations must always be prepared to return *something*.

tp_dbus_properties_mixin_getter_gobject_properties ()

void                tp_dbus_properties_mixin_getter_gobject_properties
                                                        (GObject *object,
                                                         GQuark iface,
                                                         GQuark name,
                                                         GValue *value,
                                                         gpointer getter_data);

An implementation of TpDBusPropertiesMixinGetter which assumes that the getter_data is the name of a readable GObject property of an appropriate type, and uses it for the value of the D-Bus property.

TpDBusPropertiesMixinSetter ()

gboolean            (*TpDBusPropertiesMixinSetter)      (GObject *object,
                                                         GQuark iface,
                                                         GQuark name,
                                                         const GValue *value,
                                                         gpointer setter_data,
                                                         GError **error);

Signature of a callback used to get the value of a property.

tp_dbus_properties_mixin_setter_gobject_properties ()

gboolean            tp_dbus_properties_mixin_setter_gobject_properties
                                                        (GObject *object,
                                                         GQuark iface,
                                                         GQuark name,
                                                         const GValue *value,
                                                         gpointer setter_data,
                                                         GError **error);

An implementation of TpDBusPropertiesMixinSetter which assumes that the setter_data is the name of a writable GObject property of an appropriate type, and sets that property to the given value.

tp_dbus_properties_mixin_class_init ()

void                tp_dbus_properties_mixin_class_init (GObjectClass *cls,
                                                         gsize offset);

Initialize the class cls to use the D-Bus Properties mixin. The given struct member, of size sizeof(TpDBusPropertiesMixinClass), will be used to store property implementation information.

Each property and each interface must have been declared as a member of a GInterface implemented by cls, using tp_svc_interface_set_dbus_properties_info().

Before calling this function, the array interfaces must have been placed in the TpDBusPropertiesMixinClass structure; if it would be empty, it may instead be NULL.

This function should be called from the class_init callback in such a way that it will only be called once, even if the class is subclassed.

Changed in 0.7.9: TpDBusPropertiesMixinClass::interfaces may now be NULL, which means that only interfaces whose properties are set up using tp_dbus_properties_mixin_implement_interface() will be used.

Changed in 0.7.15: offset may now be 0, in which case the TpDBusPropertiesMixinClass can be omitted from cls. It is treated as if it were present, but with all fields (including TpDBusPropertiesMixinClass::interfaces) being NULL, so only interfaces whose properties are set using tp_dbus_properties_mixin_implement_interface() will be used.

Since 0.7.3

tp_dbus_properties_mixin_implement_interface ()

void                tp_dbus_properties_mixin_implement_interface
                                                        (GObjectClass *cls,
                                                         GQuark iface,
                                                         TpDBusPropertiesMixinGetter getter,
                                                         TpDBusPropertiesMixinSetter setter,
                                                         TpDBusPropertiesMixinPropImpl *props);

Declare that, in addition to any interfaces set in tp_dbus_properties_mixin_class_init(), the given class (and its subclasses) will implement the properties of the interface iface using the callbacks getter and setter and the properties given by props.

This function should be called from the class_init callback in such a way that it will only be called once, even if the class is subclassed.

Typically, the static array interfaces in the TpDBusPropertiesMixinClass should be used for interfaces whose properties are implemented directly by the class cls, and this function should be used for interfaces whose properties are implemented by mixins.

It is an error for the same interface to appear in the array interfaces in the TpDBusPropertiesMixinClass, and also be set up by this function.

If a class C and a subclass S both implement the properties of the same interface, only the implementations from the subclass S will be used, regardless of whether the implementations in C and/or S were set up by this function or via the array interfaces in the TpDBusPropertiesMixinClass.

tp_dbus_properties_mixin_iface_init ()

void                tp_dbus_properties_mixin_iface_init (gpointer g_iface,
                                                         gpointer iface_data);

Declare that the DBus.Properties interface represented by g_iface is implemented using this mixin.

tp_dbus_properties_mixin_get ()

gboolean            tp_dbus_properties_mixin_get        (GObject *self,
                                                         const gchar *interface_name,
                                                         const gchar *property_name,
                                                         GValue *value,
                                                         GError **error);

Initialize value with the type of the property property_name on interface_name, and write the value of that property into it as if by calling the D-Bus method org.freedesktop.DBus.Properties.Get.

If Get would return a D-Bus error, value remains unset and error is filled in instead.

Since 0.7.13

tp_dbus_properties_mixin_fill_properties_hash ()

void                tp_dbus_properties_mixin_fill_properties_hash
                                                        (GObject *object,
                                                         GHashTable *table,
                                                         const gchar *first_interface,
                                                         const gchar *first_property,
                                                         ...);

Retrieves the values of several D-Bus properties from an object, and adds them to a hash mapping the fully-qualified name of the property to its value. This is equivalent to calling tp_dbus_properties_mixin_get() for each property and adding it to the table yourself, with the proviso that this function will g_assert() if retrieving a property fails (for instance, because it does not exist).

Note that in particular, table does not have the same memory-allocation model as the hash tables required by tp_asv_set_string() and similar functions.

Since 0.11.11

tp_dbus_properties_mixin_make_properties_hash ()

GHashTable *        tp_dbus_properties_mixin_make_properties_hash
                                                        (GObject *object,
                                                         const gchar *first_interface,
                                                         const gchar *first_property,
                                                         ...);

Retrieves the values of several D-Bus properties from an object, and builds a hash mapping the fully-qualified name of the property to its value. This is equivalent to calling tp_dbus_properties_mixin_get() for each property and building the table yourself, with the proviso that this function will g_assert() if retrieving a property fails (for instance, because it does not exist).

Additional keys and values can be inserted into the returned hash table; if this is done, the inserted keys and values will be freed when the hash table is destroyed. The keys must be allocated with g_strdup() or equivalent, and the values must be slice-allocated (for instance with tp_g_value_slice_new_string() or a similar function).

Note that in particular, tp_asv_set_string() and similar functions should not be used with this hash table.