Mercurial > pidgin.yaz
diff libpurple/savedstatuses.c @ 15374:5fe8042783c1
Rename gtk/ and libgaim/ to pidgin/ and libpurple/
author | Sean Egan <seanegan@gmail.com> |
---|---|
date | Sat, 20 Jan 2007 02:32:10 +0000 |
parents | |
children | 6d8728fd3dda |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/libpurple/savedstatuses.c Sat Jan 20 02:32:10 2007 +0000 @@ -0,0 +1,1195 @@ +/** + * @file savedstatuses.c Saved Status API + * @ingroup core + * + * gaim + * + * Gaim is the legal property of its developers, whose names are too numerous + * to list here. Please refer to the COPYRIGHT file distributed with this + * source distribution. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ +#include "internal.h" + +#include "debug.h" +#include "idle.h" +#include "notify.h" +#include "savedstatuses.h" +#include "dbus-maybe.h" +#include "status.h" +#include "util.h" +#include "xmlnode.h" + +/** + * The maximum number of transient statuses to save. This + * is used during the shutdown process to clean out old + * transient statuses. + */ +#define MAX_TRANSIENTS 5 + +/** + * The default message to use when the user becomes auto-away. + */ +#define DEFAULT_AUTOAWAY_MESSAGE _("I'm not here right now") + +/** + * The information stores a snap-shot of the statuses of all + * your accounts. Basically these are your saved away messages. + * There is an overall status and message that applies to + * all your accounts, and then each individual account can + * optionally have a different custom status and message. + * + * The changes to status.xml caused by the new status API + * are fully backward compatible. The new status API just + * adds the optional sub-statuses to the XML file. + */ +struct _GaimSavedStatus +{ + char *title; + GaimStatusPrimitive type; + char *message; + + /** The timestamp when this saved status was created. This must be unique. */ + time_t creation_time; + + time_t lastused; + + unsigned int usage_count; + + GList *substatuses; /**< A list of GaimSavedStatusSub's. */ +}; + +/* + * TODO: If a GaimStatusType is deleted, need to also delete any + * associated GaimSavedStatusSub's? + */ +struct _GaimSavedStatusSub +{ + GaimAccount *account; + const GaimStatusType *type; + char *message; +}; + +static GList *saved_statuses = NULL; +static guint save_timer = 0; +static gboolean statuses_loaded = FALSE; + +/* + * This hash table keeps track of which timestamps we've + * used so that we don't have two saved statuses with the + * same 'creation_time' timestamp. The 'created' timestamp + * is used as a unique identifier. + * + * So the key in this hash table is the creation_time and + * the value is a pointer to the GaimSavedStatus. + */ +static GHashTable *creation_times; + +static void schedule_save(void); + +/********************************************************************* + * Private utility functions * + *********************************************************************/ + +static void +free_saved_status_sub(GaimSavedStatusSub *substatus) +{ + g_return_if_fail(substatus != NULL); + + g_free(substatus->message); + GAIM_DBUS_UNREGISTER_POINTER(substatus); + g_free(substatus); +} + +static void +free_saved_status(GaimSavedStatus *status) +{ + g_return_if_fail(status != NULL); + + g_free(status->title); + g_free(status->message); + + while (status->substatuses != NULL) + { + GaimSavedStatusSub *substatus = status->substatuses->data; + status->substatuses = g_list_remove(status->substatuses, substatus); + free_saved_status_sub(substatus); + } + + GAIM_DBUS_UNREGISTER_POINTER(status); + g_free(status); +} + +/* + * Set the timestamp for when this saved status was created, and + * make sure it is unique. + */ +static void +set_creation_time(GaimSavedStatus *status, time_t creation_time) +{ + g_return_if_fail(status != NULL); + + /* Avoid using 0 because it's an invalid hash key */ + status->creation_time = creation_time != 0 ? creation_time : 1; + + while (g_hash_table_lookup(creation_times, &status->creation_time) != NULL) + status->creation_time++; + + g_hash_table_insert(creation_times, + &status->creation_time, + status); +} + +/** + * A magic number is calcuated for each status, and then the + * statuses are ordered by the magic number. The magic number + * is the date the status was last used offset by one day for + * each time the status has been used (but only by 10 days at + * the most). + * + * The goal is to have recently used statuses at the top of + * the list, but to also keep frequently used statuses near + * the top. + */ +static gint +saved_statuses_sort_func(gconstpointer a, gconstpointer b) +{ + const GaimSavedStatus *saved_status_a = a; + const GaimSavedStatus *saved_status_b = b; + time_t time_a = saved_status_a->lastused + + (MIN(saved_status_a->usage_count, 10) * 86400); + time_t time_b = saved_status_b->lastused + + (MIN(saved_status_b->usage_count, 10) * 86400); + if (time_a > time_b) + return -1; + if (time_a < time_b) + return 1; + return 0; +} + +/** + * Transient statuses are added and removed automatically by + * Gaim. If they're not used for a certain length of time then + * they'll expire and be automatically removed. This function + * does the expiration. + */ +static void +remove_old_transient_statuses() +{ + GList *l, *next; + GaimSavedStatus *saved_status, *current_status; + int count; + time_t creation_time; + + current_status = gaim_savedstatus_get_current(); + + /* + * Iterate through the list of saved statuses. Delete all + * transient statuses except for the first MAX_TRANSIENTS + * (remember, the saved statuses are already sorted by popularity). + */ + count = 0; + for (l = saved_statuses; l != NULL; l = next) + { + next = l->next; + saved_status = l->data; + if (gaim_savedstatus_is_transient(saved_status)) + { + if (count == MAX_TRANSIENTS) + { + if (saved_status != current_status) + { + saved_statuses = g_list_remove(saved_statuses, saved_status); + creation_time = gaim_savedstatus_get_creation_time(saved_status); + g_hash_table_remove(creation_times, &creation_time); + free_saved_status(saved_status); + } + } + else + count++; + } + } + + if (count == MAX_TRANSIENTS) + schedule_save(); +} + +/********************************************************************* + * Writing to disk * + *********************************************************************/ + +static xmlnode * +substatus_to_xmlnode(GaimSavedStatusSub *substatus) +{ + xmlnode *node, *child; + + node = xmlnode_new("substatus"); + + child = xmlnode_new_child(node, "account"); + xmlnode_set_attrib(child, "protocol", gaim_account_get_protocol_id(substatus->account)); + xmlnode_insert_data(child, gaim_account_get_username(substatus->account), -1); + + child = xmlnode_new_child(node, "state"); + xmlnode_insert_data(child, gaim_status_type_get_id(substatus->type), -1); + + if (substatus->message != NULL) + { + child = xmlnode_new_child(node, "message"); + xmlnode_insert_data(child, substatus->message, -1); + } + + return node; +} + +static xmlnode * +status_to_xmlnode(GaimSavedStatus *status) +{ + xmlnode *node, *child; + char buf[21]; + GList *cur; + + node = xmlnode_new("status"); + if (status->title != NULL) + { + xmlnode_set_attrib(node, "name", status->title); + } + else + { + /* + * Gaim 1.5.0 and earlier require a name to be set, so we + * do this little hack to maintain backward compatability + * in the status.xml file. Eventually this should be removed + * and we should determine if a status is transient by + * whether the "name" attribute is set to something or if + * it does not exist at all. + */ + xmlnode_set_attrib(node, "name", "Auto-Cached"); + xmlnode_set_attrib(node, "transient", "true"); + } + + snprintf(buf, sizeof(buf), "%lu", status->creation_time); + xmlnode_set_attrib(node, "created", buf); + + snprintf(buf, sizeof(buf), "%lu", status->lastused); + xmlnode_set_attrib(node, "lastused", buf); + + snprintf(buf, sizeof(buf), "%u", status->usage_count); + xmlnode_set_attrib(node, "usage_count", buf); + + child = xmlnode_new_child(node, "state"); + xmlnode_insert_data(child, gaim_primitive_get_id_from_type(status->type), -1); + + if (status->message != NULL) + { + child = xmlnode_new_child(node, "message"); + xmlnode_insert_data(child, status->message, -1); + } + + for (cur = status->substatuses; cur != NULL; cur = cur->next) + { + child = substatus_to_xmlnode(cur->data); + xmlnode_insert_child(node, child); + } + + return node; +} + +static xmlnode * +statuses_to_xmlnode(void) +{ + xmlnode *node, *child; + GList *cur; + + node = xmlnode_new("statuses"); + xmlnode_set_attrib(node, "version", "1.0"); + + for (cur = saved_statuses; cur != NULL; cur = cur->next) + { + child = status_to_xmlnode(cur->data); + xmlnode_insert_child(node, child); + } + + return node; +} + +static void +sync_statuses(void) +{ + xmlnode *node; + char *data; + + if (!statuses_loaded) + { + gaim_debug_error("status", "Attempted to save statuses before they " + "were read!\n"); + return; + } + + node = statuses_to_xmlnode(); + data = xmlnode_to_formatted_str(node, NULL); + gaim_util_write_data_to_file("status.xml", data, -1); + g_free(data); + xmlnode_free(node); +} + +static gboolean +save_cb(gpointer data) +{ + sync_statuses(); + save_timer = 0; + return FALSE; +} + +static void +schedule_save(void) +{ + if (save_timer == 0) + save_timer = gaim_timeout_add(5000, save_cb, NULL); +} + + +/********************************************************************* + * Reading from disk * + *********************************************************************/ + +static GaimSavedStatusSub * +parse_substatus(xmlnode *substatus) +{ + GaimSavedStatusSub *ret; + xmlnode *node; + char *data; + + ret = g_new0(GaimSavedStatusSub, 1); + + /* Read the account */ + node = xmlnode_get_child(substatus, "account"); + if (node != NULL) + { + char *acct_name; + const char *protocol; + acct_name = xmlnode_get_data(node); + protocol = xmlnode_get_attrib(node, "protocol"); + if ((acct_name != NULL) && (protocol != NULL)) + ret->account = gaim_accounts_find(acct_name, protocol); + g_free(acct_name); + } + + if (ret->account == NULL) + { + g_free(ret); + return NULL; + } + + /* Read the state */ + node = xmlnode_get_child(substatus, "state"); + if ((node != NULL) && ((data = xmlnode_get_data(node)) != NULL)) + { + ret->type = gaim_status_type_find_with_id( + ret->account->status_types, data); + g_free(data); + } + + /* Read the message */ + node = xmlnode_get_child(substatus, "message"); + if ((node != NULL) && ((data = xmlnode_get_data(node)) != NULL)) + { + ret->message = data; + } + + GAIM_DBUS_REGISTER_POINTER(ret, GaimSavedStatusSub); + return ret; +} + +/** + * Parse a saved status and add it to the saved_statuses linked list. + * + * Here's an example of the XML for a saved status: + * <status name="Girls"> + * <state>away</state> + * <message>I like the way that they walk + * And it's chill to hear them talk + * And I can always make them smile + * From White Castle to the Nile</message> + * <substatus> + * <account protocol='prpl-oscar'>markdoliner</account> + * <state>available</state> + * <message>The ladies man is here to answer your queries.</message> + * </substatus> + * <substatus> + * <account protocol='prpl-oscar'>giantgraypanda</account> + * <state>away</state> + * <message>A.C. ain't in charge no more.</message> + * </substatus> + * </status> + * + * I know. Moving, huh? + */ +static GaimSavedStatus * +parse_status(xmlnode *status) +{ + GaimSavedStatus *ret; + xmlnode *node; + const char *attrib; + char *data; + int i; + + ret = g_new0(GaimSavedStatus, 1); + + attrib = xmlnode_get_attrib(status, "transient"); + if ((attrib == NULL) || (strcmp(attrib, "true"))) + { + /* Read the title */ + attrib = xmlnode_get_attrib(status, "name"); + ret->title = g_strdup(attrib); + } + + if (ret->title != NULL) + { + /* Ensure the title is unique */ + i = 2; + while (gaim_savedstatus_find(ret->title) != NULL) + { + g_free(ret->title); + ret->title = g_strdup_printf("%s %d", attrib, i); + i++; + } + } + + /* Read the creation time */ + attrib = xmlnode_get_attrib(status, "created"); + set_creation_time(ret, (attrib != NULL ? atol(attrib) : 0)); + + /* Read the last used time */ + attrib = xmlnode_get_attrib(status, "lastused"); + ret->lastused = (attrib != NULL ? atol(attrib) : 0); + + /* Read the usage count */ + attrib = xmlnode_get_attrib(status, "usage_count"); + ret->usage_count = (attrib != NULL ? atol(attrib) : 0); + + /* Read the primitive status type */ + node = xmlnode_get_child(status, "state"); + if ((node != NULL) && ((data = xmlnode_get_data(node)) != NULL)) + { + ret->type = gaim_primitive_get_type_from_id(data); + g_free(data); + } + + /* Read the message */ + node = xmlnode_get_child(status, "message"); + if ((node != NULL) && ((data = xmlnode_get_data(node)) != NULL)) + { + ret->message = data; + } + + /* Read substatuses */ + for (node = xmlnode_get_child(status, "substatus"); node != NULL; + node = xmlnode_get_next_twin(node)) + { + GaimSavedStatusSub *new; + new = parse_substatus(node); + if (new != NULL) + ret->substatuses = g_list_prepend(ret->substatuses, new); + } + + GAIM_DBUS_REGISTER_POINTER(ret, GaimSavedStatus); + return ret; +} + +/** + * Read the saved statuses from a file in the Gaim user dir. + * + * @return TRUE on success, FALSE on failure (if the file can not + * be opened, or if it contains invalid XML). + */ +static void +load_statuses(void) +{ + xmlnode *statuses, *status; + + statuses_loaded = TRUE; + + statuses = gaim_util_read_xml_from_file("status.xml", _("saved statuses")); + + if (statuses == NULL) + return; + + for (status = xmlnode_get_child(statuses, "status"); status != NULL; + status = xmlnode_get_next_twin(status)) + { + GaimSavedStatus *new; + new = parse_status(status); + saved_statuses = g_list_prepend(saved_statuses, new); + } + saved_statuses = g_list_sort(saved_statuses, saved_statuses_sort_func); + + xmlnode_free(statuses); +} + + +/************************************************************************** +* Saved status API +**************************************************************************/ +GaimSavedStatus * +gaim_savedstatus_new(const char *title, GaimStatusPrimitive type) +{ + GaimSavedStatus *status; + + /* Make sure we don't already have a saved status with this title. */ + if (title != NULL) + g_return_val_if_fail(gaim_savedstatus_find(title) == NULL, NULL); + + status = g_new0(GaimSavedStatus, 1); + GAIM_DBUS_REGISTER_POINTER(status, GaimSavedStatus); + status->title = g_strdup(title); + status->type = type; + set_creation_time(status, time(NULL)); + + saved_statuses = g_list_insert_sorted(saved_statuses, status, saved_statuses_sort_func); + + schedule_save(); + + return status; +} + +void +gaim_savedstatus_set_title(GaimSavedStatus *status, const char *title) +{ + g_return_if_fail(status != NULL); + + /* Make sure we don't already have a saved status with this title. */ + g_return_if_fail(gaim_savedstatus_find(title) == NULL); + + g_free(status->title); + status->title = g_strdup(title); + + schedule_save(); +} + +void +gaim_savedstatus_set_type(GaimSavedStatus *status, GaimStatusPrimitive type) +{ + g_return_if_fail(status != NULL); + + status->type = type; + + schedule_save(); +} + +void +gaim_savedstatus_set_message(GaimSavedStatus *status, const char *message) +{ + g_return_if_fail(status != NULL); + + g_free(status->message); + if ((message != NULL) && (*message == '\0')) + status->message = NULL; + else + status->message = g_strdup(message); + + schedule_save(); +} + +void +gaim_savedstatus_set_substatus(GaimSavedStatus *saved_status, + const GaimAccount *account, + const GaimStatusType *type, + const char *message) +{ + GaimSavedStatusSub *substatus; + + g_return_if_fail(saved_status != NULL); + g_return_if_fail(account != NULL); + g_return_if_fail(type != NULL); + + /* Find an existing substatus or create a new one */ + substatus = gaim_savedstatus_get_substatus(saved_status, account); + if (substatus == NULL) + { + substatus = g_new0(GaimSavedStatusSub, 1); + GAIM_DBUS_REGISTER_POINTER(substatus, GaimSavedStatusSub); + substatus->account = (GaimAccount *)account; + saved_status->substatuses = g_list_prepend(saved_status->substatuses, substatus); + } + + substatus->type = type; + g_free(substatus->message); + substatus->message = g_strdup(message); + + schedule_save(); +} + +void +gaim_savedstatus_unset_substatus(GaimSavedStatus *saved_status, + const GaimAccount *account) +{ + GList *iter; + GaimSavedStatusSub *substatus; + + g_return_if_fail(saved_status != NULL); + g_return_if_fail(account != NULL); + + for (iter = saved_status->substatuses; iter != NULL; iter = iter->next) + { + substatus = iter->data; + if (substatus->account == account) + { + saved_status->substatuses = g_list_delete_link(saved_status->substatuses, iter); + g_free(substatus->message); + g_free(substatus); + return; + } + } +} + +/* + * This gets called when an account is deleted. We iterate through + * all of our saved statuses and delete any substatuses that may + * exist for this account. + */ +static void +gaim_savedstatus_unset_all_substatuses(const GaimAccount *account, + gpointer user_data) +{ + GList *iter; + GaimSavedStatus *status; + + g_return_if_fail(account != NULL); + + for (iter = saved_statuses; iter != NULL; iter = iter->next) + { + status = (GaimSavedStatus *)iter->data; + gaim_savedstatus_unset_substatus(status, account); + } +} + +gboolean +gaim_savedstatus_delete(const char *title) +{ + GaimSavedStatus *status; + time_t creation_time, current, idleaway; + + status = gaim_savedstatus_find(title); + + if (status == NULL) + return FALSE; + + saved_statuses = g_list_remove(saved_statuses, status); + creation_time = gaim_savedstatus_get_creation_time(status); + g_hash_table_remove(creation_times, &creation_time); + free_saved_status(status); + + schedule_save(); + + /* + * If we just deleted our current status or our idleaway status, + * then set the appropriate pref back to 0. + */ + current = gaim_prefs_get_int("/core/savedstatus/default"); + if (current == creation_time) + gaim_prefs_set_int("/core/savedstatus/default", 0); + + idleaway = gaim_prefs_get_int("/core/savedstatus/idleaway"); + if (idleaway == creation_time) + gaim_prefs_set_int("/core/savedstatus/idleaway", 0); + + return TRUE; +} + +const GList * +gaim_savedstatuses_get_all(void) +{ + return saved_statuses; +} + +GList * +gaim_savedstatuses_get_popular(unsigned int how_many) +{ + GList *popular = NULL; + GList *cur; + int i; + GaimSavedStatus *next; + + /* Copy 'how_many' elements to a new list */ + i = 0; + cur = saved_statuses; + while ((i < how_many) && (cur != NULL)) + { + next = cur->data; + if ((!gaim_savedstatus_is_transient(next) + || gaim_savedstatus_get_message(next) != NULL)) + { + popular = g_list_prepend(popular, cur->data); + i++; + } + cur = cur->next; + } + + popular = g_list_reverse(popular); + + return popular; +} + +GaimSavedStatus * +gaim_savedstatus_get_current(void) +{ + if (gaim_savedstatus_is_idleaway()) + return gaim_savedstatus_get_idleaway(); + else + return gaim_savedstatus_get_default(); +} + +GaimSavedStatus * +gaim_savedstatus_get_default() +{ + int creation_time; + GaimSavedStatus *saved_status = NULL; + + creation_time = gaim_prefs_get_int("/core/savedstatus/default"); + + if (creation_time != 0) + saved_status = g_hash_table_lookup(creation_times, &creation_time); + + if (saved_status == NULL) + { + /* + * We don't have a current saved status! This is either a new + * Gaim user or someone upgrading from Gaim 1.5.0 or older, or + * possibly someone who deleted the status they were currently + * using? In any case, add a default status. + */ + saved_status = gaim_savedstatus_new(NULL, GAIM_STATUS_AVAILABLE); + gaim_prefs_set_int("/core/savedstatus/default", + gaim_savedstatus_get_creation_time(saved_status)); + } + + return saved_status; +} + +GaimSavedStatus * +gaim_savedstatus_get_idleaway() +{ + int creation_time; + GaimSavedStatus *saved_status = NULL; + + creation_time = gaim_prefs_get_int("/core/savedstatus/idleaway"); + + if (creation_time != 0) + saved_status = g_hash_table_lookup(creation_times, &creation_time); + + if (saved_status == NULL) + { + /* We don't have a specified "idle" status! Weird. */ + saved_status = gaim_savedstatus_find_transient_by_type_and_message( + GAIM_STATUS_AWAY, DEFAULT_AUTOAWAY_MESSAGE); + + if (saved_status == NULL) + { + saved_status = gaim_savedstatus_new(NULL, GAIM_STATUS_AWAY); + gaim_savedstatus_set_message(saved_status, DEFAULT_AUTOAWAY_MESSAGE); + gaim_prefs_set_int("/core/savedstatus/idleaway", + gaim_savedstatus_get_creation_time(saved_status)); + } + } + + return saved_status; +} + +gboolean +gaim_savedstatus_is_idleaway() +{ + return gaim_prefs_get_bool("/core/savedstatus/isidleaway"); +} + +void +gaim_savedstatus_set_idleaway(gboolean idleaway) +{ + GList *accounts, *node; + GaimSavedStatus *old, *saved_status; + + if (gaim_savedstatus_is_idleaway() == idleaway) + /* Don't need to do anything */ + return; + + /* Changing our status makes us un-idle */ + if (!idleaway) + gaim_idle_touch(); + + old = gaim_savedstatus_get_current(); + gaim_prefs_set_bool("/core/savedstatus/isidleaway", idleaway); + saved_status = idleaway ? gaim_savedstatus_get_idleaway() + : gaim_savedstatus_get_default(); + + if (idleaway && (gaim_savedstatus_get_type(old) != GAIM_STATUS_AVAILABLE)) + /* Our global status is already "away," so don't change anything */ + return; + + accounts = gaim_accounts_get_all_active(); + for (node = accounts; node != NULL; node = node->next) + { + GaimAccount *account; + GaimPresence *presence; + GaimStatus *status; + + account = node->data; + presence = gaim_account_get_presence(account); + status = gaim_presence_get_active_status(presence); + + if (!idleaway || gaim_status_is_available(status)) + gaim_savedstatus_activate_for_account(saved_status, account); + } + + g_list_free(accounts); + + gaim_signal_emit(gaim_savedstatuses_get_handle(), "savedstatus-changed", + saved_status, old); +} + +GaimSavedStatus * +gaim_savedstatus_get_startup() +{ + int creation_time; + GaimSavedStatus *saved_status = NULL; + + creation_time = gaim_prefs_get_int("/core/savedstatus/startup"); + + if (creation_time != 0) + saved_status = g_hash_table_lookup(creation_times, &creation_time); + + if (saved_status == NULL) + { + /* + * We don't have a status to apply. + * This may be the first login, or the user wants to + * restore the "current" status. + */ + saved_status = gaim_savedstatus_get_current(); + } + + return saved_status; +} + + +GaimSavedStatus * +gaim_savedstatus_find(const char *title) +{ + GList *iter; + GaimSavedStatus *status; + + g_return_val_if_fail(title != NULL, NULL); + + for (iter = saved_statuses; iter != NULL; iter = iter->next) + { + status = (GaimSavedStatus *)iter->data; + if ((status->title != NULL) && !strcmp(status->title, title)) + return status; + } + + return NULL; +} + +GaimSavedStatus * +gaim_savedstatus_find_by_creation_time(time_t creation_time) +{ + GList *iter; + GaimSavedStatus *status; + + for (iter = saved_statuses; iter != NULL; iter = iter->next) + { + status = (GaimSavedStatus *)iter->data; + if (status->creation_time == creation_time) + return status; + } + + return NULL; +} + +GaimSavedStatus * +gaim_savedstatus_find_transient_by_type_and_message(GaimStatusPrimitive type, + const char *message) +{ + GList *iter; + GaimSavedStatus *status; + + for (iter = saved_statuses; iter != NULL; iter = iter->next) + { + status = (GaimSavedStatus *)iter->data; + if ((status->type == type) && gaim_savedstatus_is_transient(status) && + !gaim_savedstatus_has_substatuses(status) && + (((status->message == NULL) && (message == NULL)) || + ((status->message != NULL) && (message != NULL) && !strcmp(status->message, message)))) + { + return status; + } + } + + return NULL; +} + +gboolean +gaim_savedstatus_is_transient(const GaimSavedStatus *saved_status) +{ + g_return_val_if_fail(saved_status != NULL, TRUE); + + return (saved_status->title == NULL); +} + +const char * +gaim_savedstatus_get_title(const GaimSavedStatus *saved_status) +{ + const char *message; + + g_return_val_if_fail(saved_status != NULL, NULL); + + /* If we have a title then return it */ + if (saved_status->title != NULL) + return saved_status->title; + + /* Otherwise, this is a transient status and we make up a title on the fly */ + message = gaim_savedstatus_get_message(saved_status); + + if ((message == NULL) || (*message == '\0')) + { + GaimStatusPrimitive primitive; + primitive = gaim_savedstatus_get_type(saved_status); + return gaim_primitive_get_name_from_type(primitive); + } + else + { + char *stripped; + static char buf[64]; + stripped = gaim_markup_strip_html(message); + gaim_util_chrreplace(stripped, '\n', ' '); + strncpy(buf, stripped, sizeof(buf)); + buf[sizeof(buf) - 1] = '\0'; + if ((strlen(stripped) + 1) > sizeof(buf)) + { + /* Truncate and ellipsize */ + char *tmp = g_utf8_find_prev_char(buf, &buf[sizeof(buf) - 4]); + strcpy(tmp, "..."); + } + g_free(stripped); + return buf; + } +} + +GaimStatusPrimitive +gaim_savedstatus_get_type(const GaimSavedStatus *saved_status) +{ + g_return_val_if_fail(saved_status != NULL, GAIM_STATUS_OFFLINE); + + return saved_status->type; +} + +const char * +gaim_savedstatus_get_message(const GaimSavedStatus *saved_status) +{ + g_return_val_if_fail(saved_status != NULL, NULL); + + return saved_status->message; +} + +time_t +gaim_savedstatus_get_creation_time(const GaimSavedStatus *saved_status) +{ + g_return_val_if_fail(saved_status != NULL, 0); + + return saved_status->creation_time; +} + +gboolean +gaim_savedstatus_has_substatuses(const GaimSavedStatus *saved_status) +{ + g_return_val_if_fail(saved_status != NULL, FALSE); + + return (saved_status->substatuses != NULL); +} + +GaimSavedStatusSub * +gaim_savedstatus_get_substatus(const GaimSavedStatus *saved_status, + const GaimAccount *account) +{ + GList *iter; + GaimSavedStatusSub *substatus; + + g_return_val_if_fail(saved_status != NULL, NULL); + g_return_val_if_fail(account != NULL, NULL); + + for (iter = saved_status->substatuses; iter != NULL; iter = iter->next) + { + substatus = iter->data; + if (substatus->account == account) + return substatus; + } + + return NULL; +} + +const GaimStatusType * +gaim_savedstatus_substatus_get_type(const GaimSavedStatusSub *substatus) +{ + g_return_val_if_fail(substatus != NULL, NULL); + + return substatus->type; +} + +const char * +gaim_savedstatus_substatus_get_message(const GaimSavedStatusSub *substatus) +{ + g_return_val_if_fail(substatus != NULL, NULL); + + return substatus->message; +} + +void +gaim_savedstatus_activate(GaimSavedStatus *saved_status) +{ + GList *accounts, *node; + GaimSavedStatus *old = gaim_savedstatus_get_current(); + + g_return_if_fail(saved_status != NULL); + + /* Make sure our list of saved statuses remains sorted */ + saved_status->lastused = time(NULL); + saved_status->usage_count++; + saved_statuses = g_list_remove(saved_statuses, saved_status); + saved_statuses = g_list_insert_sorted(saved_statuses, saved_status, saved_statuses_sort_func); + + accounts = gaim_accounts_get_all_active(); + for (node = accounts; node != NULL; node = node->next) + { + GaimAccount *account; + + account = node->data; + + gaim_savedstatus_activate_for_account(saved_status, account); + } + + g_list_free(accounts); + + gaim_prefs_set_int("/core/savedstatus/default", + gaim_savedstatus_get_creation_time(saved_status)); + gaim_savedstatus_set_idleaway(FALSE); + + gaim_signal_emit(gaim_savedstatuses_get_handle(), "savedstatus-changed", + saved_status, old); +} + +void +gaim_savedstatus_activate_for_account(const GaimSavedStatus *saved_status, + GaimAccount *account) +{ + const GaimStatusType *status_type; + const GaimSavedStatusSub *substatus; + const char *message = NULL; + + g_return_if_fail(saved_status != NULL); + g_return_if_fail(account != NULL); + + substatus = gaim_savedstatus_get_substatus(saved_status, account); + if (substatus != NULL) + { + status_type = substatus->type; + message = substatus->message; + } + else + { + status_type = gaim_account_get_status_type_with_primitive(account, saved_status->type); + if (status_type == NULL) + return; + message = saved_status->message; + } + + if ((message != NULL) && + (gaim_status_type_get_attr(status_type, "message"))) + { + gaim_account_set_status(account, gaim_status_type_get_id(status_type), + TRUE, "message", message, NULL); + } + else + { + gaim_account_set_status(account, gaim_status_type_get_id(status_type), + TRUE, NULL); + } +} + +void * +gaim_savedstatuses_get_handle(void) +{ + static int handle; + + return &handle; +} + +void +gaim_savedstatuses_init(void) +{ + void *handle = gaim_savedstatuses_get_handle(); + + creation_times = g_hash_table_new(g_int_hash, g_int_equal); + + /* + * Using 0 as the creation_time is a special case. + * If someone calls gaim_savedstatus_get_current() or + * gaim_savedstatus_get_idleaway() and either of those functions + * sees a creation_time of 0, then it will create a default + * saved status and return that to the user. + */ + gaim_prefs_add_none("/core/savedstatus"); + gaim_prefs_add_int("/core/savedstatus/default", 0); + gaim_prefs_add_int("/core/savedstatus/startup", 0); + gaim_prefs_add_bool("/core/savedstatus/startup_current_status", TRUE); + gaim_prefs_add_int("/core/savedstatus/idleaway", 0); + gaim_prefs_add_bool("/core/savedstatus/isidleaway", FALSE); + + load_statuses(); + + gaim_signal_register(handle, "savedstatus-changed", + gaim_marshal_VOID__POINTER_POINTER, NULL, 2, + gaim_value_new(GAIM_TYPE_SUBTYPE, + GAIM_SUBTYPE_SAVEDSTATUS), + gaim_value_new(GAIM_TYPE_SUBTYPE, + GAIM_SUBTYPE_SAVEDSTATUS)); + + gaim_signal_connect(gaim_accounts_get_handle(), "account-removed", + handle, + GAIM_CALLBACK(gaim_savedstatus_unset_all_substatuses), + NULL); +} + +void +gaim_savedstatuses_uninit(void) +{ + remove_old_transient_statuses(); + + if (save_timer != 0) + { + gaim_timeout_remove(save_timer); + save_timer = 0; + sync_statuses(); + } + + while (saved_statuses != NULL) { + GaimSavedStatus *saved_status = saved_statuses->data; + saved_statuses = g_list_remove(saved_statuses, saved_status); + free_saved_status(saved_status); + } + + g_hash_table_destroy(creation_times); + + gaim_signals_unregister_by_instance(gaim_savedstatuses_get_handle()); +} +