#include <gio/gio.h>
/* ---------------------------------------------------------------------------------------------------- */
/* The D-Bus interface definition we want to create a GDBusProxy-derived type for: */
/* ---------------------------------------------------------------------------------------------------- */
static const gchar introspection_xml[] =
"<node>"
" <interface name='org.freedesktop.Accounts.User'>"
" <method name='Frobnicate'>"
" <arg name='flux' type='s' direction='in'/>"
" <arg name='baz' type='s' direction='in'/>"
" <arg name='result' type='s' direction='out'/>"
" </method>"
" <signal name='Changed'/>"
" <property name='AutomaticLogin' type='b' access='readwrite'/>"
" <property name='RealName' type='s' access='read'/>"
" <property name='UserName' type='s' access='read'/>"
" </interface>"
"</node>";
/* ---------------------------------------------------------------------------------------------------- */
/* Definition of the AccountsUser type */
/* ---------------------------------------------------------------------------------------------------- */
#define ACCOUNTS_TYPE_USER (accounts_user_get_type ())
#define ACCOUNTS_USER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), ACCOUNTS_TYPE_USER, AccountsUser))
#define ACCOUNTS_USER_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), ACCOUNTS_TYPE_USER, AccountsUserClass))
#define ACCOUNTS_USER_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), ACCOUNTS_TYPE_USER, AccountsUserClass))
#define ACCOUNTS_IS_USER(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), ACCOUNTS_TYPE_USER))
#define ACCOUNTS_IS_USER_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), ACCOUNTS_TYPE_USER))
typedef struct _AccountsUser AccountsUser;
typedef struct _AccountsUserClass AccountsUserClass;
typedef struct _AccountsUserPrivate AccountsUserPrivate;
struct _AccountsUser
{
/*< private >*/
GDBusProxy parent_instance;
AccountsUserPrivate *priv;
};
struct _AccountsUserClass
{
/*< private >*/
GDBusProxyClass parent_class;
void (*changed) (AccountsUser *user);
};
GType accounts_user_get_type (void) G_GNUC_CONST;
const gchar *accounts_user_get_user_name (AccountsUser *user);
const gchar *accounts_user_get_real_name (AccountsUser *user);
gboolean accounts_user_get_automatic_login (AccountsUser *user);
void accounts_user_frobnicate (AccountsUser *user,
const gchar *flux,
gint baz,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data);
gchar *accounts_user_frobnicate_finish (AccountsUser *user,
GAsyncResult *res,
GError **error);
gchar *accounts_user_frobnicate_sync (AccountsUser *user,
const gchar *flux,
gint baz,
GCancellable *cancellable,
GError **error);
/* ---------------------------------------------------------------------------------------------------- */
/* Implementation of the AccountsUser type */
/* ---------------------------------------------------------------------------------------------------- */
/* A more efficient approach than parsing XML is to use const static
* GDBusInterfaceInfo, GDBusMethodInfo, ... structures
*/
static GDBusInterfaceInfo *
accounts_user_get_interface_info (void)
{
static gsize has_info = 0;
static GDBusInterfaceInfo *info = NULL;
if (g_once_init_enter (&has_info))
{
GDBusNodeInfo *introspection_data;
introspection_data = g_dbus_node_info_new_for_xml (introspection_xml, NULL);
info = introspection_data->interfaces[0];
g_once_init_leave (&has_info, 1);
}
return info;
}
enum
{
PROP_0,
PROP_USER_NAME,
PROP_REAL_NAME,
PROP_AUTOMATIC_LOGIN,
};
enum
{
CHANGED_SIGNAL,
LAST_SIGNAL
};
static guint signals[LAST_SIGNAL] = {0};
G_DEFINE_TYPE (AccountsUser, accounts_user, G_TYPE_DBUS_PROXY)
static void
accounts_user_finalize (GObject *object)
{
G_GNUC_UNUSED AccountsUser *user = ACCOUNTS_USER (object);
if (G_OBJECT_CLASS (accounts_user_parent_class)->finalize != NULL)
G_OBJECT_CLASS (accounts_user_parent_class)->finalize (object);
}
static void
accounts_user_init (AccountsUser *user)
{
/* Sets the expected interface */
g_dbus_proxy_set_interface_info (G_DBUS_PROXY (user), accounts_user_get_interface_info ());
}
static void
accounts_user_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
AccountsUser *user = ACCOUNTS_USER (object);
switch (prop_id)
{
case PROP_USER_NAME:
g_value_set_string (value, accounts_user_get_user_name (user));
break;
case PROP_REAL_NAME:
g_value_set_string (value, accounts_user_get_real_name (user));
break;
case PROP_AUTOMATIC_LOGIN:
g_value_set_boolean (value, accounts_user_get_automatic_login (user));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
const gchar *
accounts_user_get_user_name (AccountsUser *user)
{
GVariant *value;
const gchar *ret;
g_return_val_if_fail (ACCOUNTS_IS_USER (user), NULL);
value = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (user), "UserName");
ret = g_variant_get_string (value, NULL);
g_variant_unref (value);
return ret;
}
const gchar *
accounts_user_get_real_name (AccountsUser *user)
{
GVariant *value;
const gchar *ret;
g_return_val_if_fail (ACCOUNTS_IS_USER (user), NULL);
value = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (user), "RealName");
ret = g_variant_get_string (value, NULL);
g_variant_unref (value);
return ret;
}
gboolean
accounts_user_get_automatic_login (AccountsUser *user)
{
GVariant *value;
gboolean ret;
g_return_val_if_fail (ACCOUNTS_IS_USER (user), FALSE);
value = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (user), "AutomaticLogin");
ret = g_variant_get_boolean (value);
g_variant_unref (value);
return ret;
}
static void
accounts_user_g_signal (GDBusProxy *proxy,
const gchar *sender_name,
const gchar *signal_name,
GVariant *parameters)
{
AccountsUser *user = ACCOUNTS_USER (proxy);
if (g_strcmp0 (signal_name, "Changed") == 0)
g_signal_emit (user, signals[CHANGED_SIGNAL], 0);
}
static void
accounts_user_g_properties_changed (GDBusProxy *proxy,
GVariant *changed_properties,
const gchar* const *invalidated_properties)
{
AccountsUser *user = ACCOUNTS_USER (proxy);
GVariantIter *iter;
const gchar *key;
if (changed_properties != NULL)
{
g_variant_get (changed_properties, "a{sv}", &iter);
while (g_variant_iter_next (iter, "{&sv}", &key, NULL))
{
if (g_strcmp0 (key, "AutomaticLogin") == 0)
g_object_notify (G_OBJECT (user), "automatic-login");
else if (g_strcmp0 (key, "RealName") == 0)
g_object_notify (G_OBJECT (user), "real-name");
else if (g_strcmp0 (key, "UserName") == 0)
g_object_notify (G_OBJECT (user), "user-name");
}
g_variant_iter_free (iter);
}
}
static void
accounts_user_class_init (AccountsUserClass *klass)
{
GObjectClass *gobject_class;
GDBusProxyClass *proxy_class;
gobject_class = G_OBJECT_CLASS (klass);
gobject_class->get_property = accounts_user_get_property;
gobject_class->finalize = accounts_user_finalize;
proxy_class = G_DBUS_PROXY_CLASS (klass);
proxy_class->g_signal = accounts_user_g_signal;
proxy_class->g_properties_changed = accounts_user_g_properties_changed;
g_object_class_install_property (gobject_class,
PROP_USER_NAME,
g_param_spec_string ("user-name",
"User Name",
"The user name of the user",
NULL,
G_PARAM_READABLE |
G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class,
PROP_REAL_NAME,
g_param_spec_string ("real-name",
"Real Name",
"The real name of the user",
NULL,
G_PARAM_READABLE |
G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class,
PROP_AUTOMATIC_LOGIN,
g_param_spec_boolean ("automatic-login",
"Automatic Login",
"Whether the user is automatically logged in",
FALSE,
G_PARAM_READABLE |
G_PARAM_STATIC_STRINGS));
signals[CHANGED_SIGNAL] = g_signal_new ("changed",
ACCOUNTS_TYPE_USER,
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (AccountsUserClass, changed),
NULL,
NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE,
0);
}
gchar *
accounts_user_frobnicate_sync (AccountsUser *user,
const gchar *flux,
gint baz,
GCancellable *cancellable,
GError **error)
{
gchar *ret;
GVariant *value;
g_return_val_if_fail (ACCOUNTS_IS_USER (user), NULL);
ret = NULL;
value = g_dbus_proxy_call_sync (G_DBUS_PROXY (user),
"Frobnicate",
g_variant_new ("(si)",
flux,
baz),
G_DBUS_CALL_FLAGS_NONE,
-1,
cancellable,
error);
if (value != NULL)
{
g_variant_get (value, "(s)", &ret);
g_variant_unref (value);
}
return ret;
}
void
accounts_user_frobnicate (AccountsUser *user,
const gchar *flux,
gint baz,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
g_return_if_fail (ACCOUNTS_IS_USER (user));
g_dbus_proxy_call (G_DBUS_PROXY (user),
"Frobnicate",
g_variant_new ("(si)",
flux,
baz),
G_DBUS_CALL_FLAGS_NONE,
-1,
cancellable,
callback,
user_data);
}
gchar *
accounts_user_frobnicate_finish (AccountsUser *user,
GAsyncResult *res,
GError **error)
{
gchar *ret;
GVariant *value;
ret = NULL;
value = g_dbus_proxy_call_finish (G_DBUS_PROXY (user), res, error);
if (value != NULL)
{
g_variant_get (value, "(s)", &ret);
g_variant_unref (value);
}
return ret;
}
/* ---------------------------------------------------------------------------------------------------- */
gint
main (gint argc, gchar *argv[])
{
return 0;
}