pidgin/pidgin

Replace purple_get_host_name by g_get_host_name.

18 months ago, Elliott Sales de Andrade
e353b2390ad8
Replace purple_get_host_name by g_get_host_name.
/* purple
*
* Purple 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., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
*/
#include "internal.h"
#include "debug.h"
#include "idle.h"
#include "notify.h"
#include "savedstatuses.h"
#include "request.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 _PurpleSavedStatus
{
char *title;
PurpleStatusPrimitive 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 PurpleSavedStatusSub's. */
};
/*
* TODO: If a PurpleStatusType is deleted, need to also delete any
* associated PurpleSavedStatusSub's?
*/
struct _PurpleSavedStatusSub
{
PurpleAccount *account;
const PurpleStatusType *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 PurpleSavedStatus.
*/
static GHashTable *creation_times;
static void schedule_save(void);
/*********************************************************************
* Private utility functions *
*********************************************************************/
static void
free_saved_status_sub(PurpleSavedStatusSub *substatus)
{
g_return_if_fail(substatus != NULL);
g_free(substatus->message);
purple_request_close_with_handle(substatus);
g_free(substatus);
}
static void
free_saved_status(PurpleSavedStatus *status)
{
g_return_if_fail(status != NULL);
g_free(status->title);
g_free(status->message);
g_list_free_full(status->substatuses, (GDestroyNotify)free_saved_status_sub);
purple_request_close_with_handle(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(PurpleSavedStatus *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, (gconstpointer)status->creation_time) != NULL)
status->creation_time++;
g_hash_table_insert(creation_times,
(gpointer)status->creation_time,
status);
}
/*
* A magic number is calculated 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 PurpleSavedStatus *saved_status_a = a;
const PurpleSavedStatus *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
* Purple. 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(void)
{
GList *l, *next;
PurpleSavedStatus *saved_status, *startup_status, *current_status;
int count;
time_t creation_time;
startup_status = purple_savedstatus_get_startup();
current_status = purple_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).
* We should also keep the startup status, if any is set.
*/
count = 0;
for (l = saved_statuses; l != NULL; l = next)
{
next = l->next;
saved_status = l->data;
if (purple_savedstatus_is_transient(saved_status))
{
if (count == MAX_TRANSIENTS)
{
if (saved_status != current_status && saved_status != startup_status)
{
saved_statuses = g_list_delete_link(saved_statuses, l);
creation_time = purple_savedstatus_get_creation_time(saved_status);
g_hash_table_remove(creation_times, (gconstpointer)creation_time);
free_saved_status(saved_status);
}
}
else
count++;
}
}
if (count == MAX_TRANSIENTS)
schedule_save();
}
/*********************************************************************
* Writing to disk *
*********************************************************************/
static PurpleXmlNode *
substatus_to_xmlnode(PurpleSavedStatusSub *substatus)
{
PurpleXmlNode *node, *child;
node = purple_xmlnode_new("substatus");
child = purple_xmlnode_new_child(node, "account");
purple_xmlnode_set_attrib(child, "protocol", purple_account_get_protocol_id(substatus->account));
purple_xmlnode_insert_data(child,
purple_normalize(substatus->account,
purple_account_get_username(substatus->account)), -1);
child = purple_xmlnode_new_child(node, "state");
purple_xmlnode_insert_data(child, purple_status_type_get_id(substatus->type), -1);
if (substatus->message != NULL)
{
child = purple_xmlnode_new_child(node, "message");
purple_xmlnode_insert_data(child, substatus->message, -1);
}
return node;
}
static PurpleXmlNode *
status_to_xmlnode(PurpleSavedStatus *status)
{
PurpleXmlNode *node, *child;
char buf[21];
GList *cur;
node = purple_xmlnode_new("status");
if (status->title != NULL)
{
purple_xmlnode_set_attrib(node, "name", status->title);
}
else
{
/*
* Purple 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.
*/
purple_xmlnode_set_attrib(node, "name", "Auto-Cached");
purple_xmlnode_set_attrib(node, "transient", "true");
}
g_snprintf(buf, sizeof(buf), "%lu", status->creation_time);
purple_xmlnode_set_attrib(node, "created", buf);
g_snprintf(buf, sizeof(buf), "%lu", status->lastused);
purple_xmlnode_set_attrib(node, "lastused", buf);
g_snprintf(buf, sizeof(buf), "%u", status->usage_count);
purple_xmlnode_set_attrib(node, "usage_count", buf);
child = purple_xmlnode_new_child(node, "state");
purple_xmlnode_insert_data(child, purple_primitive_get_id_from_type(status->type), -1);
if (status->message != NULL)
{
child = purple_xmlnode_new_child(node, "message");
purple_xmlnode_insert_data(child, status->message, -1);
}
for (cur = status->substatuses; cur != NULL; cur = cur->next)
{
child = substatus_to_xmlnode(cur->data);
purple_xmlnode_insert_child(node, child);
}
return node;
}
static PurpleXmlNode *
statuses_to_xmlnode(void)
{
PurpleXmlNode *node, *child;
GList *cur;
node = purple_xmlnode_new("statuses");
purple_xmlnode_set_attrib(node, "version", "1.0");
for (cur = saved_statuses; cur != NULL; cur = cur->next)
{
child = status_to_xmlnode(cur->data);
purple_xmlnode_insert_child(node, child);
}
return node;
}
static void
sync_statuses(void)
{
PurpleXmlNode *node;
char *data;
if (!statuses_loaded)
{
purple_debug_error("status", "Attempted to save statuses before they "
"were read!\n");
return;
}
node = statuses_to_xmlnode();
data = purple_xmlnode_to_formatted_str(node, NULL);
purple_util_write_data_to_config_file("status.xml", data, -1);
g_free(data);
purple_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 = g_timeout_add_seconds(5, save_cb, NULL);
}
/*********************************************************************
* Reading from disk *
*********************************************************************/
static PurpleSavedStatusSub *
parse_substatus(PurpleXmlNode *substatus)
{
PurpleSavedStatusSub *ret;
PurpleXmlNode *node;
char *data;
ret = g_new0(PurpleSavedStatusSub, 1);
/* Read the account */
node = purple_xmlnode_get_child(substatus, "account");
if (node != NULL)
{
char *acct_name;
const char *protocol;
acct_name = purple_xmlnode_get_data(node);
protocol = purple_xmlnode_get_attrib(node, "protocol");
if ((acct_name != NULL) && (protocol != NULL))
ret->account = purple_accounts_find(acct_name, protocol);
g_free(acct_name);
}
if (ret->account == NULL)
{
g_free(ret);
return NULL;
}
/* Read the state */
node = purple_xmlnode_get_child(substatus, "state");
if ((node != NULL) && ((data = purple_xmlnode_get_data(node)) != NULL))
{
ret->type = purple_status_type_find_with_id(
purple_account_get_status_types(ret->account), data);
g_free(data);
}
if (ret->type == NULL)
{
g_free(ret);
return NULL;
}
/* Read the message */
node = purple_xmlnode_get_child(substatus, "message");
if ((node != NULL) && ((data = purple_xmlnode_get_data(node)) != NULL))
{
ret->message = data;
}
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='aim'>markdoliner</account>
* <state>available</state>
* <message>The ladies man is here to answer your queries.</message>
* </substatus>
* <substatus>
* <account protocol='aim'>giantgraypanda</account>
* <state>away</state>
* <message>A.C. ain't in charge no more.</message>
* </substatus>
* </status>
*
* I know. Moving, huh?
*/
static PurpleSavedStatus *
parse_status(PurpleXmlNode *status)
{
PurpleSavedStatus *ret;
PurpleXmlNode *node;
const char *attrib;
char *data;
int i;
ret = g_new0(PurpleSavedStatus, 1);
attrib = purple_xmlnode_get_attrib(status, "transient");
if (!purple_strequal(attrib, "true"))
{
/* Read the title */
attrib = purple_xmlnode_get_attrib(status, "name");
ret->title = g_strdup(attrib);
}
if (ret->title != NULL)
{
/* Ensure the title is unique */
i = 2;
while (purple_savedstatus_find(ret->title) != NULL)
{
g_free(ret->title);
ret->title = g_strdup_printf("%s %d", attrib, i);
i++;
}
}
/* Read the creation time */
attrib = purple_xmlnode_get_attrib(status, "created");
set_creation_time(ret, (attrib != NULL ? atol(attrib) : 0));
/* Read the last used time */
attrib = purple_xmlnode_get_attrib(status, "lastused");
ret->lastused = (attrib != NULL ? atol(attrib) : 0);
/* Read the usage count */
attrib = purple_xmlnode_get_attrib(status, "usage_count");
ret->usage_count = (attrib != NULL ? atol(attrib) : 0);
/* Read the primitive status type */
node = purple_xmlnode_get_child(status, "state");
if ((node != NULL) && ((data = purple_xmlnode_get_data(node)) != NULL))
{
ret->type = purple_primitive_get_type_from_id(data);
g_free(data);
}
/* Read the message */
node = purple_xmlnode_get_child(status, "message");
if ((node != NULL) && ((data = purple_xmlnode_get_data(node)) != NULL))
{
ret->message = data;
}
/* Read substatuses */
for (node = purple_xmlnode_get_child(status, "substatus"); node != NULL;
node = purple_xmlnode_get_next_twin(node))
{
PurpleSavedStatusSub *new;
new = parse_substatus(node);
if (new != NULL)
ret->substatuses = g_list_prepend(ret->substatuses, new);
}
return ret;
}
/*
* load_statuses:
*
* Read the saved statuses from a file in the Purple user dir.
*
* Returns: TRUE on success, FALSE on failure (if the file can not
* be opened, or if it contains invalid XML).
*/
static void
load_statuses(void)
{
PurpleXmlNode *statuses, *status;
statuses_loaded = TRUE;
statuses = purple_util_read_xml_from_config_file("status.xml", _("saved statuses"));
if (statuses == NULL)
return;
for (status = purple_xmlnode_get_child(statuses, "status"); status != NULL;
status = purple_xmlnode_get_next_twin(status))
{
PurpleSavedStatus *new;
new = parse_status(status);
saved_statuses = g_list_prepend(saved_statuses, new);
}
saved_statuses = g_list_sort(saved_statuses, saved_statuses_sort_func);
purple_xmlnode_free(statuses);
}
/**************************************************************************
* Saved status API
**************************************************************************/
PurpleSavedStatus *
purple_savedstatus_new(const char *title, PurpleStatusPrimitive type)
{
PurpleSavedStatus *status;
/* Make sure we don't already have a saved status with this title. */
if (title != NULL)
g_return_val_if_fail(purple_savedstatus_find(title) == NULL, NULL);
status = g_new0(PurpleSavedStatus, 1);
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();
purple_signal_emit(purple_savedstatuses_get_handle(), "savedstatus-added",
status);
return status;
}
void
purple_savedstatus_set_title(PurpleSavedStatus *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(purple_savedstatus_find(title) == NULL);
g_free(status->title);
status->title = g_strdup(title);
schedule_save();
purple_signal_emit(purple_savedstatuses_get_handle(),
"savedstatus-modified", status);
}
void
purple_savedstatus_set_primitive_type(PurpleSavedStatus *status, PurpleStatusPrimitive type)
{
g_return_if_fail(status != NULL);
status->type = type;
schedule_save();
purple_signal_emit(purple_savedstatuses_get_handle(),
"savedstatus-modified", status);
}
void
purple_savedstatus_set_message(PurpleSavedStatus *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();
purple_signal_emit(purple_savedstatuses_get_handle(),
"savedstatus-modified", status);
}
void
purple_savedstatus_set_substatus(PurpleSavedStatus *saved_status,
const PurpleAccount *account,
const PurpleStatusType *type,
const char *message)
{
PurpleSavedStatusSub *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 = purple_savedstatus_get_substatus(saved_status, account);
if (substatus == NULL)
{
substatus = g_new0(PurpleSavedStatusSub, 1);
substatus->account = (PurpleAccount *)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();
purple_signal_emit(purple_savedstatuses_get_handle(),
"savedstatus-modified", saved_status);
}
void
purple_savedstatus_unset_substatus(PurpleSavedStatus *saved_status,
const PurpleAccount *account)
{
GList *iter;
PurpleSavedStatusSub *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;
}
}
purple_signal_emit(purple_savedstatuses_get_handle(),
"savedstatus-modified", saved_status);
}
/*
* 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
purple_savedstatus_unset_all_substatuses(const PurpleAccount *account,
gpointer user_data)
{
g_return_if_fail(account != NULL);
g_list_foreach(saved_statuses, (GFunc)purple_savedstatus_unset_substatus, account);
}
void
purple_savedstatus_delete_by_status(PurpleSavedStatus *status)
{
time_t creation_time, current, idleaway;
g_return_if_fail(status != NULL);
saved_statuses = g_list_remove(saved_statuses, status);
creation_time = purple_savedstatus_get_creation_time(status);
g_hash_table_remove(creation_times, (gconstpointer)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 = purple_prefs_get_int("/purple/savedstatus/default");
if (current == creation_time)
purple_prefs_set_int("/purple/savedstatus/default", 0);
idleaway = purple_prefs_get_int("/purple/savedstatus/idleaway");
if (idleaway == creation_time)
purple_prefs_set_int("/purple/savedstatus/idleaway", 0);
purple_signal_emit(purple_savedstatuses_get_handle(),
"savedstatus-deleted", status);
}
gboolean
purple_savedstatus_delete(const char *title)
{
PurpleSavedStatus *status;
status = purple_savedstatus_find(title);
if (status == NULL)
return FALSE;
if (purple_savedstatus_get_current() == status)
return FALSE;
purple_savedstatus_delete_by_status(status);
return TRUE;
}
GList *
purple_savedstatuses_get_all(void)
{
return saved_statuses;
}
GList *
purple_savedstatuses_get_popular(unsigned int how_many)
{
GList *popular = NULL;
GList *cur;
unsigned int i;
PurpleSavedStatus *next;
/* Copy 'how_many' elements to a new list. If 'how_many' is 0, then copy all of 'em. */
if (how_many == 0)
how_many = (unsigned int) -1;
i = 0;
cur = saved_statuses;
while ((i < how_many) && (cur != NULL))
{
next = cur->data;
if ((!purple_savedstatus_is_transient(next)
|| purple_savedstatus_get_message(next) != NULL))
{
popular = g_list_prepend(popular, next);
i++;
}
cur = cur->next;
}
popular = g_list_reverse(popular);
return popular;
}
PurpleSavedStatus *
purple_savedstatus_get_current(void)
{
if (purple_savedstatus_is_idleaway())
return purple_savedstatus_get_idleaway();
else
return purple_savedstatus_get_default();
}
PurpleSavedStatus *
purple_savedstatus_get_default()
{
time_t creation_time;
PurpleSavedStatus *saved_status = NULL;
creation_time = purple_prefs_get_int("/purple/savedstatus/default");
if (creation_time != 0)
saved_status = g_hash_table_lookup(creation_times, (gconstpointer)creation_time);
if (saved_status == NULL)
{
/*
* We don't have a current saved status! This is either a new
* Purple user or someone upgrading from Purple 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 = purple_savedstatus_new(NULL, PURPLE_STATUS_AVAILABLE);
purple_prefs_set_int("/purple/savedstatus/default",
purple_savedstatus_get_creation_time(saved_status));
}
return saved_status;
}
PurpleSavedStatus *
purple_savedstatus_get_idleaway()
{
time_t creation_time;
PurpleSavedStatus *saved_status = NULL;
creation_time = purple_prefs_get_int("/purple/savedstatus/idleaway");
if (creation_time != 0)
saved_status = g_hash_table_lookup(creation_times, (gconstpointer)creation_time);
if (saved_status == NULL)
{
/* We don't have a specified "idle" status! Weird. */
saved_status = purple_savedstatus_find_transient_by_type_and_message(
PURPLE_STATUS_AWAY, DEFAULT_AUTOAWAY_MESSAGE);
if (saved_status == NULL)
{
saved_status = purple_savedstatus_new(NULL, PURPLE_STATUS_AWAY);
purple_savedstatus_set_message(saved_status, DEFAULT_AUTOAWAY_MESSAGE);
purple_prefs_set_int("/purple/savedstatus/idleaway",
purple_savedstatus_get_creation_time(saved_status));
}
}
return saved_status;
}
gboolean
purple_savedstatus_is_idleaway()
{
return purple_prefs_get_bool("/purple/savedstatus/isidleaway");
}
void
purple_savedstatus_set_idleaway(gboolean idleaway)
{
GList *accounts, *node;
PurpleSavedStatus *old, *saved_status;
if (purple_savedstatus_is_idleaway() == idleaway)
/* Don't need to do anything */
return;
old = purple_savedstatus_get_current();
saved_status = idleaway ? purple_savedstatus_get_idleaway()
: purple_savedstatus_get_default();
purple_prefs_set_bool("/purple/savedstatus/isidleaway", idleaway);
/* Changing our status makes us un-idle */
if (!idleaway)
purple_idle_touch();
if (idleaway && (purple_savedstatus_get_primitive_type(old) != PURPLE_STATUS_AVAILABLE))
/* Our global status is already "away," so don't change anything */
return;
accounts = purple_accounts_get_all_active();
for (node = accounts; node != NULL; node = node->next)
{
PurpleAccount *account;
PurplePresence *presence;
PurpleStatus *status;
account = node->data;
presence = purple_account_get_presence(account);
status = purple_presence_get_active_status(presence);
if (!idleaway || purple_status_is_available(status))
purple_savedstatus_activate_for_account(saved_status, account);
}
g_list_free(accounts);
purple_signal_emit(purple_savedstatuses_get_handle(), "savedstatus-changed",
saved_status, old);
}
PurpleSavedStatus *
purple_savedstatus_get_startup()
{
time_t creation_time;
PurpleSavedStatus *saved_status = NULL;
creation_time = purple_prefs_get_int("/purple/savedstatus/startup");
if (creation_time != 0)
saved_status = g_hash_table_lookup(creation_times, (gconstpointer)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 = purple_savedstatus_get_current();
}
return saved_status;
}
PurpleSavedStatus *
purple_savedstatus_find(const char *title)
{
GList *iter;
PurpleSavedStatus *status;
g_return_val_if_fail(title != NULL, NULL);
for (iter = saved_statuses; iter != NULL; iter = iter->next)
{
status = (PurpleSavedStatus *)iter->data;
if (purple_strequal(status->title, title))
return status;
}
return NULL;
}
PurpleSavedStatus *
purple_savedstatus_find_by_creation_time(time_t creation_time)
{
GList *iter;
PurpleSavedStatus *status;
for (iter = saved_statuses; iter != NULL; iter = iter->next)
{
status = (PurpleSavedStatus *)iter->data;
if (status->creation_time == creation_time)
return status;
}
return NULL;
}
PurpleSavedStatus *
purple_savedstatus_find_transient_by_type_and_message(PurpleStatusPrimitive type,
const char *message)
{
GList *iter;
PurpleSavedStatus *status;
for (iter = saved_statuses; iter != NULL; iter = iter->next)
{
status = (PurpleSavedStatus *)iter->data;
if ((status->type == type) && purple_savedstatus_is_transient(status) &&
!purple_savedstatus_has_substatuses(status) &&
purple_strequal(status->message, message))
{
return status;
}
}
return NULL;
}
gboolean
purple_savedstatus_is_transient(const PurpleSavedStatus *saved_status)
{
g_return_val_if_fail(saved_status != NULL, TRUE);
return (saved_status->title == NULL);
}
const char *
purple_savedstatus_get_title(const PurpleSavedStatus *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 = purple_savedstatus_get_message(saved_status);
if ((message == NULL) || (*message == '\0'))
{
PurpleStatusPrimitive primitive;
primitive = purple_savedstatus_get_primitive_type(saved_status);
return purple_primitive_get_name_from_type(primitive);
}
else
{
char *stripped;
static char buf[64];
stripped = purple_markup_strip_html(message);
purple_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;
}
}
PurpleStatusPrimitive
purple_savedstatus_get_primitive_type(const PurpleSavedStatus *saved_status)
{
g_return_val_if_fail(saved_status != NULL, PURPLE_STATUS_OFFLINE);
return saved_status->type;
}
const char *
purple_savedstatus_get_message(const PurpleSavedStatus *saved_status)
{
g_return_val_if_fail(saved_status != NULL, NULL);
return saved_status->message;
}
time_t
purple_savedstatus_get_creation_time(const PurpleSavedStatus *saved_status)
{
g_return_val_if_fail(saved_status != NULL, 0);
return saved_status->creation_time;
}
gboolean
purple_savedstatus_has_substatuses(const PurpleSavedStatus *saved_status)
{
g_return_val_if_fail(saved_status != NULL, FALSE);
return (saved_status->substatuses != NULL);
}
PurpleSavedStatusSub *
purple_savedstatus_get_substatus(const PurpleSavedStatus *saved_status,
const PurpleAccount *account)
{
GList *iter;
PurpleSavedStatusSub *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 PurpleStatusType *
purple_savedstatus_substatus_get_status_type(const PurpleSavedStatusSub *substatus)
{
g_return_val_if_fail(substatus != NULL, NULL);
return substatus->type;
}
const char *
purple_savedstatus_substatus_get_message(const PurpleSavedStatusSub *substatus)
{
g_return_val_if_fail(substatus != NULL, NULL);
return substatus->message;
}
void
purple_savedstatus_activate(PurpleSavedStatus *saved_status)
{
GList *accounts, *node;
PurpleSavedStatus *old = purple_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);
purple_prefs_set_int("/purple/savedstatus/default",
purple_savedstatus_get_creation_time(saved_status));
accounts = purple_accounts_get_all_active();
for (node = accounts; node != NULL; node = node->next)
{
PurpleAccount *account;
account = node->data;
purple_savedstatus_activate_for_account(saved_status, account);
}
g_list_free(accounts);
if (purple_savedstatus_is_idleaway()) {
purple_savedstatus_set_idleaway(FALSE);
} else {
purple_signal_emit(purple_savedstatuses_get_handle(), "savedstatus-changed",
saved_status, old);
}
}
void
purple_savedstatus_activate_for_account(const PurpleSavedStatus *saved_status,
PurpleAccount *account)
{
const PurpleStatusType *status_type;
const PurpleSavedStatusSub *substatus;
const char *message = NULL;
g_return_if_fail(saved_status != NULL);
g_return_if_fail(account != NULL);
substatus = purple_savedstatus_get_substatus(saved_status, account);
if (substatus != NULL)
{
status_type = substatus->type;
message = substatus->message;
}
else
{
status_type = purple_account_get_status_type_with_primitive(account, saved_status->type);
if (status_type == NULL)
return;
message = saved_status->message;
}
if ((message != NULL) &&
(purple_status_type_get_attr(status_type, "message")))
{
purple_account_set_status(account, purple_status_type_get_id(status_type),
TRUE, "message", message, NULL);
}
else
{
purple_account_set_status(account, purple_status_type_get_id(status_type),
TRUE, NULL);
}
}
static PurpleSavedStatus *
purple_savedstatus_copy(PurpleSavedStatus *savedstatus)
{
PurpleSavedStatus *savedstatus_copy;
g_return_val_if_fail(savedstatus != NULL, NULL);
savedstatus_copy = g_new(PurpleSavedStatus, 1);
*savedstatus_copy = *savedstatus;
return savedstatus_copy;
}
GType
purple_savedstatus_get_type(void)
{
static GType type = 0;
if (type == 0) {
type = g_boxed_type_register_static("PurpleSavedStatus",
(GBoxedCopyFunc)purple_savedstatus_copy,
(GBoxedFreeFunc)g_free);
}
return type;
}
void *
purple_savedstatuses_get_handle(void)
{
static int handle;
return &handle;
}
void
purple_savedstatuses_init(void)
{
void *handle = purple_savedstatuses_get_handle();
creation_times = g_hash_table_new(g_direct_hash, g_direct_equal);
/*
* Using 0 as the creation_time is a special case.
* If someone calls purple_savedstatus_get_current() or
* purple_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.
*/
purple_prefs_add_none("/purple/savedstatus");
purple_prefs_add_int("/purple/savedstatus/default", 0);
purple_prefs_add_int("/purple/savedstatus/startup", 0);
purple_prefs_add_bool("/purple/savedstatus/startup_current_status", TRUE);
purple_prefs_add_int("/purple/savedstatus/idleaway", 0);
purple_prefs_add_bool("/purple/savedstatus/isidleaway", FALSE);
load_statuses();
purple_signal_register(handle, "savedstatus-changed",
purple_marshal_VOID__POINTER_POINTER, G_TYPE_NONE, 2,
PURPLE_TYPE_SAVEDSTATUS, PURPLE_TYPE_SAVEDSTATUS);
purple_signal_register(handle, "savedstatus-added",
purple_marshal_VOID__POINTER, G_TYPE_NONE, 1,
PURPLE_TYPE_SAVEDSTATUS);
purple_signal_register(handle, "savedstatus-deleted",
purple_marshal_VOID__POINTER, G_TYPE_NONE, 1,
PURPLE_TYPE_SAVEDSTATUS);
purple_signal_register(handle, "savedstatus-modified",
purple_marshal_VOID__POINTER, G_TYPE_NONE, 1,
PURPLE_TYPE_SAVEDSTATUS);
purple_signal_connect(purple_accounts_get_handle(), "account-removed",
handle,
PURPLE_CALLBACK(purple_savedstatus_unset_all_substatuses),
NULL);
}
void
purple_savedstatuses_uninit(void)
{
gpointer handle = purple_savedstatuses_get_handle();
remove_old_transient_statuses();
if (save_timer != 0)
{
g_source_remove(save_timer);
save_timer = 0;
sync_statuses();
}
g_list_free_full(saved_statuses, (GDestroyNotify)free_saved_status);
saved_statuses = NULL;
g_hash_table_destroy(creation_times);
creation_times = NULL;
purple_signals_unregister_by_instance(handle);
purple_signals_disconnect_by_handle(handle);
}