libpurple/savedstatuses.c

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