libpurple/status.c

   1 /* purple
   2  *
   3  * Purple is the legal property of its developers, whose names are too numerous
   4  * to list here.  Please refer to the COPYRIGHT file distributed with this
   5  * source distribution.
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  20  */
  21 #include "internal.h"
  22 #include "glibcompat.h"
  23
  24 #include "buddylist.h"
  25 #include "core.h"
  26 #include "dbus-maybe.h"
  27 #include "debug.h"
  28 #include "notify.h"
  29 #include "prefs.h"
  30 #include "status.h"
  31
  32 #define PURPLE_STATUS_GET_PRIVATE(obj) \
  33         (G_TYPE_INSTANCE_GET_PRIVATE((obj), PURPLE_TYPE_STATUS, PurpleStatusPrivate))
  34
  35 typedef struct _PurpleStatusPrivate  PurpleStatusPrivate;
  36
  37 /*
  38  * A type of status.
  39  */
  40 struct _PurpleStatusType
  41 {
  42         int box_count;
  43
  44         PurpleStatusPrimitive primitive;
  45
  46         char *id;
  47         char *name;
  48
  49         gboolean saveable;
  50         gboolean user_settable;
  51         gboolean independent;
  52
  53         GList *attrs;
  54 };
  55
  56 /*
  57  * A status attribute.
  58  */
  59 struct _PurpleStatusAttribute
  60 {
  61         char *id;
  62         char *name;
  63         GValue *value_type;
  64 };
  65
  66 /*
  67  * Private data for PurpleStatus
  68  */
  69 struct _PurpleStatusPrivate
  70 {
  71         PurpleStatusType *status_type;
  72         PurplePresence *presence;
  73
  74         gboolean active;
  75
  76         /*
  77          * The current values of the attributes for this status.  The
  78          * key is a string containing the name of the attribute.  It is
  79          * a borrowed reference from the list of attrs in the
  80          * PurpleStatusType.  The value is a GValue.
  81          */
  82         GHashTable *attr_values;
  83 };
  84
  85 /* GObject property enums */
  86 enum
  87 {
  88         PROP_0,
  89         PROP_STATUS_TYPE,
  90         PROP_PRESENCE,
  91         PROP_ACTIVE,
  92         PROP_LAST
  93 };
  94
  95 typedef struct
  96 {
  97         PurpleAccount *account;
  98         char *name;
  99 } PurpleStatusBuddyKey;
 100
 101 static GObjectClass *parent_class;
 102 static GParamSpec *properties[PROP_LAST];
 103
 104 static int primitive_scores[] =
 105 {
 106         0,      /* unset                    */
 107         -500,   /* offline                  */
 108         100,    /* available                */
 109         -75,    /* unavailable              */
 110         -50,    /* invisible                */
 111         -100,   /* away                     */
 112         -200,   /* extended away            */
 113         -400,   /* mobile                   */
 114         0,      /* tune                     */
 115         0,      /* mood                     */
 116         -10,    /* idle, special case.      */
 117         -5,     /* idle time, special case. */
 118         10      /* Offline messageable      */
 119 };
 120
 121 #define SCORE_IDLE      9
 122 #define SCORE_IDLE_TIME 10
 123 #define SCORE_OFFLINE_MESSAGE 11
 124
 125 /**************************************************************************
 126  * PurpleStatusPrimitive API
 127  **************************************************************************/
 128 static struct PurpleStatusPrimitiveMap
 129 {
 130         PurpleStatusPrimitive type;
 131         const char *id;
 132         const char *name;
 133
 134 } const status_primitive_map[] =
 135 {
 136         { PURPLE_STATUS_UNSET,           "unset",           N_("Unset")               },
 137         { PURPLE_STATUS_OFFLINE,         "offline",         N_("Offline")             },
 138         { PURPLE_STATUS_AVAILABLE,       "available",       N_("Available")           },
 139         { PURPLE_STATUS_UNAVAILABLE,     "unavailable",     N_("Do not disturb")      },
 140         { PURPLE_STATUS_INVISIBLE,       "invisible",       N_("Invisible")           },
 141         { PURPLE_STATUS_AWAY,            "away",            N_("Away")                },
 142         { PURPLE_STATUS_EXTENDED_AWAY,   "extended_away",   N_("Extended away")       },
 143         { PURPLE_STATUS_MOBILE,          "mobile",          N_("Mobile")              },
 144         { PURPLE_STATUS_TUNE,            "tune",            N_("Listening to music"), },
 145         { PURPLE_STATUS_MOOD,            "mood",            N_("Feeling")             },
 146 };
 147
 148 int *
 149 _purple_statuses_get_primitive_scores(void)
 150 {
 151         return primitive_scores;
 152 }
 153
 154 const char *
 155 purple_primitive_get_id_from_type(PurpleStatusPrimitive type)
 156 {
 157     int i;
 158
 159     for (i = 0; i < PURPLE_STATUS_NUM_PRIMITIVES; i++)
 160     {
 161                 if (type == status_primitive_map[i].type)
 162                         return status_primitive_map[i].id;
 163     }
 164
 165     return status_primitive_map[0].id;
 166 }
 167
 168 const char *
 169 purple_primitive_get_name_from_type(PurpleStatusPrimitive type)
 170 {
 171     int i;
 172
 173     for (i = 0; i < PURPLE_STATUS_NUM_PRIMITIVES; i++)
 174     {
 175         if (type == status_primitive_map[i].type)
 176                 return _(status_primitive_map[i].name);
 177     }
 178
 179     return _(status_primitive_map[0].name);
 180 }
 181
 182 PurpleStatusPrimitive
 183 purple_primitive_get_type_from_id(const char *id)
 184 {
 185     int i;
 186
 187     g_return_val_if_fail(id != NULL, PURPLE_STATUS_UNSET);
 188
 189     for (i = 0; i < PURPLE_STATUS_NUM_PRIMITIVES; i++)
 190     {
 191                 if (purple_strequal(id, status_primitive_map[i].id))
 192             return status_primitive_map[i].type;
 193     }
 194
 195     return status_primitive_map[0].type;
 196 }
 197
 198
 199 /**************************************************************************
 200  * PurpleStatusType API
 201  **************************************************************************/
 202 PurpleStatusType *
 203 purple_status_type_new_full(PurpleStatusPrimitive primitive, const char *id,
 204                                                   const char *name, gboolean saveable,
 205                                                   gboolean user_settable, gboolean independent)
 206 {
 207         PurpleStatusType *status_type;
 208
 209         g_return_val_if_fail(primitive != PURPLE_STATUS_UNSET, NULL);
 210
 211         status_type = g_new0(PurpleStatusType, 1);
 212         PURPLE_DBUS_REGISTER_POINTER(status_type, PurpleStatusType);
 213
 214         status_type->primitive     = primitive;
 215         status_type->saveable      = saveable;
 216         status_type->user_settable = user_settable;
 217         status_type->independent   = independent;
 218
 219         if (id != NULL)
 220                 status_type->id = g_strdup(id);
 221         else
 222                 status_type->id = g_strdup(purple_primitive_get_id_from_type(primitive));
 223
 224         if (name != NULL)
 225                 status_type->name = g_strdup(name);
 226         else
 227                 status_type->name = g_strdup(purple_primitive_get_name_from_type(primitive));
 228
 229         return status_type;
 230 }
 231
 232 PurpleStatusType *
 233 purple_status_type_new(PurpleStatusPrimitive primitive, const char *id,
 234                                          const char *name, gboolean user_settable)
 235 {
 236         g_return_val_if_fail(primitive != PURPLE_STATUS_UNSET, NULL);
 237
 238         return purple_status_type_new_full(primitive, id, name, TRUE,
 239                         user_settable, FALSE);
 240 }
 241
 242 static void
 243 status_type_add_attr(PurpleStatusType *status_type, const char *id,
 244                 const char *name, GValue *value)
 245 {
 246         PurpleStatusAttribute *attr;
 247
 248         g_return_if_fail(status_type != NULL);
 249         g_return_if_fail(id          != NULL);
 250         g_return_if_fail(name        != NULL);
 251         g_return_if_fail(value       != NULL);
 252
 253         attr = purple_status_attribute_new(id, name, value);
 254
 255         status_type->attrs = g_list_append(status_type->attrs, attr);
 256 }
 257
 258 static void
 259 status_type_add_attrs_vargs(PurpleStatusType *status_type, va_list args)
 260 {
 261         const char *id, *name;
 262         GValue *value;
 263
 264         g_return_if_fail(status_type != NULL);
 265
 266         while ((id = va_arg(args, const char *)) != NULL)
 267         {
 268                 name = va_arg(args, const char *);
 269                 g_return_if_fail(name != NULL);
 270
 271                 value = va_arg(args, GValue *);
 272                 g_return_if_fail(value != NULL);
 273
 274                 status_type_add_attr(status_type, id, name, value);
 275         }
 276 }
 277
 278 PurpleStatusType *
 279 purple_status_type_new_with_attrs(PurpleStatusPrimitive primitive,
 280                 const char *id, const char *name,
 281                 gboolean saveable, gboolean user_settable,
 282                 gboolean independent, const char *attr_id,
 283                 const char *attr_name, GValue *attr_value,
 284                 ...)
 285 {
 286         PurpleStatusType *status_type;
 287         va_list args;
 288
 289         g_return_val_if_fail(primitive  != PURPLE_STATUS_UNSET, NULL);
 290         g_return_val_if_fail(attr_id    != NULL,              NULL);
 291         g_return_val_if_fail(attr_name  != NULL,              NULL);
 292         g_return_val_if_fail(attr_value != NULL,              NULL);
 293
 294         status_type = purple_status_type_new_full(primitive, id, name, saveable,
 295                         user_settable, independent);
 296
 297         /* Add the first attribute */
 298         status_type_add_attr(status_type, attr_id, attr_name, attr_value);
 299
 300         va_start(args, attr_value);
 301         status_type_add_attrs_vargs(status_type, args);
 302         va_end(args);
 303
 304         return status_type;
 305 }
 306
 307 void
 308 purple_status_type_destroy(PurpleStatusType *status_type)
 309 {
 310         g_return_if_fail(status_type != NULL);
 311
 312         g_free(status_type->id);
 313         g_free(status_type->name);
 314
 315         g_list_foreach(status_type->attrs, (GFunc)purple_status_attribute_destroy, NULL);
 316         g_list_free(status_type->attrs);
 317
 318         PURPLE_DBUS_UNREGISTER_POINTER(status_type);
 319         g_free(status_type);
 320 }
 321
 322 PurpleStatusPrimitive
 323 purple_status_type_get_primitive(const PurpleStatusType *status_type)
 324 {
 325         g_return_val_if_fail(status_type != NULL, PURPLE_STATUS_UNSET);
 326
 327         return status_type->primitive;
 328 }
 329
 330 const char *
 331 purple_status_type_get_id(const PurpleStatusType *status_type)
 332 {
 333         g_return_val_if_fail(status_type != NULL, NULL);
 334
 335         return status_type->id;
 336 }
 337
 338 const char *
 339 purple_status_type_get_name(const PurpleStatusType *status_type)
 340 {
 341         g_return_val_if_fail(status_type != NULL, NULL);
 342
 343         return status_type->name;
 344 }
 345
 346 gboolean
 347 purple_status_type_is_saveable(const PurpleStatusType *status_type)
 348 {
 349         g_return_val_if_fail(status_type != NULL, FALSE);
 350
 351         return status_type->saveable;
 352 }
 353
 354 gboolean
 355 purple_status_type_is_user_settable(const PurpleStatusType *status_type)
 356 {
 357         g_return_val_if_fail(status_type != NULL, FALSE);
 358
 359         return status_type->user_settable;
 360 }
 361
 362 gboolean
 363 purple_status_type_is_independent(const PurpleStatusType *status_type)
 364 {
 365         g_return_val_if_fail(status_type != NULL, FALSE);
 366
 367         return status_type->independent;
 368 }
 369
 370 gboolean
 371 purple_status_type_is_exclusive(const PurpleStatusType *status_type)
 372 {
 373         g_return_val_if_fail(status_type != NULL, FALSE);
 374
 375         return !status_type->independent;
 376 }
 377
 378 gboolean
 379 purple_status_type_is_available(const PurpleStatusType *status_type)
 380 {
 381         PurpleStatusPrimitive primitive;
 382
 383         g_return_val_if_fail(status_type != NULL, FALSE);
 384
 385         primitive = purple_status_type_get_primitive(status_type);
 386
 387         return (primitive == PURPLE_STATUS_AVAILABLE);
 388 }
 389
 390 PurpleStatusAttribute *
 391 purple_status_type_get_attr(const PurpleStatusType *status_type, const char *id)
 392 {
 393         GList *l;
 394
 395         g_return_val_if_fail(status_type != NULL, NULL);
 396         g_return_val_if_fail(id          != NULL, NULL);
 397
 398         for (l = status_type->attrs; l != NULL; l = l->next)
 399         {
 400                 PurpleStatusAttribute *attr = (PurpleStatusAttribute *)l->data;
 401
 402                 if (purple_strequal(purple_status_attribute_get_id(attr), id))
 403                         return attr;
 404         }
 405
 406         return NULL;
 407 }
 408
 409 GList *
 410 purple_status_type_get_attrs(const PurpleStatusType *status_type)
 411 {
 412         g_return_val_if_fail(status_type != NULL, NULL);
 413
 414         return status_type->attrs;
 415 }
 416
 417 const PurpleStatusType *
 418 purple_status_type_find_with_id(GList *status_types, const char *id)
 419 {
 420         PurpleStatusType *status_type;
 421
 422         g_return_val_if_fail(id != NULL, NULL);
 423
 424         while (status_types != NULL)
 425         {
 426                 status_type = status_types->data;
 427
 428                 if (purple_strequal(id, status_type->id))
 429                         return status_type;
 430
 431                 status_types = status_types->next;
 432         }
 433
 434         return NULL;
 435 }
 436
 437
 438 /**************************************************************************
 439 * PurpleStatusAttribute API
 440 **************************************************************************/
 441 PurpleStatusAttribute *
 442 purple_status_attribute_new(const char *id, const char *name, GValue *value_type)
 443 {
 444         PurpleStatusAttribute *attr;
 445
 446         g_return_val_if_fail(id         != NULL, NULL);
 447         g_return_val_if_fail(name       != NULL, NULL);
 448         g_return_val_if_fail(value_type != NULL, NULL);
 449
 450         attr = g_new0(PurpleStatusAttribute, 1);
 451         PURPLE_DBUS_REGISTER_POINTER(attr, PurpleStatusAttribute);
 452
 453         attr->id         = g_strdup(id);
 454         attr->name       = g_strdup(name);
 455         attr->value_type = value_type;
 456
 457         return attr;
 458 }
 459
 460 void
 461 purple_status_attribute_destroy(PurpleStatusAttribute *attr)
 462 {
 463         g_return_if_fail(attr != NULL);
 464
 465         g_free(attr->id);
 466         g_free(attr->name);
 467
 468         purple_value_free(attr->value_type);
 469
 470         PURPLE_DBUS_UNREGISTER_POINTER(attr);
 471         g_free(attr);
 472 }
 473
 474 const char *
 475 purple_status_attribute_get_id(const PurpleStatusAttribute *attr)
 476 {
 477         g_return_val_if_fail(attr != NULL, NULL);
 478
 479         return attr->id;
 480 }
 481
 482 const char *
 483 purple_status_attribute_get_name(const PurpleStatusAttribute *attr)
 484 {
 485         g_return_val_if_fail(attr != NULL, NULL);
 486
 487         return attr->name;
 488 }
 489
 490 GValue *
 491 purple_status_attribute_get_value(const PurpleStatusAttribute *attr)
 492 {
 493         g_return_val_if_fail(attr != NULL, NULL);
 494
 495         return attr->value_type;
 496 }
 497
 498
 499 /**************************************************************************
 500 * PurpleStatus API
 501 **************************************************************************/
 502 static void
 503 notify_buddy_status_update(PurpleBuddy *buddy, PurplePresence *presence,
 504                 PurpleStatus *old_status, PurpleStatus *new_status)
 505 {
 506         if (purple_prefs_get_bool("/purple/logging/log_system"))
 507         {
 508                 GDateTime *current_time = g_date_time_new_now_utc();
 509                 const char *buddy_alias = purple_buddy_get_alias(buddy);
 510                 char *tmp, *logtmp;
 511                 PurpleLog *log;
 512
 513                 if (old_status != NULL)
 514                 {
 515                         tmp = g_strdup_printf(_("%s (%s) changed status from %s to %s"), buddy_alias,
 516                                               purple_buddy_get_name(buddy),
 517                                               purple_status_get_name(old_status),
 518                                               purple_status_get_name(new_status));
 519                         logtmp = g_markup_escape_text(tmp, -1);
 520                 }
 521                 else
 522                 {
 523                         /* old_status == NULL when an independent status is toggled. */
 524
 525                         if (purple_status_is_active(new_status))
 526                         {
 527                                 tmp = g_strdup_printf(_("%s (%s) is now %s"), buddy_alias,
 528                                                       purple_buddy_get_name(buddy),
 529                                                       purple_status_get_name(new_status));
 530                                 logtmp = g_markup_escape_text(tmp, -1);
 531                         }
 532                         else
 533                         {
 534                                 tmp = g_strdup_printf(_("%s (%s) is no longer %s"), buddy_alias,
 535                                                       purple_buddy_get_name(buddy),
 536                                                       purple_status_get_name(new_status));
 537                                 logtmp = g_markup_escape_text(tmp, -1);
 538                         }
 539                 }
 540
 541                 log = purple_account_get_log(purple_buddy_get_account(buddy), FALSE);
 542                 if (log != NULL)
 543                 {
 544                         purple_log_write(log, PURPLE_MESSAGE_SYSTEM, buddy_alias,
 545                                        current_time, logtmp);
 546                 }
 547
 548                 g_date_time_unref(current_time);
 549                 g_free(tmp);
 550                 g_free(logtmp);
 551         }
 552 }
 553
 554 static void
 555 notify_status_update(PurplePresence *presence, PurpleStatus *old_status,
 556                                          PurpleStatus *new_status)
 557 {
 558         if (PURPLE_IS_ACCOUNT_PRESENCE(presence))
 559         {
 560                 PurpleAccount *account = purple_account_presence_get_account(
 561                                 PURPLE_ACCOUNT_PRESENCE(presence));
 562                 PurpleAccountUiOps *ops = purple_accounts_get_ui_ops();
 563
 564                 if (purple_account_get_enabled(account, purple_core_get_ui()))
 565                         purple_protocol_change_account_status(account, old_status, new_status);
 566
 567                 if (ops != NULL && ops->status_changed != NULL)
 568                 {
 569                         ops->status_changed(account, new_status);
 570                 }
 571         }
 572         else if (PURPLE_IS_BUDDY_PRESENCE(presence))
 573         {
 574                 notify_buddy_status_update(purple_buddy_presence_get_buddy(
 575                                 PURPLE_BUDDY_PRESENCE(presence)), presence, old_status,
 576                                 new_status);
 577         }
 578 }
 579
 580 static void
 581 status_has_changed(PurpleStatus *status)
 582 {
 583         PurplePresence *presence;
 584         PurpleStatus *old_status;
 585
 586         presence   = purple_status_get_presence(status);
 587
 588         /*
 589          * If this status is exclusive, then we must be setting it to "active."
 590          * Since we are setting it to active, we want to set the currently
 591          * active status to "inactive."
 592          */
 593         if (purple_status_is_exclusive(status))
 594         {
 595                 old_status = purple_presence_get_active_status(presence);
 596                 if (old_status != NULL && (old_status != status)) {
 597                         PURPLE_STATUS_GET_PRIVATE(old_status)->active = FALSE;
 598                         g_object_notify_by_pspec(G_OBJECT(old_status),
 599                                         properties[PROP_ACTIVE]);
 600                 }
 601         }
 602         else
 603                 old_status = NULL;
 604
 605         g_object_set(presence, "active-status", status, NULL);
 606         g_object_notify_by_pspec(G_OBJECT(status), properties[PROP_ACTIVE]);
 607
 608         notify_status_update(presence, old_status, status);
 609 }
 610
 611 static void
 612 status_set_attr_boolean(PurpleStatus *status, const char *id,
 613                 gboolean value)
 614 {
 615         GValue *attr_value;
 616
 617         g_return_if_fail(PURPLE_IS_STATUS(status));
 618         g_return_if_fail(id != NULL);
 619
 620         /* Make sure this attribute exists and is the correct type. */
 621         attr_value = purple_status_get_attr_value(status, id);
 622         g_return_if_fail(attr_value != NULL);
 623         g_return_if_fail(G_VALUE_TYPE(attr_value) == G_TYPE_BOOLEAN);
 624
 625         g_value_set_boolean(attr_value, value);
 626 }
 627
 628 static void
 629 status_set_attr_int(PurpleStatus *status, const char *id, int value)
 630 {
 631         GValue *attr_value;
 632
 633         g_return_if_fail(PURPLE_IS_STATUS(status));
 634         g_return_if_fail(id != NULL);
 635
 636         /* Make sure this attribute exists and is the correct type. */
 637         attr_value = purple_status_get_attr_value(status, id);
 638         g_return_if_fail(attr_value != NULL);
 639         g_return_if_fail(G_VALUE_TYPE(attr_value) == G_TYPE_INT);
 640
 641         g_value_set_int(attr_value, value);
 642 }
 643
 644 static void
 645 status_set_attr_string(PurpleStatus *status, const char *id,
 646                 const char *value)
 647 {
 648         GValue *attr_value;
 649
 650         g_return_if_fail(PURPLE_IS_STATUS(status));
 651         g_return_if_fail(id != NULL);
 652
 653         /* Make sure this attribute exists and is the correct type. */
 654         attr_value = purple_status_get_attr_value(status, id);
 655         /* This used to be g_return_if_fail, but it's failing a LOT, so
 656          * let's generate a log error for now. */
 657         /* g_return_if_fail(attr_value != NULL); */
 658         if (attr_value == NULL) {
 659                 purple_debug_error("status",
 660                                  "Attempted to set status attribute '%s' for "
 661                                  "status '%s', which is not legal.  Fix "
 662                                  "this!\n", id,
 663                                  purple_status_type_get_name(purple_status_get_status_type(status)));
 664                 return;
 665         }
 666         g_return_if_fail(G_VALUE_TYPE(attr_value) == G_TYPE_STRING);
 667
 668         /* XXX: Check if the value has actually changed. If it has, and the status
 669          * is active, should this trigger 'status_has_changed'? */
 670         g_value_set_string(attr_value, value);
 671 }
 672
 673 void
 674 purple_status_set_active(PurpleStatus *status, gboolean active)
 675 {
 676         purple_status_set_active_with_attrs_list(status, active, NULL);
 677 }
 678
 679 /*
 680  * This used to parse the va_list directly, but now it creates a GList
 681  * and passes it to purple_status_set_active_with_attrs_list().  That
 682  * function was created because account.c needs to pass a GList of
 683  * attributes to the status API.
 684  */
 685 void
 686 purple_status_set_active_with_attrs(PurpleStatus *status, gboolean active, va_list args)
 687 {
 688         GList *attrs = NULL;
 689         const gchar *id;
 690         gpointer data;
 691
 692         while ((id = va_arg(args, const char *)) != NULL)
 693         {
 694                 attrs = g_list_append(attrs, (char *)id);
 695                 data = va_arg(args, void *);
 696                 attrs = g_list_append(attrs, data);
 697         }
 698         purple_status_set_active_with_attrs_list(status, active, attrs);
 699         g_list_free(attrs);
 700 }
 701
 702 void
 703 purple_status_set_active_with_attrs_list(PurpleStatus *status, gboolean active,
 704                                                                            GList *attrs)
 705 {
 706         gboolean changed = FALSE;
 707         GList *l;
 708         GList *specified_attr_ids = NULL;
 709         PurpleStatusType *status_type;
 710         PurpleStatusPrivate *priv = PURPLE_STATUS_GET_PRIVATE(status);
 711
 712         g_return_if_fail(priv != NULL);
 713
 714         if (!active && purple_status_is_exclusive(status))
 715         {
 716                 purple_debug_error("status",
 717                                    "Cannot deactivate an exclusive status (%s).\n",
 718                                    purple_status_get_id(status));
 719                 return;
 720         }
 721
 722         if (priv->active != active)
 723         {
 724                 changed = TRUE;
 725         }
 726
 727         priv->active = active;
 728
 729         /* Set any attributes */
 730         l = attrs;
 731         while (l != NULL)
 732         {
 733                 const gchar *id;
 734                 GValue *value;
 735
 736                 id = l->data;
 737                 l = l->next;
 738                 value = purple_status_get_attr_value(status, id);
 739                 if (value == NULL)
 740                 {
 741                         purple_debug_warning("status", "The attribute \"%s\" on the status \"%s\" is "
 742                                                            "not supported.\n", id, priv->status_type->name);
 743                         /* Skip over the data and move on to the next attribute */
 744                         l = l->next;
 745                         continue;
 746                 }
 747
 748                 specified_attr_ids = g_list_prepend(specified_attr_ids, (gpointer)id);
 749
 750                 if (G_VALUE_TYPE(value) == G_TYPE_STRING)
 751                 {
 752                         const gchar *string_data = l->data;
 753                         l = l->next;
 754                         if (purple_strequal(string_data, g_value_get_string(value)))
 755                                 continue;
 756                         status_set_attr_string(status, id, string_data);
 757                         changed = TRUE;
 758                 }
 759                 else if (G_VALUE_TYPE(value) == G_TYPE_INT)
 760                 {
 761                         int int_data = GPOINTER_TO_INT(l->data);
 762                         l = l->next;
 763                         if (int_data == g_value_get_int(value))
 764                                 continue;
 765                         status_set_attr_int(status, id, int_data);
 766                         changed = TRUE;
 767                 }
 768                 else if (G_VALUE_TYPE(value) == G_TYPE_BOOLEAN)
 769                 {
 770                         gboolean boolean_data = GPOINTER_TO_INT(l->data);
 771                         l = l->next;
 772                         if (boolean_data == g_value_get_boolean(value))
 773                                 continue;
 774                         status_set_attr_boolean(status, id, boolean_data);
 775                         changed = TRUE;
 776                 }
 777                 else
 778                 {
 779                         /* We don't know what the data is--skip over it */
 780                         l = l->next;
 781                 }
 782         }
 783
 784         /* Reset any unspecified attributes to their default value */
 785         status_type = purple_status_get_status_type(status);
 786         l = purple_status_type_get_attrs(status_type);
 787         while (l != NULL) {
 788                 PurpleStatusAttribute *attr;
 789
 790                 attr = l->data;
 791                 l = l->next;
 792
 793                 if (!g_list_find_custom(specified_attr_ids, attr->id, (GCompareFunc)strcmp)) {
 794                         GValue *default_value;
 795                         default_value = purple_status_attribute_get_value(attr);
 796                         if (G_VALUE_TYPE(default_value) == G_TYPE_STRING) {
 797                                 const char *cur = purple_status_get_attr_string(status, attr->id);
 798                                 const char *def = g_value_get_string(default_value);
 799                                 if (purple_strequal(cur, def)) {
 800                                         continue;
 801                                 }
 802
 803                                 status_set_attr_string(status, attr->id, def);
 804                         } else if (G_VALUE_TYPE(default_value) == G_TYPE_INT) {
 805                                 int cur = purple_status_get_attr_int(status, attr->id);
 806                                 int def = g_value_get_int(default_value);
 807                                 if (cur == def)
 808                                         continue;
 809
 810                                 status_set_attr_int(status, attr->id, def);
 811                         } else if (G_VALUE_TYPE(default_value) == G_TYPE_BOOLEAN) {
 812                                 gboolean cur = purple_status_get_attr_boolean(status, attr->id);
 813                                 gboolean def = g_value_get_boolean(default_value);
 814                                 if (cur == def)
 815                                         continue;
 816
 817                                 status_set_attr_boolean(status, attr->id, def);
 818                         }
 819                         changed = TRUE;
 820                 }
 821         }
 822         g_list_free(specified_attr_ids);
 823
 824         if (!changed)
 825                 return;
 826         status_has_changed(status);
 827 }
 828
 829 PurpleStatusType *
 830 purple_status_get_status_type(const PurpleStatus *status)
 831 {
 832         PurpleStatusPrivate *priv = PURPLE_STATUS_GET_PRIVATE(status);
 833
 834         g_return_val_if_fail(priv != NULL, NULL);
 835
 836         return priv->status_type;
 837 }
 838
 839 PurplePresence *
 840 purple_status_get_presence(const PurpleStatus *status)
 841 {
 842         PurpleStatusPrivate *priv = PURPLE_STATUS_GET_PRIVATE(status);
 843
 844         g_return_val_if_fail(priv != NULL, NULL);
 845
 846         return priv->presence;
 847 }
 848
 849 const char *
 850 purple_status_get_id(const PurpleStatus *status)
 851 {
 852         g_return_val_if_fail(PURPLE_IS_STATUS(status), NULL);
 853
 854         return purple_status_type_get_id(purple_status_get_status_type(status));
 855 }
 856
 857 const char *
 858 purple_status_get_name(const PurpleStatus *status)
 859 {
 860         g_return_val_if_fail(PURPLE_IS_STATUS(status), NULL);
 861
 862         return purple_status_type_get_name(purple_status_get_status_type(status));
 863 }
 864
 865 gboolean
 866 purple_status_is_independent(const PurpleStatus *status)
 867 {
 868         g_return_val_if_fail(PURPLE_IS_STATUS(status), FALSE);
 869
 870         return purple_status_type_is_independent(purple_status_get_status_type(status));
 871 }
 872
 873 gboolean
 874 purple_status_is_exclusive(const PurpleStatus *status)
 875 {
 876         g_return_val_if_fail(PURPLE_IS_STATUS(status), FALSE);
 877
 878         return purple_status_type_is_exclusive(purple_status_get_status_type(status));
 879 }
 880
 881 gboolean
 882 purple_status_is_available(const PurpleStatus *status)
 883 {
 884         g_return_val_if_fail(PURPLE_IS_STATUS(status), FALSE);
 885
 886         return purple_status_type_is_available(purple_status_get_status_type(status));
 887 }
 888
 889 gboolean
 890 purple_status_is_active(const PurpleStatus *status)
 891 {
 892         PurpleStatusPrivate *priv = PURPLE_STATUS_GET_PRIVATE(status);
 893
 894         g_return_val_if_fail(priv != NULL, FALSE);
 895
 896         return priv->active;
 897 }
 898
 899 gboolean
 900 purple_status_is_online(const PurpleStatus *status)
 901 {
 902         PurpleStatusPrimitive primitive;
 903
 904         g_return_val_if_fail(PURPLE_IS_STATUS(status), FALSE);
 905
 906         primitive = purple_status_type_get_primitive(purple_status_get_status_type(status));
 907
 908         return (primitive != PURPLE_STATUS_UNSET &&
 909                         primitive != PURPLE_STATUS_OFFLINE);
 910 }
 911
 912 GValue *
 913 purple_status_get_attr_value(const PurpleStatus *status, const char *id)
 914 {
 915         PurpleStatusPrivate *priv = PURPLE_STATUS_GET_PRIVATE(status);
 916
 917         g_return_val_if_fail(priv != NULL, NULL);
 918         g_return_val_if_fail(id   != NULL, NULL);
 919
 920         return (GValue *)g_hash_table_lookup(priv->attr_values, id);
 921 }
 922
 923 gboolean
 924 purple_status_get_attr_boolean(const PurpleStatus *status, const char *id)
 925 {
 926         const GValue *value;
 927
 928         g_return_val_if_fail(PURPLE_IS_STATUS(status), FALSE);
 929         g_return_val_if_fail(id != NULL, FALSE);
 930
 931         if ((value = purple_status_get_attr_value(status, id)) == NULL)
 932                 return FALSE;
 933
 934         g_return_val_if_fail(G_VALUE_TYPE(value) == G_TYPE_BOOLEAN, FALSE);
 935
 936         return g_value_get_boolean(value);
 937 }
 938
 939 int
 940 purple_status_get_attr_int(const PurpleStatus *status, const char *id)
 941 {
 942         const GValue *value;
 943
 944         g_return_val_if_fail(PURPLE_IS_STATUS(status), 0);
 945         g_return_val_if_fail(id != NULL, 0);
 946
 947         if ((value = purple_status_get_attr_value(status, id)) == NULL)
 948                 return 0;
 949
 950         g_return_val_if_fail(G_VALUE_TYPE(value) == G_TYPE_INT, 0);
 951
 952         return g_value_get_int(value);
 953 }
 954
 955 const char *
 956 purple_status_get_attr_string(const PurpleStatus *status, const char *id)
 957 {
 958         const GValue *value;
 959
 960         g_return_val_if_fail(PURPLE_IS_STATUS(status), NULL);
 961         g_return_val_if_fail(id != NULL, NULL);
 962
 963         if ((value = purple_status_get_attr_value(status, id)) == NULL)
 964                 return NULL;
 965
 966         g_return_val_if_fail(G_VALUE_TYPE(value) == G_TYPE_STRING, NULL);
 967
 968         return g_value_get_string(value);
 969 }
 970
 971 gint
 972 purple_status_compare(const PurpleStatus *status1, const PurpleStatus *status2)
 973 {
 974         PurpleStatusType *type1, *type2;
 975         int score1 = 0, score2 = 0;
 976
 977         if ((status1 == NULL && status2 == NULL) ||
 978                         (status1 == status2))
 979         {
 980                 return 0;
 981         }
 982         else if (status1 == NULL)
 983                 return 1;
 984         else if (status2 == NULL)
 985                 return -1;
 986
 987         type1 = purple_status_get_status_type(status1);
 988         type2 = purple_status_get_status_type(status2);
 989
 990         if (purple_status_is_active(status1))
 991                 score1 = primitive_scores[purple_status_type_get_primitive(type1)];
 992
 993         if (purple_status_is_active(status2))
 994                 score2 = primitive_scores[purple_status_type_get_primitive(type2)];
 995
 996         if (score1 > score2)
 997                 return -1;
 998         else if (score1 < score2)
 999                 return 1;
1000
1001         return 0;
1002 }
1003
1004
1005 /**************************************************************************
1006 * GBoxed code for PurpleStatusType
1007 **************************************************************************/
1008 static PurpleStatusType *
1009 purple_status_type_ref(PurpleStatusType *status_type)
1010 {
1011         g_return_val_if_fail(status_type != NULL, NULL);
1012
1013         status_type->box_count++;
1014
1015         return status_type;
1016 }
1017
1018 static void
1019 purple_status_type_unref(PurpleStatusType *status_type)
1020 {
1021         g_return_if_fail(status_type != NULL);
1022         g_return_if_fail(status_type->box_count >= 0);
1023
1024         if (!status_type->box_count--)
1025                 purple_status_type_destroy(status_type);
1026 }
1027
1028 GType
1029 purple_status_type_get_type(void)
1030 {
1031         static GType type = 0;
1032
1033         if (type == 0) {
1034                 type = g_boxed_type_register_static("PurpleStatusType",
1035                                 (GBoxedCopyFunc)purple_status_type_ref,
1036                                 (GBoxedFreeFunc)purple_status_type_unref);
1037         }
1038
1039         return type;
1040 }
1041
1042 /**************************************************************************
1043 * GBoxed code for PurpleStatusAttribute
1044 **************************************************************************/
1045 static PurpleStatusAttribute *
1046 purple_status_attribute_copy(PurpleStatusAttribute *status_attr)
1047 {
1048         g_return_val_if_fail(status_attr != NULL, NULL);
1049
1050         return purple_status_attribute_new(status_attr->id,
1051                                       status_attr->name,
1052                                       purple_value_dup(status_attr->value_type));
1053 }
1054
1055 GType
1056 purple_status_attribute_get_type(void)
1057 {
1058         static GType type = 0;
1059
1060         if (type == 0) {
1061                 type = g_boxed_type_register_static("PurpleStatusAttribute",
1062                                 (GBoxedCopyFunc)purple_status_attribute_copy,
1063                                 (GBoxedFreeFunc)purple_status_attribute_destroy);
1064         }
1065
1066         return type;
1067 }
1068
1069 /**************************************************************************
1070 * GBoxed code for PurpleMood
1071 **************************************************************************/
1072 static PurpleMood *
1073 purple_mood_copy(PurpleMood *mood)
1074 {
1075         PurpleMood *mood_copy;
1076
1077         g_return_val_if_fail(mood != NULL, NULL);
1078
1079         mood_copy = g_new(PurpleMood, 1);
1080
1081         mood_copy->mood        = g_strdup(mood->mood);
1082         mood_copy->description = g_strdup(mood->description);
1083
1084         return mood_copy;
1085 }
1086
1087 static void
1088 purple_mood_free(PurpleMood *mood)
1089 {
1090         g_free((gchar *)mood->mood);
1091         g_free((gchar *)mood->description);
1092
1093         g_free(mood);
1094 }
1095
1096 GType
1097 purple_mood_get_type(void)
1098 {
1099         static GType type = 0;
1100
1101         if (type == 0) {
1102                 type = g_boxed_type_register_static("PurpleMood",
1103                                 (GBoxedCopyFunc)purple_mood_copy,
1104                                 (GBoxedFreeFunc)purple_mood_free);
1105         }
1106
1107         return type;
1108 }
1109
1110
1111 /**************************************************************************
1112 * GObject code
1113 **************************************************************************/
1114
1115 /* Set method for GObject properties */
1116 static void
1117 purple_status_set_property(GObject *obj, guint param_id, const GValue *value,
1118                 GParamSpec *pspec)
1119 {
1120         PurpleStatus *status = PURPLE_STATUS(obj);
1121         PurpleStatusPrivate *priv = PURPLE_STATUS_GET_PRIVATE(status);
1122
1123         switch (param_id) {
1124                 case PROP_STATUS_TYPE:
1125                         priv->status_type = g_value_get_pointer(value);
1126                         break;
1127                 case PROP_PRESENCE:
1128                         priv->presence = g_value_get_object(value);
1129                         break;
1130                 case PROP_ACTIVE:
1131                         purple_status_set_active(status, g_value_get_boolean(value));
1132                         break;
1133                 default:
1134                         G_OBJECT_WARN_INVALID_PROPERTY_ID(obj, param_id, pspec);
1135                         break;
1136         }
1137 }
1138
1139 /* Get method for GObject properties */
1140 static void
1141 purple_status_get_property(GObject *obj, guint param_id, GValue *value,
1142                 GParamSpec *pspec)
1143 {
1144         PurpleStatus *status = PURPLE_STATUS(obj);
1145
1146         switch (param_id) {
1147                 case PROP_STATUS_TYPE:
1148                         g_value_set_pointer(value, purple_status_get_status_type(status));
1149                         break;
1150                 case PROP_PRESENCE:
1151                         g_value_set_object(value, purple_status_get_presence(status));
1152                         break;
1153                 case PROP_ACTIVE:
1154                         g_value_set_boolean(value, purple_status_is_active(status));
1155                         break;
1156                 default:
1157                         G_OBJECT_WARN_INVALID_PROPERTY_ID(obj, param_id, pspec);
1158                         break;
1159         }
1160 }
1161
1162 /* GObject initialization function */
1163 static void
1164 purple_status_init(GTypeInstance *instance, gpointer klass)
1165 {
1166         PurpleStatus *status = PURPLE_STATUS(instance);
1167
1168         PURPLE_DBUS_REGISTER_POINTER(status, PurpleStatus);
1169
1170         PURPLE_STATUS_GET_PRIVATE(status)->attr_values =
1171                 g_hash_table_new_full(g_str_hash, g_str_equal, NULL,
1172                 (GDestroyNotify)purple_value_free);
1173 }
1174
1175 /* Called when done constructing */
1176 static void
1177 purple_status_constructed(GObject *object)
1178 {
1179         GList *l;
1180         PurpleStatusPrivate *priv = PURPLE_STATUS_GET_PRIVATE(object);
1181
1182         parent_class->constructed(object);
1183
1184         for (l = purple_status_type_get_attrs(priv->status_type); l != NULL; l = l->next)
1185         {
1186                 PurpleStatusAttribute *attr = (PurpleStatusAttribute *)l->data;
1187                 GValue *value = purple_status_attribute_get_value(attr);
1188                 GValue *new_value = purple_value_dup(value);
1189
1190                 g_hash_table_insert(priv->attr_values,
1191                                                         (char *)purple_status_attribute_get_id(attr),
1192                                                         new_value);
1193         }
1194 }
1195
1196 /*
1197  * GObject finalize function
1198  * TODO: If the PurpleStatus is in a PurplePresence, then
1199  *       remove it from the PurplePresence?
1200  */
1201 static void
1202 purple_status_finalize(GObject *object)
1203 {
1204         g_hash_table_destroy(PURPLE_STATUS_GET_PRIVATE(object)->attr_values);
1205
1206         PURPLE_DBUS_UNREGISTER_POINTER(object);
1207
1208         parent_class->finalize(object);
1209 }
1210
1211 /* Class initializer function */
1212 static void
1213 purple_status_class_init(PurpleStatusClass *klass)
1214 {
1215         GObjectClass *obj_class = G_OBJECT_CLASS(klass);
1216
1217         parent_class = g_type_class_peek_parent(klass);
1218
1219         obj_class->finalize = purple_status_finalize;
1220         obj_class->constructed = purple_status_constructed;
1221
1222         /* Setup properties */
1223         obj_class->get_property = purple_status_get_property;
1224         obj_class->set_property = purple_status_set_property;
1225
1226         g_type_class_add_private(klass, sizeof(PurpleStatusPrivate));
1227
1228         properties[PROP_STATUS_TYPE] = g_param_spec_pointer("status-type",
1229                                 "Status type",
1230                                 "The PurpleStatusType of the status.",
1231                                 G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
1232                                 G_PARAM_STATIC_STRINGS);
1233
1234         properties[PROP_PRESENCE] = g_param_spec_object("presence", "Presence",
1235                                 "The presence that the status belongs to.",
1236                                 PURPLE_TYPE_PRESENCE,
1237                                 G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
1238                                 G_PARAM_STATIC_STRINGS);
1239
1240         properties[PROP_ACTIVE] = g_param_spec_boolean("active", "Active",
1241                                 "Whether the status is active or not.", FALSE,
1242                                 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
1243
1244         g_object_class_install_properties(obj_class, PROP_LAST, properties);
1245 }
1246
1247 GType
1248 purple_status_get_type(void)
1249 {
1250         static GType type = 0;
1251
1252         if(type == 0) {
1253                 static const GTypeInfo info = {
1254                         sizeof(PurpleStatusClass),
1255                         NULL,
1256                         NULL,
1257                         (GClassInitFunc)purple_status_class_init,
1258                         NULL,
1259                         NULL,
1260                         sizeof(PurpleStatus),
1261                         0,
1262                         (GInstanceInitFunc)purple_status_init,
1263                         NULL,
1264                 };
1265
1266                 type = g_type_register_static(G_TYPE_OBJECT,
1267                                 "PurpleStatus",
1268                                 &info, 0);
1269         }
1270
1271         return type;
1272 }
1273
1274 PurpleStatus *
1275 purple_status_new(PurpleStatusType *status_type, PurplePresence *presence)
1276 {
1277         g_return_val_if_fail(status_type != NULL, NULL);
1278         g_return_val_if_fail(PURPLE_IS_PRESENCE(presence), NULL);
1279
1280         return g_object_new(PURPLE_TYPE_STATUS,
1281                         "status-type",  status_type,
1282                         "presence",     presence,
1283                         NULL);
1284 }
1285
1286
1287 /**************************************************************************
1288 * Status subsystem
1289 **************************************************************************/
1290 static void
1291 score_pref_changed_cb(const char *name, PurplePrefType type,
1292                                           gconstpointer value, gpointer data)
1293 {
1294         int index = GPOINTER_TO_INT(data);
1295
1296         primitive_scores[index] = GPOINTER_TO_INT(value);
1297 }
1298
1299 void *
1300 purple_statuses_get_handle(void) {
1301         static int handle;
1302
1303         return &handle;
1304 }
1305
1306 void
1307 purple_statuses_init(void)
1308 {
1309         void *handle = purple_statuses_get_handle();
1310
1311         purple_prefs_add_none("/purple/status");
1312         purple_prefs_add_none("/purple/status/scores");
1313
1314         purple_prefs_add_int("/purple/status/scores/offline",
1315                         primitive_scores[PURPLE_STATUS_OFFLINE]);
1316         purple_prefs_add_int("/purple/status/scores/available",
1317                         primitive_scores[PURPLE_STATUS_AVAILABLE]);
1318         purple_prefs_add_int("/purple/status/scores/invisible",
1319                         primitive_scores[PURPLE_STATUS_INVISIBLE]);
1320         purple_prefs_add_int("/purple/status/scores/away",
1321                         primitive_scores[PURPLE_STATUS_AWAY]);
1322         purple_prefs_add_int("/purple/status/scores/extended_away",
1323                         primitive_scores[PURPLE_STATUS_EXTENDED_AWAY]);
1324         purple_prefs_add_int("/purple/status/scores/idle",
1325                         primitive_scores[SCORE_IDLE]);
1326         purple_prefs_add_int("/purple/status/scores/idle_time",
1327                         primitive_scores[SCORE_IDLE_TIME]);
1328         purple_prefs_add_int("/purple/status/scores/offline_msg",
1329                         primitive_scores[SCORE_OFFLINE_MESSAGE]);
1330
1331         purple_prefs_connect_callback(handle, "/purple/status/scores/offline",
1332                         score_pref_changed_cb,
1333                         GINT_TO_POINTER(PURPLE_STATUS_OFFLINE));
1334         purple_prefs_connect_callback(handle, "/purple/status/scores/available",
1335                         score_pref_changed_cb,
1336                         GINT_TO_POINTER(PURPLE_STATUS_AVAILABLE));
1337         purple_prefs_connect_callback(handle, "/purple/status/scores/invisible",
1338                         score_pref_changed_cb,
1339                         GINT_TO_POINTER(PURPLE_STATUS_INVISIBLE));
1340         purple_prefs_connect_callback(handle, "/purple/status/scores/away",
1341                         score_pref_changed_cb,
1342                         GINT_TO_POINTER(PURPLE_STATUS_AWAY));
1343         purple_prefs_connect_callback(handle, "/purple/status/scores/extended_away",
1344                         score_pref_changed_cb,
1345                         GINT_TO_POINTER(PURPLE_STATUS_EXTENDED_AWAY));
1346         purple_prefs_connect_callback(handle, "/purple/status/scores/idle",
1347                         score_pref_changed_cb,
1348                         GINT_TO_POINTER(SCORE_IDLE));
1349         purple_prefs_connect_callback(handle, "/purple/status/scores/idle_time",
1350                         score_pref_changed_cb,
1351                         GINT_TO_POINTER(SCORE_IDLE_TIME));
1352         purple_prefs_connect_callback(handle, "/purple/status/scores/offline_msg",
1353                         score_pref_changed_cb,
1354                         GINT_TO_POINTER(SCORE_OFFLINE_MESSAGE));
1355
1356         purple_prefs_trigger_callback("/purple/status/scores/offline");
1357         purple_prefs_trigger_callback("/purple/status/scores/available");
1358         purple_prefs_trigger_callback("/purple/status/scores/invisible");
1359         purple_prefs_trigger_callback("/purple/status/scores/away");
1360         purple_prefs_trigger_callback("/purple/status/scores/extended_away");
1361         purple_prefs_trigger_callback("/purple/status/scores/idle");
1362         purple_prefs_trigger_callback("/purple/status/scores/idle_time");
1363         purple_prefs_trigger_callback("/purple/status/scores/offline_msg");
1364 }
1365
1366 void
1367 purple_statuses_uninit(void)
1368 {
1369         purple_prefs_disconnect_by_handle(purple_prefs_get_handle());
1370 }