liblightdm-gobject/user.c

   1 /*
   2  * Copyright (C) 2010 Robert Ancell.
   3  * Author: Robert Ancell <robert.ancell@canonical.com>
   4  *
   5  * This library is free software; you can redistribute it and/or modify it under
   6  * the terms of the GNU Lesser General Public License as published by the Free
   7  * Software Foundation; either version 3 of the License, or (at your option) any
   8  * later version. See http://www.gnu.org/copyleft/lgpl.html the full text of the
   9  * license.
  10  */
  11
  12 #include "user-private.h"
  13
  14 enum {
  15     PROP_0,
  16     PROP_GREETER,
  17     PROP_NAME,
  18     PROP_REAL_NAME,
  19     PROP_DISPLAY_NAME,
  20     PROP_HOME_DIRECTORY,
  21     PROP_IMAGE,
  22     PROP_LANGUAGE,
  23     PROP_LAYOUT,
  24     PROP_SESSION,
  25     PROP_LOGGED_IN
  26 };
  27
  28 typedef struct
  29 {
  30     LdmGreeter *greeter;
  31
  32     gchar *name;
  33     gchar *real_name;
  34     gchar *home_directory;
  35     gchar *image;
  36     gboolean logged_in;
  37
  38     GKeyFile *dmrc_file;
  39     gchar *language;
  40     gchar *layout;
  41     gchar *session;
  42 } LdmUserPrivate;
  43
  44 G_DEFINE_TYPE (LdmUser, ldm_user, G_TYPE_OBJECT);
  45
  46 #define GET_PRIVATE(obj) G_TYPE_INSTANCE_GET_PRIVATE ((obj), LDM_TYPE_USER, LdmUserPrivate)
  47
  48 /**
  49  * ldm_user_new:
  50  *
  51  * Create a new user.
  52  * @greeter: The greeter the user is connected to
  53  * @name: The username
  54  * @real_name: The real name of the user
  55  * @home_directory: The home directory of the user
  56  * @image: The image URI
  57  * @logged_in: TRUE if this user is currently logged in
  58  *
  59  * Return value: the new #LdmUser
  60  **/
  61 LdmUser *
  62 ldm_user_new (LdmGreeter *greeter, const gchar *name, const gchar *real_name, const gchar *home_directory, const gchar *image, gboolean logged_in)
  63 {
  64     return g_object_new (LDM_TYPE_USER, "greeter", greeter, "name", name, "real-name", real_name, "home-directory", home_directory, "image", image, "logged-in", logged_in, NULL);
  65 }
  66
  67 gboolean
  68 ldm_user_update (LdmUser *user, const gchar *real_name, const gchar *home_directory, const gchar *image, gboolean logged_in)
  69 {
  70     LdmUserPrivate *priv = GET_PRIVATE (user);
  71
  72     if (g_strcmp0 (priv->real_name, real_name) == 0 &&
  73         g_strcmp0 (priv->home_directory, home_directory) == 0 &&
  74         g_strcmp0 (priv->image, image) == 0 &&
  75         priv->logged_in == logged_in)
  76         return FALSE;
  77
  78     g_free (priv->real_name);
  79     priv->real_name = g_strdup (real_name);
  80     g_free (priv->home_directory);
  81     priv->home_directory = g_strdup (home_directory);
  82     g_free (priv->image);
  83     priv->image = g_strdup (image);
  84     priv->logged_in = logged_in;
  85
  86     return TRUE;
  87 }
  88
  89 /**
  90  * ldm_user_get_name:
  91  * @user: A #LdmUser
  92  *
  93  * Get the name of a user.
  94  *
  95  * Return value: The name of the given user
  96  **/
  97 const gchar *
  98 ldm_user_get_name (LdmUser *user)
  99 {
 100     g_return_val_if_fail (LDM_IS_USER (user), NULL);
 101     return GET_PRIVATE (user)->name;
 102 }
 103
 104 void
 105 ldm_user_set_name (LdmUser *user, const gchar *name)
 106 {
 107     LdmUserPrivate *priv;
 108
 109     g_return_if_fail (LDM_IS_USER (user));
 110
 111     priv = GET_PRIVATE (user);
 112     g_free (priv->name);
 113     priv->name = g_strdup (name);
 114 }
 115
 116 /**
 117  * ldm_user_get_real_name:
 118  * @user: A #LdmUser
 119  *
 120  * Get the real name of a user.
 121  *
 122  * Return value: The real name of the given user (may be blank)
 123  **/
 124 const gchar *
 125 ldm_user_get_real_name (LdmUser *user)
 126 {
 127     g_return_val_if_fail (LDM_IS_USER (user), NULL);
 128     return GET_PRIVATE (user)->real_name;
 129 }
 130
 131 void
 132 ldm_user_set_real_name (LdmUser *user, const gchar *real_name)
 133 {
 134     LdmUserPrivate *priv;
 135
 136     g_return_if_fail (LDM_IS_USER (user));
 137
 138     priv = GET_PRIVATE (user);
 139     g_free (priv->real_name);
 140     priv->real_name = g_strdup (real_name);
 141 }
 142
 143 /**
 144  * ldm_user_get_display_name:
 145  * @user: A #LdmUser
 146  *
 147  * Get the display name of a user.
 148  *
 149  * Return value: The display name of the given user
 150  **/
 151 const gchar *
 152 ldm_user_get_display_name (LdmUser *user)
 153 {
 154     LdmUserPrivate *priv;
 155
 156     g_return_val_if_fail (LDM_IS_USER (user), NULL);
 157
 158     priv = GET_PRIVATE (user);
 159     if (priv->real_name)
 160         return priv->real_name;
 161     else
 162         return priv->name;
 163 }
 164
 165 /**
 166  * ldm_user_get_home_directory:
 167  * @user: A #LdmUser
 168  *
 169  * Get the home directory for a user.
 170  *
 171  * Return value: The users home directory
 172  */
 173 const gchar *
 174 ldm_user_get_home_directory (LdmUser *user)
 175 {
 176     g_return_val_if_fail (LDM_IS_USER (user), NULL);
 177     return GET_PRIVATE (user)->home_directory;
 178 }
 179
 180 void
 181 ldm_user_set_home_directory (LdmUser *user, const gchar *home_directory)
 182 {
 183     LdmUserPrivate *priv;
 184
 185     g_return_if_fail (LDM_IS_USER (user));
 186
 187     priv = GET_PRIVATE (user);
 188     g_free (priv->home_directory);
 189     priv->home_directory = g_strdup (home_directory);
 190 }
 191
 192 /**
 193  * ldm_user_get_image:
 194  * @user: A #LdmUser
 195  *
 196  * Get the image URI for a user.
 197  *
 198  * Return value: The image URI for the given user or NULL if no URI
 199  **/
 200 const gchar *
 201 ldm_user_get_image (LdmUser *user)
 202 {
 203     g_return_val_if_fail (LDM_IS_USER (user), NULL);
 204     return GET_PRIVATE (user)->image;
 205 }
 206
 207 void
 208 ldm_user_set_image (LdmUser *user, const gchar *image)
 209 {
 210     LdmUserPrivate *priv;
 211
 212     g_return_if_fail (LDM_IS_USER (user));
 213
 214     priv = GET_PRIVATE (user);
 215     g_free (priv->image);
 216     priv->image = g_strdup (image);
 217 }
 218
 219 static void
 220 load_dmrc (LdmUser *user)
 221 {
 222     LdmUserPrivate *priv = GET_PRIVATE (user);
 223     gchar *path;
 224     gboolean have_dmrc;
 225
 226     priv->dmrc_file = g_key_file_new ();
 227
 228     /* Load from the user directory */
 229     path = g_build_filename (priv->home_directory, ".dmrc", NULL);
 230     have_dmrc = g_key_file_load_from_file (priv->dmrc_file, path, G_KEY_FILE_KEEP_COMMENTS, NULL);
 231     g_free (path);
 232
 233     /* If no ~/.dmrc, then load from the cache */
 234     // FIXME
 235
 236     // FIXME: Watch for changes
 237
 238     priv->language = g_key_file_get_string (priv->dmrc_file, "Desktop", "Language", NULL);
 239     priv->layout = g_key_file_get_string (priv->dmrc_file, "Desktop", "Layout", NULL);
 240     priv->session = g_key_file_get_string (priv->dmrc_file, "Desktop", "Session", NULL);
 241 }
 242
 243 /**
 244  * ldm_user_get_language
 245  * @user: A #LdmUser
 246  *
 247  * Get the language for a user.
 248  *
 249  * Return value: The language for the given user or NULL if using system defaults.
 250  **/
 251 const gchar *
 252 ldm_user_get_language (LdmUser *user)
 253 {
 254     g_return_val_if_fail (LDM_IS_USER (user), NULL);
 255     load_dmrc (user);
 256     return GET_PRIVATE (user)->language;
 257 }
 258
 259 /**
 260  * ldm_user_get_layout
 261  * @user: A #LdmUser
 262  *
 263  * Get the keyboard layout for a user.
 264  *
 265  * Return value: The keyboard layoyt for the given user or NULL if using system defaults.
 266  **/
 267 const gchar *
 268 ldm_user_get_layout (LdmUser *user)
 269 {
 270     g_return_val_if_fail (LDM_IS_USER (user), NULL);
 271     load_dmrc (user);
 272     return GET_PRIVATE (user)->layout;
 273 }
 274
 275 /**
 276  * ldm_user_get_session
 277  * @user: A #LdmUser
 278  *
 279  * Get the session for a user.
 280  *
 281  * Return value: The session for the given user or NULL if using system defaults.
 282  **/
 283 const gchar *
 284 ldm_user_get_session (LdmUser *user)
 285 {
 286     g_return_val_if_fail (LDM_IS_USER (user), NULL);
 287     load_dmrc (user);
 288     return GET_PRIVATE (user)->session;
 289 }
 290
 291 /**
 292  * ldm_user_get_logged_in:
 293  * @user: A #LdmUser
 294  *
 295  * Check if a user is logged in.
 296  *
 297  * Return value: TRUE if the user is currently logged in.
 298  **/
 299 gboolean
 300 ldm_user_get_logged_in (LdmUser *user)
 301 {
 302     g_return_val_if_fail (LDM_IS_USER (user), FALSE);
 303     return GET_PRIVATE (user)->logged_in;
 304 }
 305
 306 void
 307 ldm_user_set_logged_in (LdmUser *user, gboolean logged_in)
 308 {
 309     g_return_if_fail (LDM_IS_USER (user));
 310     GET_PRIVATE (user)->logged_in = logged_in;
 311 }
 312
 313 static void
 314 ldm_user_init (LdmUser *user)
 315 {
 316 }
 317
 318 static void
 319 ldm_user_set_property (GObject      *object,
 320                        guint         prop_id,
 321                        const GValue *value,
 322                        GParamSpec   *pspec)
 323 {
 324     LdmUser *self = LDM_USER (object);
 325     LdmUserPrivate *priv = GET_PRIVATE (self);
 326
 327     switch (prop_id) {
 328     case PROP_GREETER:
 329         priv->greeter = g_object_ref (g_value_get_object (value));
 330         break;
 331     case PROP_NAME:
 332         ldm_user_set_name (self, g_value_get_string (value));
 333         break;
 334     case PROP_REAL_NAME:
 335         ldm_user_set_real_name (self, g_value_get_string (value));
 336         break;
 337     case PROP_HOME_DIRECTORY:
 338         ldm_user_set_home_directory (self, g_value_get_string (value));
 339         break;
 340     case PROP_IMAGE:
 341         ldm_user_set_image (self, g_value_get_string (value));
 342         break;
 343     case PROP_LOGGED_IN:
 344         ldm_user_set_logged_in (self, g_value_get_boolean (value));
 345         break;
 346     default:
 347         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 348         break;
 349     }
 350 }
 351
 352 static void
 353 ldm_user_get_property (GObject    *object,
 354                        guint       prop_id,
 355                        GValue     *value,
 356                        GParamSpec *pspec)
 357 {
 358     LdmUser *self;
 359
 360     self = LDM_USER (object);
 361
 362     switch (prop_id) {
 363     case PROP_NAME:
 364         g_value_set_string (value, ldm_user_get_name (self));
 365         break;
 366     case PROP_REAL_NAME:
 367         g_value_set_string (value, ldm_user_get_real_name (self));
 368         break;
 369     case PROP_DISPLAY_NAME:
 370         g_value_set_string (value, ldm_user_get_display_name (self));
 371         break;
 372     case PROP_HOME_DIRECTORY:
 373         g_value_set_string (value, ldm_user_get_home_directory (self));
 374         break;
 375     case PROP_IMAGE:
 376         g_value_set_string (value, ldm_user_get_image (self));
 377         break;
 378     case PROP_LANGUAGE:
 379         g_value_set_string (value, ldm_user_get_language (self));
 380         break;
 381     case PROP_LAYOUT:
 382         g_value_set_string (value, ldm_user_get_layout (self));
 383         break;
 384     case PROP_SESSION:
 385         g_value_set_string (value, ldm_user_get_session (self));
 386         break;
 387     case PROP_LOGGED_IN:
 388         g_value_set_boolean (value, ldm_user_get_logged_in (self));
 389         break;
 390     default:
 391         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 392         break;
 393     }
 394 }
 395
 396 static void
 397 ldm_user_finalize (GObject *object)
 398 {
 399     LdmUser *self = LDM_USER (object);
 400     LdmUserPrivate *priv = GET_PRIVATE (self);
 401
 402     g_free (priv->name);
 403     g_free (priv->real_name);
 404     g_free (priv->home_directory);
 405     g_free (priv->image);
 406     if (priv->dmrc_file)
 407         g_key_file_free (priv->dmrc_file);
 408 }
 409
 410 static void
 411 ldm_user_class_init (LdmUserClass *klass)
 412 {
 413     GObjectClass *object_class = G_OBJECT_CLASS (klass);
 414
 415     g_type_class_add_private (klass, sizeof (LdmUserPrivate));
 416
 417     object_class->set_property = ldm_user_set_property;
 418     object_class->get_property = ldm_user_get_property;
 419     object_class->finalize = ldm_user_finalize;
 420
 421     g_object_class_install_property(object_class,
 422                                     PROP_GREETER,
 423                                     g_param_spec_object("greeter",
 424                                                         "greeter",
 425                                                         "Greeter",
 426                                                         LDM_TYPE_GREETER,
 427                                                         G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
 428     g_object_class_install_property(object_class,
 429                                     PROP_NAME,
 430                                     g_param_spec_string("name",
 431                                                         "name",
 432                                                         "Username",
 433                                                         NULL,
 434                                                         G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 435     g_object_class_install_property(object_class,
 436                                     PROP_REAL_NAME,
 437                                     g_param_spec_string("real-name",
 438                                                         "real-name",
 439                                                         "Users real name",
 440                                                         NULL,
 441                                                         G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 442     g_object_class_install_property(object_class,
 443                                     PROP_DISPLAY_NAME,
 444                                     g_param_spec_string("display-name",
 445                                                         "display-name",
 446                                                         "Users display name",
 447                                                         NULL,
 448                                                         G_PARAM_READABLE));
 449     g_object_class_install_property(object_class,
 450                                     PROP_HOME_DIRECTORY,
 451                                     g_param_spec_string("home-directory",
 452                                                         "home-directory",
 453                                                         "Home directory",
 454                                                         NULL,
 455                                                         G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 456     g_object_class_install_property(object_class,
 457                                     PROP_IMAGE,
 458                                     g_param_spec_string("image",
 459                                                         "image",
 460                                                         "Avatar image",
 461                                                         NULL,
 462                                                         G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 463     g_object_class_install_property(object_class,
 464                                     PROP_LANGUAGE,
 465                                     g_param_spec_string("language",
 466                                                         "language",
 467                                                         "Language used by this user",
 468                                                         NULL,
 469                                                         G_PARAM_READABLE));
 470     g_object_class_install_property(object_class,
 471                                     PROP_LAYOUT,
 472                                     g_param_spec_string("layout",
 473                                                         "layout",
 474                                                         "Keyboard layout used by this user",
 475                                                         NULL,
 476                                                         G_PARAM_READABLE));
 477     g_object_class_install_property(object_class,
 478                                     PROP_SESSION,
 479                                     g_param_spec_string("session",
 480                                                         "session",
 481                                                         "Session used by this user",
 482                                                         NULL,
 483                                                         G_PARAM_READABLE));
 484     g_object_class_install_property(object_class,
 485                                     PROP_LOGGED_IN,
 486                                     g_param_spec_boolean("logged-in",
 487                                                          "logged-in",
 488                                                          "TRUE if the user is currently in a session",
 489                                                          FALSE,
 490                                                          G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 491 }