libpurple/savedstatuses.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
  23 #include "debug.h"
  24 #include "idle.h"
  25 #include "notify.h"
  26 #include "savedstatuses.h"
  27 #include "request.h"
  28 #include "status.h"
  29 #include "util.h"
  30 #include "xmlnode.h"
  31
  32 /*
  33  * The maximum number of transient statuses to save.  This
  34  * is used during the shutdown process to clean out old
  35  * transient statuses.
  36  */
  37 #define MAX_TRANSIENTS 5
  38
  39 /*
  40  * The default message to use when the user becomes auto-away.
  41  */
  42 #define DEFAULT_AUTOAWAY_MESSAGE _("I'm not here right now")
  43
  44 /*
  45  * The information stores a snap-shot of the statuses of all
  46  * your accounts.  Basically these are your saved away messages.
  47  * There is an overall status and message that applies to
  48  * all your accounts, and then each individual account can
  49  * optionally have a different custom status and message.
  50  *
  51  * The changes to status.xml caused by the new status API
  52  * are fully backward compatible.  The new status API just
  53  * adds the optional sub-statuses to the XML file.
  54  */
  55 struct _PurpleSavedStatus
  56 {
  57         char *title;
  58         PurpleStatusPrimitive type;
  59         char *message;
  60
  61         /* The timestamp when this saved status was created. This must be unique. */
  62         time_t creation_time;
  63
  64         time_t lastused;
  65
  66         unsigned int usage_count;
  67
  68         GList *substatuses;      /* A list of PurpleSavedStatusSub's. */
  69 };
  70
  71 /*
  72  * TODO: If a PurpleStatusType is deleted, need to also delete any
  73  *       associated PurpleSavedStatusSub's?
  74  */
  75 struct _PurpleSavedStatusSub
  76 {
  77         PurpleAccount *account;
  78         const PurpleStatusType *type;
  79         char *message;
  80 };
  81
  82 static GList      *saved_statuses = NULL;
  83 static guint       save_timer = 0;
  84 static gboolean    statuses_loaded = FALSE;
  85
  86 /*
  87  * This hash table keeps track of which timestamps we've
  88  * used so that we don't have two saved statuses with the
  89  * same 'creation_time' timestamp.  The 'created' timestamp
  90  * is used as a unique identifier.
  91  *
  92  * So the key in this hash table is the creation_time and
  93  * the value is a pointer to the PurpleSavedStatus.
  94  */
  95 static GHashTable *creation_times;
  96
  97 static void schedule_save(void);
  98
  99 /*********************************************************************
 100  * Private utility functions                                         *
 101  *********************************************************************/
 102
 103 static void
 104 free_saved_status_sub(PurpleSavedStatusSub *substatus)
 105 {
 106         g_return_if_fail(substatus != NULL);
 107
 108         g_free(substatus->message);
 109         purple_request_close_with_handle(substatus);
 110         g_free(substatus);
 111 }
 112
 113 static void
 114 free_saved_status(PurpleSavedStatus *status)
 115 {
 116         g_return_if_fail(status != NULL);
 117
 118         g_free(status->title);
 119         g_free(status->message);
 120
 121         while (status->substatuses != NULL)
 122         {
 123                 PurpleSavedStatusSub *substatus = status->substatuses->data;
 124                 status->substatuses = g_list_remove(status->substatuses, substatus);
 125                 free_saved_status_sub(substatus);
 126         }
 127         purple_request_close_with_handle(status);
 128         g_free(status);
 129 }
 130
 131 /*
 132  * Set the timestamp for when this saved status was created, and
 133  * make sure it is unique.
 134  */
 135 static void
 136 set_creation_time(PurpleSavedStatus *status, time_t creation_time)
 137 {
 138         g_return_if_fail(status != NULL);
 139
 140         /* Avoid using 0 because it's an invalid hash key */
 141         status->creation_time = creation_time != 0 ? creation_time : 1;
 142
 143         while (g_hash_table_lookup(creation_times, (gconstpointer)status->creation_time) != NULL)
 144                 status->creation_time++;
 145
 146         g_hash_table_insert(creation_times,
 147                                                 (gpointer)status->creation_time,
 148                                                 status);
 149 }
 150
 151 /*
 152  * A magic number is calculated for each status, and then the
 153  * statuses are ordered by the magic number.  The magic number
 154  * is the date the status was last used offset by one day for
 155  * each time the status has been used (but only by 10 days at
 156  * the most).
 157  *
 158  * The goal is to have recently used statuses at the top of
 159  * the list, but to also keep frequently used statuses near
 160  * the top.
 161  */
 162 static gint
 163 saved_statuses_sort_func(gconstpointer a, gconstpointer b)
 164 {
 165         const PurpleSavedStatus *saved_status_a = a;
 166         const PurpleSavedStatus *saved_status_b = b;
 167         time_t time_a = saved_status_a->lastused +
 168                                                 (MIN(saved_status_a->usage_count, 10) * 86400);
 169         time_t time_b = saved_status_b->lastused +
 170                                                 (MIN(saved_status_b->usage_count, 10) * 86400);
 171         if (time_a > time_b)
 172                 return -1;
 173         if (time_a < time_b)
 174                 return 1;
 175         return 0;
 176 }
 177
 178 /*
 179  * Transient statuses are added and removed automatically by
 180  * Purple.  If they're not used for a certain length of time then
 181  * they'll expire and be automatically removed.  This function
 182  * does the expiration.
 183  */
 184 static void
 185 remove_old_transient_statuses(void)
 186 {
 187         GList *l, *next;
 188         PurpleSavedStatus *saved_status, *startup_status, *current_status;
 189         int count;
 190         time_t creation_time;
 191
 192         startup_status = purple_savedstatus_get_startup();
 193         current_status = purple_savedstatus_get_current();
 194
 195         /*
 196          * Iterate through the list of saved statuses.  Delete all
 197          * transient statuses except for the first MAX_TRANSIENTS
 198          * (remember, the saved statuses are already sorted by popularity).
 199          * We should also keep the startup status, if any is set.
 200          */
 201         count = 0;
 202         for (l = saved_statuses; l != NULL; l = next)
 203         {
 204                 next = l->next;
 205                 saved_status = l->data;
 206                 if (purple_savedstatus_is_transient(saved_status))
 207                 {
 208                         if (count == MAX_TRANSIENTS)
 209                         {
 210                                 if (saved_status != current_status && saved_status != startup_status)
 211                                 {
 212                                         saved_statuses = g_list_remove(saved_statuses, saved_status);
 213                                         creation_time = purple_savedstatus_get_creation_time(saved_status);
 214                                         g_hash_table_remove(creation_times, (gconstpointer)creation_time);
 215                                         free_saved_status(saved_status);
 216                                 }
 217                         }
 218                         else
 219                                 count++;
 220                 }
 221         }
 222
 223         if (count == MAX_TRANSIENTS)
 224                 schedule_save();
 225 }
 226
 227 /*********************************************************************
 228  * Writing to disk                                                   *
 229  *********************************************************************/
 230
 231 static PurpleXmlNode *
 232 substatus_to_xmlnode(PurpleSavedStatusSub *substatus)
 233 {
 234         PurpleXmlNode *node, *child;
 235
 236         node = purple_xmlnode_new("substatus");
 237
 238         child = purple_xmlnode_new_child(node, "account");
 239         purple_xmlnode_set_attrib(child, "protocol", purple_account_get_protocol_id(substatus->account));
 240         purple_xmlnode_insert_data(child,
 241                         purple_normalize(substatus->account,
 242                                 purple_account_get_username(substatus->account)), -1);
 243
 244         child = purple_xmlnode_new_child(node, "state");
 245         purple_xmlnode_insert_data(child, purple_status_type_get_id(substatus->type), -1);
 246
 247         if (substatus->message != NULL)
 248         {
 249                 child = purple_xmlnode_new_child(node, "message");
 250                 purple_xmlnode_insert_data(child, substatus->message, -1);
 251         }
 252
 253         return node;
 254 }
 255
 256 static PurpleXmlNode *
 257 status_to_xmlnode(PurpleSavedStatus *status)
 258 {
 259         PurpleXmlNode *node, *child;
 260         char buf[21];
 261         GList *cur;
 262
 263         node = purple_xmlnode_new("status");
 264         if (status->title != NULL)
 265         {
 266                 purple_xmlnode_set_attrib(node, "name", status->title);
 267         }
 268         else
 269         {
 270                 /*
 271                  * Purple 1.5.0 and earlier require a name to be set, so we
 272                  * do this little hack to maintain backward compatability
 273                  * in the status.xml file.  Eventually this should be removed
 274                  * and we should determine if a status is transient by
 275                  * whether the "name" attribute is set to something or if
 276                  * it does not exist at all.
 277                  */
 278                 purple_xmlnode_set_attrib(node, "name", "Auto-Cached");
 279                 purple_xmlnode_set_attrib(node, "transient", "true");
 280         }
 281
 282         g_snprintf(buf, sizeof(buf), "%lu", status->creation_time);
 283         purple_xmlnode_set_attrib(node, "created", buf);
 284
 285         g_snprintf(buf, sizeof(buf), "%lu", status->lastused);
 286         purple_xmlnode_set_attrib(node, "lastused", buf);
 287
 288         g_snprintf(buf, sizeof(buf), "%u", status->usage_count);
 289         purple_xmlnode_set_attrib(node, "usage_count", buf);
 290
 291         child = purple_xmlnode_new_child(node, "state");
 292         purple_xmlnode_insert_data(child, purple_primitive_get_id_from_type(status->type), -1);
 293
 294         if (status->message != NULL)
 295         {
 296                 child = purple_xmlnode_new_child(node, "message");
 297                 purple_xmlnode_insert_data(child, status->message, -1);
 298         }
 299
 300         for (cur = status->substatuses; cur != NULL; cur = cur->next)
 301         {
 302                 child = substatus_to_xmlnode(cur->data);
 303                 purple_xmlnode_insert_child(node, child);
 304         }
 305
 306         return node;
 307 }
 308
 309 static PurpleXmlNode *
 310 statuses_to_xmlnode(void)
 311 {
 312         PurpleXmlNode *node, *child;
 313         GList *cur;
 314
 315         node = purple_xmlnode_new("statuses");
 316         purple_xmlnode_set_attrib(node, "version", "1.0");
 317
 318         for (cur = saved_statuses; cur != NULL; cur = cur->next)
 319         {
 320                 child = status_to_xmlnode(cur->data);
 321                 purple_xmlnode_insert_child(node, child);
 322         }
 323
 324         return node;
 325 }
 326
 327 static void
 328 sync_statuses(void)
 329 {
 330         PurpleXmlNode *node;
 331         char *data;
 332
 333         if (!statuses_loaded)
 334         {
 335                 purple_debug_error("status", "Attempted to save statuses before they "
 336                                                  "were read!\n");
 337                 return;
 338         }
 339
 340         node = statuses_to_xmlnode();
 341         data = purple_xmlnode_to_formatted_str(node, NULL);
 342         purple_util_write_data_to_config_file("status.xml", data, -1);
 343         g_free(data);
 344         purple_xmlnode_free(node);
 345 }
 346
 347 static gboolean
 348 save_cb(gpointer data)
 349 {
 350         sync_statuses();
 351         save_timer = 0;
 352         return FALSE;
 353 }
 354
 355 static void
 356 schedule_save(void)
 357 {
 358         if (save_timer == 0)
 359                 save_timer = g_timeout_add_seconds(5, save_cb, NULL);
 360 }
 361
 362
 363 /*********************************************************************
 364  * Reading from disk                                                 *
 365  *********************************************************************/
 366
 367 static PurpleSavedStatusSub *
 368 parse_substatus(PurpleXmlNode *substatus)
 369 {
 370         PurpleSavedStatusSub *ret;
 371         PurpleXmlNode *node;
 372         char *data;
 373
 374         ret = g_new0(PurpleSavedStatusSub, 1);
 375
 376         /* Read the account */
 377         node = purple_xmlnode_get_child(substatus, "account");
 378         if (node != NULL)
 379         {
 380                 char *acct_name;
 381                 const char *protocol;
 382                 acct_name = purple_xmlnode_get_data(node);
 383                 protocol = purple_xmlnode_get_attrib(node, "protocol");
 384                 if ((acct_name != NULL) && (protocol != NULL))
 385                         ret->account = purple_accounts_find(acct_name, protocol);
 386                 g_free(acct_name);
 387         }
 388
 389         if (ret->account == NULL)
 390         {
 391                 g_free(ret);
 392                 return NULL;
 393         }
 394
 395         /* Read the state */
 396         node = purple_xmlnode_get_child(substatus, "state");
 397         if ((node != NULL) && ((data = purple_xmlnode_get_data(node)) != NULL))
 398         {
 399                 ret->type = purple_status_type_find_with_id(
 400                                                         purple_account_get_status_types(ret->account), data);
 401                 g_free(data);
 402         }
 403
 404         if (ret->type == NULL)
 405         {
 406                 g_free(ret);
 407                 return NULL;
 408         }
 409
 410         /* Read the message */
 411         node = purple_xmlnode_get_child(substatus, "message");
 412         if ((node != NULL) && ((data = purple_xmlnode_get_data(node)) != NULL))
 413         {
 414                 ret->message = data;
 415         }
 416
 417         return ret;
 418 }
 419
 420 /*
 421  * Parse a saved status and add it to the saved_statuses linked list.
 422  *
 423  * Here's an example of the XML for a saved status:
 424  *   <status name="Girls">
 425  *       <state>away</state>
 426  *       <message>I like the way that they walk
 427  *   And it's chill to hear them talk
 428  *   And I can always make them smile
 429  *   From White Castle to the Nile</message>
 430  *       <substatus>
 431  *           <account protocol='aim'>markdoliner</account>
 432  *           <state>available</state>
 433  *           <message>The ladies man is here to answer your queries.</message>
 434  *       </substatus>
 435  *       <substatus>
 436  *           <account protocol='aim'>giantgraypanda</account>
 437  *           <state>away</state>
 438  *           <message>A.C. ain't in charge no more.</message>
 439  *       </substatus>
 440  *   </status>
 441  *
 442  * I know.  Moving, huh?
 443  */
 444 static PurpleSavedStatus *
 445 parse_status(PurpleXmlNode *status)
 446 {
 447         PurpleSavedStatus *ret;
 448         PurpleXmlNode *node;
 449         const char *attrib;
 450         char *data;
 451         int i;
 452
 453         ret = g_new0(PurpleSavedStatus, 1);
 454
 455         attrib = purple_xmlnode_get_attrib(status, "transient");
 456         if (!purple_strequal(attrib, "true"))
 457         {
 458                 /* Read the title */
 459                 attrib = purple_xmlnode_get_attrib(status, "name");
 460                 ret->title = g_strdup(attrib);
 461         }
 462
 463         if (ret->title != NULL)
 464         {
 465                 /* Ensure the title is unique */
 466                 i = 2;
 467                 while (purple_savedstatus_find(ret->title) != NULL)
 468                 {
 469                         g_free(ret->title);
 470                         ret->title = g_strdup_printf("%s %d", attrib, i);
 471                         i++;
 472                 }
 473         }
 474
 475         /* Read the creation time */
 476         attrib = purple_xmlnode_get_attrib(status, "created");
 477         set_creation_time(ret, (attrib != NULL ? atol(attrib) : 0));
 478
 479         /* Read the last used time */
 480         attrib = purple_xmlnode_get_attrib(status, "lastused");
 481         ret->lastused = (attrib != NULL ? atol(attrib) : 0);
 482
 483         /* Read the usage count */
 484         attrib = purple_xmlnode_get_attrib(status, "usage_count");
 485         ret->usage_count = (attrib != NULL ? atol(attrib) : 0);
 486
 487         /* Read the primitive status type */
 488         node = purple_xmlnode_get_child(status, "state");
 489         if ((node != NULL) && ((data = purple_xmlnode_get_data(node)) != NULL))
 490         {
 491                 ret->type = purple_primitive_get_type_from_id(data);
 492                 g_free(data);
 493         }
 494
 495         /* Read the message */
 496         node = purple_xmlnode_get_child(status, "message");
 497         if ((node != NULL) && ((data = purple_xmlnode_get_data(node)) != NULL))
 498         {
 499                 ret->message = data;
 500         }
 501
 502         /* Read substatuses */
 503         for (node = purple_xmlnode_get_child(status, "substatus"); node != NULL;
 504                         node = purple_xmlnode_get_next_twin(node))
 505         {
 506                 PurpleSavedStatusSub *new;
 507                 new = parse_substatus(node);
 508                 if (new != NULL)
 509                         ret->substatuses = g_list_prepend(ret->substatuses, new);
 510         }
 511
 512         return ret;
 513 }
 514
 515 /*
 516  * load_statuses:
 517  *
 518  * Read the saved statuses from a file in the Purple user dir.
 519  *
 520  * Returns: TRUE on success, FALSE on failure (if the file can not
 521  *          be opened, or if it contains invalid XML).
 522  */
 523 static void
 524 load_statuses(void)
 525 {
 526         PurpleXmlNode *statuses, *status;
 527
 528         statuses_loaded = TRUE;
 529
 530         statuses = purple_util_read_xml_from_config_file("status.xml", _("saved statuses"));
 531
 532         if (statuses == NULL)
 533                 return;
 534
 535         for (status = purple_xmlnode_get_child(statuses, "status"); status != NULL;
 536                         status = purple_xmlnode_get_next_twin(status))
 537         {
 538                 PurpleSavedStatus *new;
 539                 new = parse_status(status);
 540                 saved_statuses = g_list_prepend(saved_statuses, new);
 541         }
 542         saved_statuses = g_list_sort(saved_statuses, saved_statuses_sort_func);
 543
 544         purple_xmlnode_free(statuses);
 545 }
 546
 547
 548 /**************************************************************************
 549 * Saved status API
 550 **************************************************************************/
 551 PurpleSavedStatus *
 552 purple_savedstatus_new(const char *title, PurpleStatusPrimitive type)
 553 {
 554         PurpleSavedStatus *status;
 555
 556         /* Make sure we don't already have a saved status with this title. */
 557         if (title != NULL)
 558                 g_return_val_if_fail(purple_savedstatus_find(title) == NULL, NULL);
 559
 560         status = g_new0(PurpleSavedStatus, 1);
 561         status->title = g_strdup(title);
 562         status->type = type;
 563         set_creation_time(status, time(NULL));
 564
 565         saved_statuses = g_list_insert_sorted(saved_statuses, status, saved_statuses_sort_func);
 566
 567         schedule_save();
 568
 569         purple_signal_emit(purple_savedstatuses_get_handle(), "savedstatus-added",
 570                 status);
 571
 572         return status;
 573 }
 574
 575 void
 576 purple_savedstatus_set_title(PurpleSavedStatus *status, const char *title)
 577 {
 578         g_return_if_fail(status != NULL);
 579
 580         /* Make sure we don't already have a saved status with this title. */
 581         g_return_if_fail(purple_savedstatus_find(title) == NULL);
 582
 583         g_free(status->title);
 584         status->title = g_strdup(title);
 585
 586         schedule_save();
 587
 588         purple_signal_emit(purple_savedstatuses_get_handle(),
 589                         "savedstatus-modified", status);
 590 }
 591
 592 void
 593 purple_savedstatus_set_primitive_type(PurpleSavedStatus *status, PurpleStatusPrimitive type)
 594 {
 595         g_return_if_fail(status != NULL);
 596
 597         status->type = type;
 598
 599         schedule_save();
 600         purple_signal_emit(purple_savedstatuses_get_handle(),
 601                         "savedstatus-modified", status);
 602 }
 603
 604 void
 605 purple_savedstatus_set_message(PurpleSavedStatus *status, const char *message)
 606 {
 607         g_return_if_fail(status != NULL);
 608
 609         g_free(status->message);
 610         if ((message != NULL) && (*message == '\0'))
 611                 status->message = NULL;
 612         else
 613                 status->message = g_strdup(message);
 614
 615         schedule_save();
 616
 617         purple_signal_emit(purple_savedstatuses_get_handle(),
 618                         "savedstatus-modified", status);
 619 }
 620
 621 void
 622 purple_savedstatus_set_substatus(PurpleSavedStatus *saved_status,
 623                                                            const PurpleAccount *account,
 624                                                            const PurpleStatusType *type,
 625                                                            const char *message)
 626 {
 627         PurpleSavedStatusSub *substatus;
 628
 629         g_return_if_fail(saved_status != NULL);
 630         g_return_if_fail(account      != NULL);
 631         g_return_if_fail(type         != NULL);
 632
 633         /* Find an existing substatus or create a new one */
 634         substatus = purple_savedstatus_get_substatus(saved_status, account);
 635         if (substatus == NULL)
 636         {
 637                 substatus = g_new0(PurpleSavedStatusSub, 1);
 638                 substatus->account = (PurpleAccount *)account;
 639                 saved_status->substatuses = g_list_prepend(saved_status->substatuses, substatus);
 640         }
 641
 642         substatus->type = type;
 643         g_free(substatus->message);
 644         substatus->message = g_strdup(message);
 645
 646         schedule_save();
 647         purple_signal_emit(purple_savedstatuses_get_handle(),
 648                         "savedstatus-modified", saved_status);
 649 }
 650
 651 void
 652 purple_savedstatus_unset_substatus(PurpleSavedStatus *saved_status,
 653                                                                  const PurpleAccount *account)
 654 {
 655         GList *iter;
 656         PurpleSavedStatusSub *substatus;
 657
 658         g_return_if_fail(saved_status != NULL);
 659         g_return_if_fail(account      != NULL);
 660
 661         for (iter = saved_status->substatuses; iter != NULL; iter = iter->next)
 662         {
 663                 substatus = iter->data;
 664                 if (substatus->account == account)
 665                 {
 666                         saved_status->substatuses = g_list_delete_link(saved_status->substatuses, iter);
 667                         g_free(substatus->message);
 668                         g_free(substatus);
 669                         return;
 670                 }
 671         }
 672
 673         purple_signal_emit(purple_savedstatuses_get_handle(),
 674                         "savedstatus-modified", saved_status);
 675 }
 676
 677 /*
 678  * This gets called when an account is deleted.  We iterate through
 679  * all of our saved statuses and delete any substatuses that may
 680  * exist for this account.
 681  */
 682 static void
 683 purple_savedstatus_unset_all_substatuses(const PurpleAccount *account,
 684                 gpointer user_data)
 685 {
 686         g_return_if_fail(account != NULL);
 687
 688         g_list_foreach(saved_statuses, (GFunc)purple_savedstatus_unset_substatus, account);
 689 }
 690
 691 void
 692 purple_savedstatus_delete_by_status(PurpleSavedStatus *status)
 693 {
 694         time_t creation_time, current, idleaway;
 695
 696         g_return_if_fail(status != NULL);
 697
 698         saved_statuses = g_list_remove(saved_statuses, status);
 699         creation_time = purple_savedstatus_get_creation_time(status);
 700         g_hash_table_remove(creation_times, (gconstpointer)creation_time);
 701         free_saved_status(status);
 702
 703         schedule_save();
 704
 705         /*
 706          * If we just deleted our current status or our idleaway status,
 707          * then set the appropriate pref back to 0.
 708          */
 709         current = purple_prefs_get_int("/purple/savedstatus/default");
 710         if (current == creation_time)
 711                 purple_prefs_set_int("/purple/savedstatus/default", 0);
 712
 713         idleaway = purple_prefs_get_int("/purple/savedstatus/idleaway");
 714         if (idleaway == creation_time)
 715                 purple_prefs_set_int("/purple/savedstatus/idleaway", 0);
 716
 717         purple_signal_emit(purple_savedstatuses_get_handle(),
 718                         "savedstatus-deleted", status);
 719 }
 720
 721 gboolean
 722 purple_savedstatus_delete(const char *title)
 723 {
 724         PurpleSavedStatus *status;
 725
 726         status = purple_savedstatus_find(title);
 727
 728         if (status == NULL)
 729                 return FALSE;
 730
 731         if (purple_savedstatus_get_current() == status)
 732                 return FALSE;
 733
 734         purple_savedstatus_delete_by_status(status);
 735
 736         return TRUE;
 737 }
 738
 739 GList *
 740 purple_savedstatuses_get_all(void)
 741 {
 742         return saved_statuses;
 743 }
 744
 745 GList *
 746 purple_savedstatuses_get_popular(unsigned int how_many)
 747 {
 748         GList *popular = NULL;
 749         GList *cur;
 750         unsigned int i;
 751         PurpleSavedStatus *next;
 752
 753         /* Copy 'how_many' elements to a new list. If 'how_many' is 0, then copy all of 'em. */
 754         if (how_many == 0)
 755                 how_many = (unsigned int) -1;
 756
 757         i = 0;
 758         cur = saved_statuses;
 759         while ((i < how_many) && (cur != NULL))
 760         {
 761                 next = cur->data;
 762                 if ((!purple_savedstatus_is_transient(next)
 763                         || purple_savedstatus_get_message(next) != NULL))
 764                 {
 765                         popular = g_list_prepend(popular, next);
 766                         i++;
 767                 }
 768                 cur = cur->next;
 769         }
 770
 771         popular = g_list_reverse(popular);
 772
 773         return popular;
 774 }
 775
 776 PurpleSavedStatus *
 777 purple_savedstatus_get_current(void)
 778 {
 779         if (purple_savedstatus_is_idleaway())
 780                 return purple_savedstatus_get_idleaway();
 781         else
 782                 return purple_savedstatus_get_default();
 783 }
 784
 785 PurpleSavedStatus *
 786 purple_savedstatus_get_default()
 787 {
 788         time_t creation_time;
 789         PurpleSavedStatus *saved_status = NULL;
 790
 791         creation_time = purple_prefs_get_int("/purple/savedstatus/default");
 792
 793         if (creation_time != 0)
 794                 saved_status = g_hash_table_lookup(creation_times, (gconstpointer)creation_time);
 795
 796         if (saved_status == NULL)
 797         {
 798                 /*
 799                  * We don't have a current saved status!  This is either a new
 800                  * Purple user or someone upgrading from Purple 1.5.0 or older, or
 801                  * possibly someone who deleted the status they were currently
 802                  * using?  In any case, add a default status.
 803                  */
 804                 saved_status = purple_savedstatus_new(NULL, PURPLE_STATUS_AVAILABLE);
 805                 purple_prefs_set_int("/purple/savedstatus/default",
 806                                                    purple_savedstatus_get_creation_time(saved_status));
 807         }
 808
 809         return saved_status;
 810 }
 811
 812 PurpleSavedStatus *
 813 purple_savedstatus_get_idleaway()
 814 {
 815         time_t creation_time;
 816         PurpleSavedStatus *saved_status = NULL;
 817
 818         creation_time = purple_prefs_get_int("/purple/savedstatus/idleaway");
 819
 820         if (creation_time != 0)
 821                 saved_status = g_hash_table_lookup(creation_times, (gconstpointer)creation_time);
 822
 823         if (saved_status == NULL)
 824         {
 825                 /* We don't have a specified "idle" status!  Weird. */
 826                 saved_status = purple_savedstatus_find_transient_by_type_and_message(
 827                                 PURPLE_STATUS_AWAY, DEFAULT_AUTOAWAY_MESSAGE);
 828
 829                 if (saved_status == NULL)
 830                 {
 831                         saved_status = purple_savedstatus_new(NULL, PURPLE_STATUS_AWAY);
 832                         purple_savedstatus_set_message(saved_status, DEFAULT_AUTOAWAY_MESSAGE);
 833                         purple_prefs_set_int("/purple/savedstatus/idleaway",
 834                                                            purple_savedstatus_get_creation_time(saved_status));
 835                 }
 836         }
 837
 838         return saved_status;
 839 }
 840
 841 gboolean
 842 purple_savedstatus_is_idleaway()
 843 {
 844         return purple_prefs_get_bool("/purple/savedstatus/isidleaway");
 845 }
 846
 847 void
 848 purple_savedstatus_set_idleaway(gboolean idleaway)
 849 {
 850         GList *accounts, *node;
 851         PurpleSavedStatus *old, *saved_status;
 852
 853         if (purple_savedstatus_is_idleaway() == idleaway)
 854                 /* Don't need to do anything */
 855                 return;
 856
 857         old = purple_savedstatus_get_current();
 858         saved_status = idleaway ? purple_savedstatus_get_idleaway()
 859                         : purple_savedstatus_get_default();
 860         purple_prefs_set_bool("/purple/savedstatus/isidleaway", idleaway);
 861
 862         /* Changing our status makes us un-idle */
 863         if (!idleaway)
 864                 purple_idle_touch();
 865
 866         if (idleaway && (purple_savedstatus_get_primitive_type(old) != PURPLE_STATUS_AVAILABLE))
 867                 /* Our global status is already "away," so don't change anything */
 868                 return;
 869
 870         accounts = purple_accounts_get_all_active();
 871         for (node = accounts; node != NULL; node = node->next)
 872         {
 873                 PurpleAccount *account;
 874                 PurplePresence *presence;
 875                 PurpleStatus *status;
 876
 877                 account = node->data;
 878                 presence = purple_account_get_presence(account);
 879                 status = purple_presence_get_active_status(presence);
 880
 881                 if (!idleaway || purple_status_is_available(status))
 882                         purple_savedstatus_activate_for_account(saved_status, account);
 883         }
 884
 885         g_list_free(accounts);
 886
 887         purple_signal_emit(purple_savedstatuses_get_handle(), "savedstatus-changed",
 888                                          saved_status, old);
 889 }
 890
 891 PurpleSavedStatus *
 892 purple_savedstatus_get_startup()
 893 {
 894         time_t creation_time;
 895         PurpleSavedStatus *saved_status = NULL;
 896
 897         creation_time = purple_prefs_get_int("/purple/savedstatus/startup");
 898
 899         if (creation_time != 0)
 900                 saved_status = g_hash_table_lookup(creation_times, (gconstpointer)creation_time);
 901
 902         if (saved_status == NULL)
 903         {
 904                 /*
 905                  * We don't have a status to apply.
 906                  * This may be the first login, or the user wants to
 907                  * restore the "current" status.
 908                  */
 909                 saved_status = purple_savedstatus_get_current();
 910         }
 911
 912         return saved_status;
 913 }
 914
 915
 916 PurpleSavedStatus *
 917 purple_savedstatus_find(const char *title)
 918 {
 919         GList *iter;
 920         PurpleSavedStatus *status;
 921
 922         g_return_val_if_fail(title != NULL, NULL);
 923
 924         for (iter = saved_statuses; iter != NULL; iter = iter->next)
 925         {
 926                 status = (PurpleSavedStatus *)iter->data;
 927                 if (purple_strequal(status->title, title))
 928                         return status;
 929         }
 930
 931         return NULL;
 932 }
 933
 934 PurpleSavedStatus *
 935 purple_savedstatus_find_by_creation_time(time_t creation_time)
 936 {
 937         GList *iter;
 938         PurpleSavedStatus *status;
 939
 940         for (iter = saved_statuses; iter != NULL; iter = iter->next)
 941         {
 942                 status = (PurpleSavedStatus *)iter->data;
 943                 if (status->creation_time == creation_time)
 944                         return status;
 945         }
 946
 947         return NULL;
 948 }
 949
 950 PurpleSavedStatus *
 951 purple_savedstatus_find_transient_by_type_and_message(PurpleStatusPrimitive type,
 952                                                                                                         const char *message)
 953 {
 954         GList *iter;
 955         PurpleSavedStatus *status;
 956
 957         for (iter = saved_statuses; iter != NULL; iter = iter->next)
 958         {
 959                 status = (PurpleSavedStatus *)iter->data;
 960                 if ((status->type == type) && purple_savedstatus_is_transient(status) &&
 961                         !purple_savedstatus_has_substatuses(status) &&
 962                         purple_strequal(status->message, message))
 963                 {
 964                         return status;
 965                 }
 966         }
 967
 968         return NULL;
 969 }
 970
 971 gboolean
 972 purple_savedstatus_is_transient(const PurpleSavedStatus *saved_status)
 973 {
 974         g_return_val_if_fail(saved_status != NULL, TRUE);
 975
 976         return (saved_status->title == NULL);
 977 }
 978
 979 const char *
 980 purple_savedstatus_get_title(const PurpleSavedStatus *saved_status)
 981 {
 982         const char *message;
 983
 984         g_return_val_if_fail(saved_status != NULL, NULL);
 985
 986         /* If we have a title then return it */
 987         if (saved_status->title != NULL)
 988                 return saved_status->title;
 989
 990         /* Otherwise, this is a transient status and we make up a title on the fly */
 991         message = purple_savedstatus_get_message(saved_status);
 992
 993         if ((message == NULL) || (*message == '\0'))
 994         {
 995                 PurpleStatusPrimitive primitive;
 996                 primitive = purple_savedstatus_get_primitive_type(saved_status);
 997                 return purple_primitive_get_name_from_type(primitive);
 998         }
 999         else
1000         {
1001                 char *stripped;
1002                 static char buf[64];
1003                 stripped = purple_markup_strip_html(message);
1004                 purple_util_chrreplace(stripped, '\n', ' ');
1005                 strncpy(buf, stripped, sizeof(buf));
1006                 buf[sizeof(buf) - 1] = '\0';
1007                 if ((strlen(stripped) + 1) > sizeof(buf))
1008                 {
1009                         /* Truncate and ellipsize */
1010                         char *tmp = g_utf8_find_prev_char(buf, &buf[sizeof(buf) - 4]);
1011                         strcpy(tmp, "...");
1012                 }
1013                 g_free(stripped);
1014                 return buf;
1015         }
1016 }
1017
1018 PurpleStatusPrimitive
1019 purple_savedstatus_get_primitive_type(const PurpleSavedStatus *saved_status)
1020 {
1021         g_return_val_if_fail(saved_status != NULL, PURPLE_STATUS_OFFLINE);
1022
1023         return saved_status->type;
1024 }
1025
1026 const char *
1027 purple_savedstatus_get_message(const PurpleSavedStatus *saved_status)
1028 {
1029         g_return_val_if_fail(saved_status != NULL, NULL);
1030
1031         return saved_status->message;
1032 }
1033
1034 time_t
1035 purple_savedstatus_get_creation_time(const PurpleSavedStatus *saved_status)
1036 {
1037         g_return_val_if_fail(saved_status != NULL, 0);
1038
1039         return saved_status->creation_time;
1040 }
1041
1042 gboolean
1043 purple_savedstatus_has_substatuses(const PurpleSavedStatus *saved_status)
1044 {
1045         g_return_val_if_fail(saved_status != NULL, FALSE);
1046
1047         return (saved_status->substatuses != NULL);
1048 }
1049
1050 PurpleSavedStatusSub *
1051 purple_savedstatus_get_substatus(const PurpleSavedStatus *saved_status,
1052                                                            const PurpleAccount *account)
1053 {
1054         GList *iter;
1055         PurpleSavedStatusSub *substatus;
1056
1057         g_return_val_if_fail(saved_status != NULL, NULL);
1058         g_return_val_if_fail(account      != NULL, NULL);
1059
1060         for (iter = saved_status->substatuses; iter != NULL; iter = iter->next)
1061         {
1062                 substatus = iter->data;
1063                 if (substatus->account == account)
1064                         return substatus;
1065         }
1066
1067         return NULL;
1068 }
1069
1070 const PurpleStatusType *
1071 purple_savedstatus_substatus_get_status_type(const PurpleSavedStatusSub *substatus)
1072 {
1073         g_return_val_if_fail(substatus != NULL, NULL);
1074
1075         return substatus->type;
1076 }
1077
1078 const char *
1079 purple_savedstatus_substatus_get_message(const PurpleSavedStatusSub *substatus)
1080 {
1081         g_return_val_if_fail(substatus != NULL, NULL);
1082
1083         return substatus->message;
1084 }
1085
1086 void
1087 purple_savedstatus_activate(PurpleSavedStatus *saved_status)
1088 {
1089         GList *accounts, *node;
1090         PurpleSavedStatus *old = purple_savedstatus_get_current();
1091
1092         g_return_if_fail(saved_status != NULL);
1093
1094         /* Make sure our list of saved statuses remains sorted */
1095         saved_status->lastused = time(NULL);
1096         saved_status->usage_count++;
1097         saved_statuses = g_list_remove(saved_statuses, saved_status);
1098         saved_statuses = g_list_insert_sorted(saved_statuses, saved_status, saved_statuses_sort_func);
1099         purple_prefs_set_int("/purple/savedstatus/default",
1100                                            purple_savedstatus_get_creation_time(saved_status));
1101
1102         accounts = purple_accounts_get_all_active();
1103         for (node = accounts; node != NULL; node = node->next)
1104         {
1105                 PurpleAccount *account;
1106
1107                 account = node->data;
1108
1109                 purple_savedstatus_activate_for_account(saved_status, account);
1110         }
1111
1112         g_list_free(accounts);
1113
1114         if (purple_savedstatus_is_idleaway()) {
1115                 purple_savedstatus_set_idleaway(FALSE);
1116         } else {
1117                 purple_signal_emit(purple_savedstatuses_get_handle(), "savedstatus-changed",
1118                                                    saved_status, old);
1119         }
1120 }
1121
1122 void
1123 purple_savedstatus_activate_for_account(const PurpleSavedStatus *saved_status,
1124                                                                           PurpleAccount *account)
1125 {
1126         const PurpleStatusType *status_type;
1127         const PurpleSavedStatusSub *substatus;
1128         const char *message = NULL;
1129
1130         g_return_if_fail(saved_status != NULL);
1131         g_return_if_fail(account != NULL);
1132
1133         substatus = purple_savedstatus_get_substatus(saved_status, account);
1134         if (substatus != NULL)
1135         {
1136                 status_type = substatus->type;
1137                 message = substatus->message;
1138         }
1139         else
1140         {
1141                 status_type = purple_account_get_status_type_with_primitive(account, saved_status->type);
1142                 if (status_type == NULL)
1143                         return;
1144                 message = saved_status->message;
1145         }
1146
1147         if ((message != NULL) &&
1148                 (purple_status_type_get_attr(status_type, "message")))
1149         {
1150                 purple_account_set_status(account, purple_status_type_get_id(status_type),
1151                                                                 TRUE, "message", message, NULL);
1152         }
1153         else
1154         {
1155                 purple_account_set_status(account, purple_status_type_get_id(status_type),
1156                                                                 TRUE, NULL);
1157         }
1158 }
1159
1160 static PurpleSavedStatus *
1161 purple_savedstatus_copy(PurpleSavedStatus *savedstatus)
1162 {
1163         PurpleSavedStatus *savedstatus_copy;
1164
1165         g_return_val_if_fail(savedstatus != NULL, NULL);
1166
1167         savedstatus_copy = g_new(PurpleSavedStatus, 1);
1168         *savedstatus_copy = *savedstatus;
1169
1170         return savedstatus_copy;
1171 }
1172
1173 GType
1174 purple_savedstatus_get_type(void)
1175 {
1176         static GType type = 0;
1177
1178         if (type == 0) {
1179                 type = g_boxed_type_register_static("PurpleSavedStatus",
1180                                 (GBoxedCopyFunc)purple_savedstatus_copy,
1181                                 (GBoxedFreeFunc)g_free);
1182         }
1183
1184         return type;
1185 }
1186
1187 void *
1188 purple_savedstatuses_get_handle(void)
1189 {
1190         static int handle;
1191
1192         return &handle;
1193 }
1194
1195 void
1196 purple_savedstatuses_init(void)
1197 {
1198         void *handle = purple_savedstatuses_get_handle();
1199
1200         creation_times = g_hash_table_new(g_direct_hash, g_direct_equal);
1201
1202         /*
1203          * Using 0 as the creation_time is a special case.
1204          * If someone calls purple_savedstatus_get_current() or
1205          * purple_savedstatus_get_idleaway() and either of those functions
1206          * sees a creation_time of 0, then it will create a default
1207          * saved status and return that to the user.
1208          */
1209         purple_prefs_add_none("/purple/savedstatus");
1210         purple_prefs_add_int("/purple/savedstatus/default", 0);
1211         purple_prefs_add_int("/purple/savedstatus/startup", 0);
1212         purple_prefs_add_bool("/purple/savedstatus/startup_current_status", TRUE);
1213         purple_prefs_add_int("/purple/savedstatus/idleaway", 0);
1214         purple_prefs_add_bool("/purple/savedstatus/isidleaway", FALSE);
1215
1216         load_statuses();
1217
1218         purple_signal_register(handle, "savedstatus-changed",
1219                                          purple_marshal_VOID__POINTER_POINTER, G_TYPE_NONE, 2,
1220                                          PURPLE_TYPE_SAVEDSTATUS, PURPLE_TYPE_SAVEDSTATUS);
1221
1222         purple_signal_register(handle, "savedstatus-added",
1223                 purple_marshal_VOID__POINTER, G_TYPE_NONE, 1,
1224                 PURPLE_TYPE_SAVEDSTATUS);
1225
1226         purple_signal_register(handle, "savedstatus-deleted",
1227                 purple_marshal_VOID__POINTER, G_TYPE_NONE, 1,
1228                 PURPLE_TYPE_SAVEDSTATUS);
1229
1230         purple_signal_register(handle, "savedstatus-modified",
1231                 purple_marshal_VOID__POINTER, G_TYPE_NONE, 1,
1232                 PURPLE_TYPE_SAVEDSTATUS);
1233
1234         purple_signal_connect(purple_accounts_get_handle(), "account-removed",
1235                         handle,
1236                         PURPLE_CALLBACK(purple_savedstatus_unset_all_substatuses),
1237                         NULL);
1238 }
1239
1240 void
1241 purple_savedstatuses_uninit(void)
1242 {
1243         gpointer handle = purple_savedstatuses_get_handle();
1244
1245         remove_old_transient_statuses();
1246
1247         if (save_timer != 0)
1248         {
1249                 g_source_remove(save_timer);
1250                 save_timer = 0;
1251                 sync_statuses();
1252         }
1253
1254         while (saved_statuses != NULL) {
1255                 PurpleSavedStatus *saved_status = saved_statuses->data;
1256                 saved_statuses = g_list_remove(saved_statuses, saved_status);
1257                 free_saved_status(saved_status);
1258         }
1259
1260         g_hash_table_destroy(creation_times);
1261         creation_times = NULL;
1262
1263         purple_signals_unregister_by_instance(handle);
1264         purple_signals_disconnect_by_handle(handle);
1265 }
1266