Mercurial > pidgin.yaz
view libgaim/status.c @ 14740:a169177ffa4e
[gaim-migrate @ 17496]
Better error messages, in my opinion. Now we don't need
to worry about defuzzing anything...
committer: Tailor Script <tailor@pidgin.im>
author | Mark Doliner <mark@kingant.net> |
---|---|
date | Tue, 17 Oct 2006 14:16:46 +0000 |
parents | 4df2827fc2eb |
children |
line wrap: on
line source
/** * @file status.c 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 "blist.h" #include "core.h" #include "dbus-maybe.h" #include "debug.h" #include "notify.h" #include "prefs.h" #include "status.h" /** * A type of status. */ struct _GaimStatusType { GaimStatusPrimitive primitive; char *id; char *name; char *primary_attr_id; gboolean saveable; gboolean user_settable; gboolean independent; GList *attrs; }; /** * A status attribute. */ struct _GaimStatusAttr { char *id; char *name; GaimValue *value_type; }; /** * A list of statuses. */ struct _GaimPresence { GaimPresenceContext context; gboolean idle; time_t idle_time; time_t login_time; GList *statuses; GHashTable *status_table; GaimStatus *active_status; union { GaimAccount *account; struct { GaimConversation *conv; char *user; } chat; struct { GaimAccount *account; char *name; size_t ref_count; GList *buddies; } buddy; } u; }; /** * An active status. */ struct _GaimStatus { GaimStatusType *type; GaimPresence *presence; const char *title; gboolean active; GHashTable *attr_values; }; typedef struct { GaimAccount *account; char *name; } GaimStatusBuddyKey; static int primitive_scores[] = { 0, /* unset */ -500, /* offline */ 100, /* available */ -75, /* unavailable */ -50, /* invisible */ -100, /* away */ -200, /* extended away */ -400, /* mobile */ -10, /* idle, special case. */ -5 /* idle time, special case. */ }; static GHashTable *buddy_presences = NULL; #define SCORE_IDLE 8 #define SCORE_IDLE_TIME 9 /************************************************************************** * GaimStatusPrimitive API **************************************************************************/ static struct GaimStatusPrimitiveMap { GaimStatusPrimitive type; const char *id; const char *name; } const status_primitive_map[] = { { GAIM_STATUS_UNSET, "unset", N_("Unset") }, { GAIM_STATUS_OFFLINE, "offline", N_("Offline") }, { GAIM_STATUS_AVAILABLE, "available", N_("Available") }, { GAIM_STATUS_UNAVAILABLE, "unavailable", N_("Unavailable") }, { GAIM_STATUS_INVISIBLE, "invisible", N_("Invisible") }, { GAIM_STATUS_AWAY, "away", N_("Away") }, { GAIM_STATUS_EXTENDED_AWAY, "extended_away", N_("Extended Away") }, { GAIM_STATUS_MOBILE, "mobile", N_("Mobile") } }; const char * gaim_primitive_get_id_from_type(GaimStatusPrimitive type) { int i; for (i = 0; i < GAIM_STATUS_NUM_PRIMITIVES; i++) { if (type == status_primitive_map[i].type) return status_primitive_map[i].id; } return status_primitive_map[0].id; } const char * gaim_primitive_get_name_from_type(GaimStatusPrimitive type) { int i; for (i = 0; i < GAIM_STATUS_NUM_PRIMITIVES; i++) { if (type == status_primitive_map[i].type) return _(status_primitive_map[i].name); } return _(status_primitive_map[0].name); } GaimStatusPrimitive gaim_primitive_get_type_from_id(const char *id) { int i; g_return_val_if_fail(id != NULL, GAIM_STATUS_UNSET); for (i = 0; i < GAIM_STATUS_NUM_PRIMITIVES; i++) { if (!strcmp(id, status_primitive_map[i].id)) return status_primitive_map[i].type; } return status_primitive_map[0].type; } /************************************************************************** * GaimStatusType API **************************************************************************/ GaimStatusType * gaim_status_type_new_full(GaimStatusPrimitive primitive, const char *id, const char *name, gboolean saveable, gboolean user_settable, gboolean independent) { GaimStatusType *status_type; g_return_val_if_fail(primitive != GAIM_STATUS_UNSET, NULL); status_type = g_new0(GaimStatusType, 1); GAIM_DBUS_REGISTER_POINTER(status_type, GaimStatusType); status_type->primitive = primitive; status_type->saveable = saveable; status_type->user_settable = user_settable; status_type->independent = independent; if (id != NULL) status_type->id = g_strdup(id); else status_type->id = g_strdup(gaim_primitive_get_id_from_type(primitive)); if (name != NULL) status_type->name = g_strdup(name); else status_type->name = g_strdup(gaim_primitive_get_name_from_type(primitive)); return status_type; } GaimStatusType * gaim_status_type_new(GaimStatusPrimitive primitive, const char *id, const char *name, gboolean user_settable) { g_return_val_if_fail(primitive != GAIM_STATUS_UNSET, NULL); return gaim_status_type_new_full(primitive, id, name, FALSE, user_settable, FALSE); } GaimStatusType * gaim_status_type_new_with_attrs(GaimStatusPrimitive primitive, const char *id, const char *name, gboolean saveable, gboolean user_settable, gboolean independent, const char *attr_id, const char *attr_name, GaimValue *attr_value, ...) { GaimStatusType *status_type; va_list args; g_return_val_if_fail(primitive != GAIM_STATUS_UNSET, NULL); g_return_val_if_fail(attr_id != NULL, NULL); g_return_val_if_fail(attr_name != NULL, NULL); g_return_val_if_fail(attr_value != NULL, NULL); status_type = gaim_status_type_new_full(primitive, id, name, saveable, user_settable, independent); /* Add the first attribute */ gaim_status_type_add_attr(status_type, attr_id, attr_name, attr_value); va_start(args, attr_value); gaim_status_type_add_attrs_vargs(status_type, args); va_end(args); return status_type; } void gaim_status_type_destroy(GaimStatusType *status_type) { g_return_if_fail(status_type != NULL); g_free(status_type->id); g_free(status_type->name); g_free(status_type->primary_attr_id); g_list_foreach(status_type->attrs, (GFunc)gaim_status_attr_destroy, NULL); g_list_free(status_type->attrs); GAIM_DBUS_UNREGISTER_POINTER(status_type); g_free(status_type); } void gaim_status_type_set_primary_attr(GaimStatusType *status_type, const char *id) { g_return_if_fail(status_type != NULL); g_free(status_type->primary_attr_id); status_type->primary_attr_id = g_strdup(id); } void gaim_status_type_add_attr(GaimStatusType *status_type, const char *id, const char *name, GaimValue *value) { GaimStatusAttr *attr; g_return_if_fail(status_type != NULL); g_return_if_fail(id != NULL); g_return_if_fail(name != NULL); g_return_if_fail(value != NULL); attr = gaim_status_attr_new(id, name, value); status_type->attrs = g_list_append(status_type->attrs, attr); } void gaim_status_type_add_attrs_vargs(GaimStatusType *status_type, va_list args) { const char *id, *name; GaimValue *value; g_return_if_fail(status_type != NULL); while ((id = va_arg(args, const char *)) != NULL) { name = va_arg(args, const char *); g_return_if_fail(name != NULL); value = va_arg(args, GaimValue *); g_return_if_fail(value != NULL); gaim_status_type_add_attr(status_type, id, name, value); } } void gaim_status_type_add_attrs(GaimStatusType *status_type, const char *id, const char *name, GaimValue *value, ...) { va_list args; g_return_if_fail(status_type != NULL); g_return_if_fail(id != NULL); g_return_if_fail(name != NULL); g_return_if_fail(value != NULL); /* Add the first attribute */ gaim_status_type_add_attr(status_type, id, name, value); va_start(args, value); gaim_status_type_add_attrs_vargs(status_type, args); va_end(args); } GaimStatusPrimitive gaim_status_type_get_primitive(const GaimStatusType *status_type) { g_return_val_if_fail(status_type != NULL, GAIM_STATUS_UNSET); return status_type->primitive; } const char * gaim_status_type_get_id(const GaimStatusType *status_type) { g_return_val_if_fail(status_type != NULL, NULL); return status_type->id; } const char * gaim_status_type_get_name(const GaimStatusType *status_type) { g_return_val_if_fail(status_type != NULL, NULL); return status_type->name; } gboolean gaim_status_type_is_saveable(const GaimStatusType *status_type) { g_return_val_if_fail(status_type != NULL, FALSE); return status_type->saveable; } gboolean gaim_status_type_is_user_settable(const GaimStatusType *status_type) { g_return_val_if_fail(status_type != NULL, FALSE); return status_type->user_settable; } gboolean gaim_status_type_is_independent(const GaimStatusType *status_type) { g_return_val_if_fail(status_type != NULL, FALSE); return status_type->independent; } gboolean gaim_status_type_is_exclusive(const GaimStatusType *status_type) { g_return_val_if_fail(status_type != NULL, FALSE); return !status_type->independent; } gboolean gaim_status_type_is_available(const GaimStatusType *status_type) { GaimStatusPrimitive primitive; g_return_val_if_fail(status_type != NULL, FALSE); primitive = gaim_status_type_get_primitive(status_type); return (primitive == GAIM_STATUS_AVAILABLE); } const char * gaim_status_type_get_primary_attr(const GaimStatusType *status_type) { g_return_val_if_fail(status_type != NULL, NULL); return status_type->primary_attr_id; } GaimStatusAttr * gaim_status_type_get_attr(const GaimStatusType *status_type, const char *id) { GList *l; g_return_val_if_fail(status_type != NULL, NULL); g_return_val_if_fail(id != NULL, NULL); for (l = status_type->attrs; l != NULL; l = l->next) { GaimStatusAttr *attr = (GaimStatusAttr *)l->data; if (!strcmp(gaim_status_attr_get_id(attr), id)) return attr; } return NULL; } const GList * gaim_status_type_get_attrs(const GaimStatusType *status_type) { g_return_val_if_fail(status_type != NULL, NULL); return status_type->attrs; } const GaimStatusType * gaim_status_type_find_with_id(GList *status_types, const char *id) { GaimStatusType *status_type; g_return_val_if_fail(id != NULL, NULL); while (status_types != NULL) { status_type = status_types->data; if (!strcmp(id, status_type->id)) return status_type; status_types = status_types->next; } return NULL; } /************************************************************************** * GaimStatusAttr API **************************************************************************/ GaimStatusAttr * gaim_status_attr_new(const char *id, const char *name, GaimValue *value_type) { GaimStatusAttr *attr; g_return_val_if_fail(id != NULL, NULL); g_return_val_if_fail(name != NULL, NULL); g_return_val_if_fail(value_type != NULL, NULL); attr = g_new0(GaimStatusAttr, 1); GAIM_DBUS_REGISTER_POINTER(attr, GaimStatusAttr); attr->id = g_strdup(id); attr->name = g_strdup(name); attr->value_type = value_type; return attr; } void gaim_status_attr_destroy(GaimStatusAttr *attr) { g_return_if_fail(attr != NULL); g_free(attr->id); g_free(attr->name); gaim_value_destroy(attr->value_type); GAIM_DBUS_UNREGISTER_POINTER(attr); g_free(attr); } const char * gaim_status_attr_get_id(const GaimStatusAttr *attr) { g_return_val_if_fail(attr != NULL, NULL); return attr->id; } const char * gaim_status_attr_get_name(const GaimStatusAttr *attr) { g_return_val_if_fail(attr != NULL, NULL); return attr->name; } GaimValue * gaim_status_attr_get_value(const GaimStatusAttr *attr) { g_return_val_if_fail(attr != NULL, NULL); return attr->value_type; } /************************************************************************** * GaimStatus API **************************************************************************/ GaimStatus * gaim_status_new(GaimStatusType *status_type, GaimPresence *presence) { GaimStatus *status; const GList *l; g_return_val_if_fail(status_type != NULL, NULL); g_return_val_if_fail(presence != NULL, NULL); status = g_new0(GaimStatus, 1); GAIM_DBUS_REGISTER_POINTER(status, GaimStatus); status->type = status_type; status->presence = presence; status->attr_values = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, (GDestroyNotify)gaim_value_destroy); for (l = gaim_status_type_get_attrs(status_type); l != NULL; l = l->next) { GaimStatusAttr *attr = (GaimStatusAttr *)l->data; GaimValue *value = gaim_status_attr_get_value(attr); GaimValue *new_value = gaim_value_dup(value); g_hash_table_insert(status->attr_values, g_strdup(gaim_status_attr_get_id(attr)), new_value); } return status; } /* * TODO: If the GaimStatus is in a GaimPresence, then * remove it from the GaimPresence? */ void gaim_status_destroy(GaimStatus *status) { g_return_if_fail(status != NULL); g_hash_table_destroy(status->attr_values); GAIM_DBUS_UNREGISTER_POINTER(status); g_free(status); } static void notify_buddy_status_update(GaimBuddy *buddy, GaimPresence *presence, GaimStatus *old_status, GaimStatus *new_status) { GaimBlistUiOps *ops = gaim_blist_get_ui_ops(); if (gaim_prefs_get_bool("/core/logging/log_system")) { time_t current_time = time(NULL); const char *buddy_alias = gaim_buddy_get_alias(buddy); char *tmp; GaimLog *log; if (old_status != NULL) { tmp = g_strdup_printf(_("%s changed status from %s to %s"), buddy_alias, gaim_status_get_name(old_status), gaim_status_get_name(new_status)); } else { /* old_status == NULL when an independent status is toggled. */ if (gaim_status_is_active(new_status)) { tmp = g_strdup_printf(_("%s is now %s"), buddy_alias, gaim_status_get_name(new_status)); } else { tmp = g_strdup_printf(_("%s is no longer %s"), buddy_alias, gaim_status_get_name(new_status)); } } log = gaim_account_get_log(buddy->account, FALSE); if (log != NULL) { gaim_log_write(log, GAIM_MESSAGE_SYSTEM, buddy_alias, current_time, tmp); } g_free(tmp); } if (ops != NULL && ops->update != NULL) ops->update(gaim_get_blist(), (GaimBlistNode*)buddy); } static void notify_status_update(GaimPresence *presence, GaimStatus *old_status, GaimStatus *new_status) { GaimPresenceContext context = gaim_presence_get_context(presence); if (context == GAIM_PRESENCE_CONTEXT_ACCOUNT) { GaimAccount *account = gaim_presence_get_account(presence); GaimAccountUiOps *ops = gaim_accounts_get_ui_ops(); if (gaim_account_get_enabled(account, gaim_core_get_ui())) gaim_prpl_change_account_status(account, old_status, new_status); if (ops != NULL && ops->status_changed != NULL) { ops->status_changed(account, new_status); } } else if (context == GAIM_PRESENCE_CONTEXT_BUDDY) { const GList *l; for (l = gaim_presence_get_buddies(presence); l != NULL; l = l->next) { notify_buddy_status_update((GaimBuddy *)l->data, presence, old_status, new_status); } } } static void status_has_changed(GaimStatus *status) { GaimPresence *presence; GaimStatus *old_status; presence = gaim_status_get_presence(status); /* * If this status is exclusive, then we must be setting it to "active." * Since we are setting it to active, we want to set the currently * active status to "inactive." */ if (gaim_status_is_exclusive(status)) { old_status = gaim_presence_get_active_status(presence); if (old_status != NULL && (old_status != status)) old_status->active = FALSE; presence->active_status = status; } else old_status = NULL; notify_status_update(presence, old_status, status); } void gaim_status_set_active(GaimStatus *status, gboolean active) { gaim_status_set_active_with_attrs_list(status, active, NULL); } /* * This used to parse the va_list directly, but now it creates a GList * and passes it to gaim_status_set_active_with_attrs_list(). That * function was created because accounts.c needs to pass a GList of * attributes to the status API. */ void gaim_status_set_active_with_attrs(GaimStatus *status, gboolean active, va_list args) { GList *attrs = NULL; const gchar *id; gpointer data; while ((id = va_arg(args, const char *)) != NULL) { attrs = g_list_append(attrs, (char *)id); data = va_arg(args, void *); attrs = g_list_append(attrs, data); } gaim_status_set_active_with_attrs_list(status, active, attrs); g_list_free(attrs); } void gaim_status_set_active_with_attrs_list(GaimStatus *status, gboolean active, const GList *attrs) { gboolean changed = FALSE; const GList *l; GList *specified_attr_ids = NULL; GaimStatusType *status_type; g_return_if_fail(status != NULL); if (!active && gaim_status_is_exclusive(status)) { gaim_debug_error("status", "Cannot deactivate an exclusive status (%s).\n", gaim_status_get_id(status)); return; } if (status->active != active) { changed = TRUE; } status->active = active; /* Set any attributes */ l = attrs; while (l != NULL) { const gchar *id; GaimValue *value; id = l->data; l = l->next; value = gaim_status_get_attr_value(status, id); if (value == NULL) { gaim_debug_warning("status", "The attribute \"%s\" on the status \"%s\" is " "not supported.\n", id, status->type->name); /* Skip over the data and move on to the next attribute */ l = l->next; continue; } specified_attr_ids = g_list_prepend(specified_attr_ids, (gpointer)id); if (value->type == GAIM_TYPE_STRING) { const gchar *string_data = l->data; l = l->next; if (((string_data == NULL) && (value->data.string_data == NULL)) || ((string_data != NULL) && (value->data.string_data != NULL) && !strcmp(string_data, value->data.string_data))) { continue; } gaim_status_set_attr_string(status, id, string_data); changed = TRUE; } else if (value->type == GAIM_TYPE_INT) { int int_data = GPOINTER_TO_INT(l->data); l = l->next; if (int_data == value->data.int_data) continue; gaim_status_set_attr_int(status, id, int_data); changed = TRUE; } else if (value->type == GAIM_TYPE_BOOLEAN) { gboolean boolean_data = GPOINTER_TO_INT(l->data); l = l->next; if (boolean_data == value->data.boolean_data) continue; gaim_status_set_attr_boolean(status, id, boolean_data); changed = TRUE; } else { /* We don't know what the data is--skip over it */ l = l->next; } } /* Reset any unspecified attributes to their default value */ status_type = gaim_status_get_type(status); l = gaim_status_type_get_attrs(status_type); while (l != NULL) { GaimStatusAttr *attr; attr = l->data; if (!g_list_find_custom(specified_attr_ids, attr->id, (GCompareFunc)strcmp)) { GaimValue *default_value; default_value = gaim_status_attr_get_value(attr); if (default_value->type == GAIM_TYPE_STRING) gaim_status_set_attr_string(status, attr->id, gaim_value_get_string(default_value)); else if (default_value->type == GAIM_TYPE_INT) gaim_status_set_attr_int(status, attr->id, gaim_value_get_int(default_value)); else if (default_value->type == GAIM_TYPE_BOOLEAN) gaim_status_set_attr_boolean(status, attr->id, gaim_value_get_boolean(default_value)); changed = TRUE; } l = l->next; } g_list_free(specified_attr_ids); if (!changed) return; status_has_changed(status); } void gaim_status_set_attr_boolean(GaimStatus *status, const char *id, gboolean value) { GaimValue *attr_value; g_return_if_fail(status != NULL); g_return_if_fail(id != NULL); /* Make sure this attribute exists and is the correct type. */ attr_value = gaim_status_get_attr_value(status, id); g_return_if_fail(attr_value != NULL); g_return_if_fail(gaim_value_get_type(attr_value) == GAIM_TYPE_BOOLEAN); gaim_value_set_boolean(attr_value, value); } void gaim_status_set_attr_int(GaimStatus *status, const char *id, int value) { GaimValue *attr_value; g_return_if_fail(status != NULL); g_return_if_fail(id != NULL); /* Make sure this attribute exists and is the correct type. */ attr_value = gaim_status_get_attr_value(status, id); g_return_if_fail(attr_value != NULL); g_return_if_fail(gaim_value_get_type(attr_value) == GAIM_TYPE_INT); gaim_value_set_int(attr_value, value); } void gaim_status_set_attr_string(GaimStatus *status, const char *id, const char *value) { GaimValue *attr_value; g_return_if_fail(status != NULL); g_return_if_fail(id != NULL); /* Make sure this attribute exists and is the correct type. */ attr_value = gaim_status_get_attr_value(status, id); /* This used to be g_return_if_fail, but it's failing a LOT, so * let's generate a log error for now. */ /* g_return_if_fail(attr_value != NULL); */ if (attr_value == NULL) { gaim_debug_error("status", "Attempted to set status attribute '%s' for " "status '%s', which is not legal. Fix " "this!\n", id, gaim_status_type_get_name(gaim_status_get_type(status))); return; } g_return_if_fail(gaim_value_get_type(attr_value) == GAIM_TYPE_STRING); gaim_value_set_string(attr_value, value); } GaimStatusType * gaim_status_get_type(const GaimStatus *status) { g_return_val_if_fail(status != NULL, NULL); return status->type; } GaimPresence * gaim_status_get_presence(const GaimStatus *status) { g_return_val_if_fail(status != NULL, NULL); return status->presence; } const char * gaim_status_get_id(const GaimStatus *status) { g_return_val_if_fail(status != NULL, NULL); return gaim_status_type_get_id(gaim_status_get_type(status)); } const char * gaim_status_get_name(const GaimStatus *status) { g_return_val_if_fail(status != NULL, NULL); return gaim_status_type_get_name(gaim_status_get_type(status)); } gboolean gaim_status_is_independent(const GaimStatus *status) { g_return_val_if_fail(status != NULL, FALSE); return gaim_status_type_is_independent(gaim_status_get_type(status)); } gboolean gaim_status_is_exclusive(const GaimStatus *status) { g_return_val_if_fail(status != NULL, FALSE); return gaim_status_type_is_exclusive(gaim_status_get_type(status)); } gboolean gaim_status_is_available(const GaimStatus *status) { g_return_val_if_fail(status != NULL, FALSE); return gaim_status_type_is_available(gaim_status_get_type(status)); } gboolean gaim_status_is_active(const GaimStatus *status) { g_return_val_if_fail(status != NULL, FALSE); return status->active; } gboolean gaim_status_is_online(const GaimStatus *status) { GaimStatusPrimitive primitive; g_return_val_if_fail( status != NULL, FALSE); primitive = gaim_status_type_get_primitive(gaim_status_get_type(status)); return (primitive != GAIM_STATUS_UNSET && primitive != GAIM_STATUS_OFFLINE); } GaimValue * gaim_status_get_attr_value(const GaimStatus *status, const char *id) { g_return_val_if_fail(status != NULL, NULL); g_return_val_if_fail(id != NULL, NULL); return (GaimValue *)g_hash_table_lookup(status->attr_values, id); } gboolean gaim_status_get_attr_boolean(const GaimStatus *status, const char *id) { const GaimValue *value; g_return_val_if_fail(status != NULL, FALSE); g_return_val_if_fail(id != NULL, FALSE); if ((value = gaim_status_get_attr_value(status, id)) == NULL) return FALSE; g_return_val_if_fail(gaim_value_get_type(value) == GAIM_TYPE_BOOLEAN, FALSE); return gaim_value_get_boolean(value); } int gaim_status_get_attr_int(const GaimStatus *status, const char *id) { const GaimValue *value; g_return_val_if_fail(status != NULL, 0); g_return_val_if_fail(id != NULL, 0); if ((value = gaim_status_get_attr_value(status, id)) == NULL) return 0; g_return_val_if_fail(gaim_value_get_type(value) == GAIM_TYPE_INT, 0); return gaim_value_get_int(value); } const char * gaim_status_get_attr_string(const GaimStatus *status, const char *id) { const GaimValue *value; g_return_val_if_fail(status != NULL, NULL); g_return_val_if_fail(id != NULL, NULL); if ((value = gaim_status_get_attr_value(status, id)) == NULL) return NULL; g_return_val_if_fail(gaim_value_get_type(value) == GAIM_TYPE_STRING, NULL); return gaim_value_get_string(value); } gint gaim_status_compare(const GaimStatus *status1, const GaimStatus *status2) { GaimStatusType *type1, *type2; int score1 = 0, score2 = 0; if ((status1 == NULL && status2 == NULL) || (status1 == status2)) { return 0; } else if (status1 == NULL) return 1; else if (status2 == NULL) return -1; type1 = gaim_status_get_type(status1); type2 = gaim_status_get_type(status2); if (gaim_status_is_active(status1)) score1 = primitive_scores[gaim_status_type_get_primitive(type1)]; if (gaim_status_is_active(status2)) score2 = primitive_scores[gaim_status_type_get_primitive(type2)]; if (score1 > score2) return -1; else if (score1 < score2) return 1; return 0; } /************************************************************************** * GaimPresence API **************************************************************************/ GaimPresence * gaim_presence_new(GaimPresenceContext context) { GaimPresence *presence; g_return_val_if_fail(context != GAIM_PRESENCE_CONTEXT_UNSET, NULL); presence = g_new0(GaimPresence, 1); GAIM_DBUS_REGISTER_POINTER(presence, GaimPresence); presence->context = context; presence->status_table = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL); return presence; } GaimPresence * gaim_presence_new_for_account(GaimAccount *account) { GaimPresence *presence = NULL; g_return_val_if_fail(account != NULL, NULL); presence = gaim_presence_new(GAIM_PRESENCE_CONTEXT_ACCOUNT); presence->u.account = account; presence->statuses = gaim_prpl_get_statuses(account, presence); return presence; } GaimPresence * gaim_presence_new_for_conv(GaimConversation *conv) { GaimPresence *presence; g_return_val_if_fail(conv != NULL, NULL); presence = gaim_presence_new(GAIM_PRESENCE_CONTEXT_CONV); presence->u.chat.conv = conv; /* presence->statuses = gaim_prpl_get_statuses(conv->account, presence); ? */ return presence; } GaimPresence * gaim_presence_new_for_buddy(GaimBuddy *buddy) { GaimPresence *presence; GaimStatusBuddyKey *key; GaimAccount *account; g_return_val_if_fail(buddy != NULL, NULL); account = buddy->account; key = g_new0(GaimStatusBuddyKey, 1); key->account = buddy->account; key->name = g_strdup(buddy->name); presence = g_hash_table_lookup(buddy_presences, key); if (presence == NULL) { presence = gaim_presence_new(GAIM_PRESENCE_CONTEXT_BUDDY); presence->u.buddy.name = g_strdup(buddy->name); presence->u.buddy.account = buddy->account; presence->statuses = gaim_prpl_get_statuses(buddy->account, presence); g_hash_table_insert(buddy_presences, key, presence); } else { g_free(key->name); g_free(key); } presence->u.buddy.ref_count++; presence->u.buddy.buddies = g_list_append(presence->u.buddy.buddies, buddy); return presence; } void gaim_presence_destroy(GaimPresence *presence) { g_return_if_fail(presence != NULL); if (gaim_presence_get_context(presence) == GAIM_PRESENCE_CONTEXT_BUDDY) { GaimStatusBuddyKey key; if(presence->u.buddy.ref_count != 0) return; key.account = presence->u.buddy.account; key.name = presence->u.buddy.name; g_hash_table_remove(buddy_presences, &key); g_free(presence->u.buddy.name); } else if (gaim_presence_get_context(presence) == GAIM_PRESENCE_CONTEXT_CONV) { g_free(presence->u.chat.user); } g_list_foreach(presence->statuses, (GFunc)gaim_status_destroy, NULL); g_list_free(presence->statuses); g_hash_table_destroy(presence->status_table); GAIM_DBUS_UNREGISTER_POINTER(presence); g_free(presence); } /* * TODO: Maybe we should cal gaim_presence_destroy() after we * decrement the ref count? I don't see why we should * make other places do it manually when we can do it here. */ void gaim_presence_remove_buddy(GaimPresence *presence, GaimBuddy *buddy) { g_return_if_fail(presence != NULL); g_return_if_fail(buddy != NULL); g_return_if_fail(gaim_presence_get_context(presence) == GAIM_PRESENCE_CONTEXT_BUDDY); if (g_list_find(presence->u.buddy.buddies, buddy) != NULL) { presence->u.buddy.buddies = g_list_remove(presence->u.buddy.buddies, buddy); presence->u.buddy.ref_count--; } } void gaim_presence_add_status(GaimPresence *presence, GaimStatus *status) { g_return_if_fail(presence != NULL); g_return_if_fail(status != NULL); presence->statuses = g_list_append(presence->statuses, status); g_hash_table_insert(presence->status_table, g_strdup(gaim_status_get_id(status)), status); } void gaim_presence_add_list(GaimPresence *presence, const GList *source_list) { const GList *l; g_return_if_fail(presence != NULL); g_return_if_fail(source_list != NULL); for (l = source_list; l != NULL; l = l->next) gaim_presence_add_status(presence, (GaimStatus *)l->data); } void gaim_presence_set_status_active(GaimPresence *presence, const char *status_id, gboolean active) { GaimStatus *status; g_return_if_fail(presence != NULL); g_return_if_fail(status_id != NULL); status = gaim_presence_get_status(presence, status_id); g_return_if_fail(status != NULL); /* TODO: Should we do the following? */ /* g_return_if_fail(active == status->active); */ if (gaim_status_is_exclusive(status)) { if (!active) { gaim_debug_warning("status", "Attempted to set a non-independent status " "(%s) inactive. Only independent statuses " "can be specifically marked inactive.", status_id); return; } } gaim_status_set_active(status, active); } void gaim_presence_switch_status(GaimPresence *presence, const char *status_id) { gaim_presence_set_status_active(presence, status_id, TRUE); } static void update_buddy_idle(GaimBuddy *buddy, GaimPresence *presence, time_t current_time, gboolean old_idle, gboolean idle) { GaimBlistUiOps *ops = gaim_blist_get_ui_ops(); if (!old_idle && idle) { if (gaim_prefs_get_bool("/core/logging/log_system")) { GaimLog *log = gaim_account_get_log(buddy->account, FALSE); if (log != NULL) { char *tmp = g_strdup_printf(_("%s became idle"), gaim_buddy_get_alias(buddy)); gaim_log_write(log, GAIM_MESSAGE_SYSTEM, gaim_buddy_get_alias(buddy), current_time, tmp); g_free(tmp); } } } else if (old_idle && !idle) { if (gaim_prefs_get_bool("/core/logging/log_system")) { GaimLog *log = gaim_account_get_log(buddy->account, FALSE); if (log != NULL) { char *tmp = g_strdup_printf(_("%s became unidle"), gaim_buddy_get_alias(buddy)); gaim_log_write(log, GAIM_MESSAGE_SYSTEM, gaim_buddy_get_alias(buddy), current_time, tmp); g_free(tmp); } } } if (old_idle != idle) gaim_signal_emit(gaim_blist_get_handle(), "buddy-idle-changed", buddy, old_idle, idle); gaim_contact_invalidate_priority_buddy(gaim_buddy_get_contact(buddy)); /* Should this be done here? It'd perhaps make more sense to * connect to buddy-[un]idle signals and update from there */ if (ops != NULL && ops->update != NULL) ops->update(gaim_get_blist(), (GaimBlistNode *)buddy); } void gaim_presence_set_idle(GaimPresence *presence, gboolean idle, time_t idle_time) { gboolean old_idle; g_return_if_fail(presence != NULL); if (presence->idle == idle && presence->idle_time == idle_time) return; old_idle = presence->idle; presence->idle = idle; presence->idle_time = (idle ? idle_time : 0); if (gaim_presence_get_context(presence) == GAIM_PRESENCE_CONTEXT_BUDDY) { const GList *l; time_t current_time = time(NULL); for (l = gaim_presence_get_buddies(presence); l != NULL; l = l->next) { update_buddy_idle((GaimBuddy *)l->data, presence, current_time, old_idle, idle); } } else if(gaim_presence_get_context(presence) == GAIM_PRESENCE_CONTEXT_ACCOUNT) { GaimAccount *account; GaimConnection *gc; GaimPluginProtocolInfo *prpl_info = NULL; account = gaim_presence_get_account(presence); if (gaim_prefs_get_bool("/core/logging/log_system")) { GaimLog *log = gaim_account_get_log(account, FALSE); if (log != NULL) { char *msg; if (idle) msg = g_strdup_printf(_("+++ %s became idle"), gaim_account_get_username(account)); else msg = g_strdup_printf(_("+++ %s became unidle"), gaim_account_get_username(account)); gaim_log_write(log, GAIM_MESSAGE_SYSTEM, gaim_account_get_username(account), idle_time, msg); g_free(msg); } } gc = gaim_account_get_connection(account); if (gc != NULL && GAIM_CONNECTION_IS_CONNECTED(gc) && gc->prpl != NULL) prpl_info = GAIM_PLUGIN_PROTOCOL_INFO(gc->prpl); if (prpl_info && prpl_info->set_idle) prpl_info->set_idle(gc, (idle ? (time(NULL) - idle_time) : 0)); } } void gaim_presence_set_login_time(GaimPresence *presence, time_t login_time) { g_return_if_fail(presence != NULL); if (presence->login_time == login_time) return; presence->login_time = login_time; } GaimPresenceContext gaim_presence_get_context(const GaimPresence *presence) { g_return_val_if_fail(presence != NULL, GAIM_PRESENCE_CONTEXT_UNSET); return presence->context; } GaimAccount * gaim_presence_get_account(const GaimPresence *presence) { GaimPresenceContext context; g_return_val_if_fail(presence != NULL, NULL); context = gaim_presence_get_context(presence); g_return_val_if_fail(context == GAIM_PRESENCE_CONTEXT_ACCOUNT || context == GAIM_PRESENCE_CONTEXT_BUDDY, NULL); return presence->u.account; } GaimConversation * gaim_presence_get_conversation(const GaimPresence *presence) { g_return_val_if_fail(presence != NULL, NULL); g_return_val_if_fail(gaim_presence_get_context(presence) == GAIM_PRESENCE_CONTEXT_CONV, NULL); return presence->u.chat.conv; } const char * gaim_presence_get_chat_user(const GaimPresence *presence) { g_return_val_if_fail(presence != NULL, NULL); g_return_val_if_fail(gaim_presence_get_context(presence) == GAIM_PRESENCE_CONTEXT_CONV, NULL); return presence->u.chat.user; } const GList * gaim_presence_get_buddies(const GaimPresence *presence) { g_return_val_if_fail(presence != NULL, NULL); g_return_val_if_fail(gaim_presence_get_context(presence) == GAIM_PRESENCE_CONTEXT_BUDDY, NULL); return presence->u.buddy.buddies; } const GList * gaim_presence_get_statuses(const GaimPresence *presence) { g_return_val_if_fail(presence != NULL, NULL); return presence->statuses; } GaimStatus * gaim_presence_get_status(const GaimPresence *presence, const char *status_id) { GaimStatus *status; const GList *l = NULL; g_return_val_if_fail(presence != NULL, NULL); g_return_val_if_fail(status_id != NULL, NULL); /* What's the purpose of this hash table? */ status = (GaimStatus *)g_hash_table_lookup(presence->status_table, status_id); if (status == NULL) { for (l = gaim_presence_get_statuses(presence); l != NULL && status == NULL; l = l->next) { GaimStatus *temp_status = l->data; if (!strcmp(status_id, gaim_status_get_id(temp_status))) status = temp_status; } if (status != NULL) g_hash_table_insert(presence->status_table, g_strdup(gaim_status_get_id(status)), status); } return status; } GaimStatus * gaim_presence_get_active_status(const GaimPresence *presence) { g_return_val_if_fail(presence != NULL, NULL); return presence->active_status; } gboolean gaim_presence_is_available(const GaimPresence *presence) { GaimStatus *status; g_return_val_if_fail(presence != NULL, FALSE); status = gaim_presence_get_active_status(presence); return ((status != NULL && gaim_status_is_available(status)) && !gaim_presence_is_idle(presence)); } gboolean gaim_presence_is_online(const GaimPresence *presence) { GaimStatus *status; g_return_val_if_fail(presence != NULL, FALSE); if ((status = gaim_presence_get_active_status(presence)) == NULL) return FALSE; return gaim_status_is_online(status); } gboolean gaim_presence_is_status_active(const GaimPresence *presence, const char *status_id) { GaimStatus *status; g_return_val_if_fail(presence != NULL, FALSE); g_return_val_if_fail(status_id != NULL, FALSE); status = gaim_presence_get_status(presence, status_id); return (status != NULL && gaim_status_is_active(status)); } gboolean gaim_presence_is_status_primitive_active(const GaimPresence *presence, GaimStatusPrimitive primitive) { GaimStatus *status; GaimStatusType *status_type; g_return_val_if_fail(presence != NULL, FALSE); g_return_val_if_fail(primitive != GAIM_STATUS_UNSET, FALSE); status = gaim_presence_get_active_status(presence); status_type = gaim_status_get_type(status); if (gaim_status_type_get_primitive(status_type) == primitive) return TRUE; return FALSE; } gboolean gaim_presence_is_idle(const GaimPresence *presence) { g_return_val_if_fail(presence != NULL, FALSE); return gaim_presence_is_online(presence) && presence->idle; } time_t gaim_presence_get_idle_time(const GaimPresence *presence) { g_return_val_if_fail(presence != NULL, 0); return presence->idle_time; } time_t gaim_presence_get_login_time(const GaimPresence *presence) { g_return_val_if_fail(presence != NULL, 0); return gaim_presence_is_online(presence) ? presence->login_time : 0; } gint gaim_presence_compare(const GaimPresence *presence1, const GaimPresence *presence2) { gboolean idle1, idle2; time_t idle_time_1, idle_time_2; int score1 = 0, score2 = 0; const GList *l; if (presence1 == presence2) return 0; else if (presence1 == NULL) return 1; else if (presence2 == NULL) return -1; /* Compute the score of the first set of statuses. */ for (l = gaim_presence_get_statuses(presence1); l != NULL; l = l->next) { GaimStatus *status = (GaimStatus *)l->data; GaimStatusType *type = gaim_status_get_type(status); if (gaim_status_is_active(status)) score1 += primitive_scores[gaim_status_type_get_primitive(type)]; } score1 += gaim_account_get_int(gaim_presence_get_account(presence1), "score", 0); /* Compute the score of the second set of statuses. */ for (l = gaim_presence_get_statuses(presence2); l != NULL; l = l->next) { GaimStatus *status = (GaimStatus *)l->data; GaimStatusType *type = gaim_status_get_type(status); if (gaim_status_is_active(status)) score2 += primitive_scores[gaim_status_type_get_primitive(type)]; } score2 += gaim_account_get_int(gaim_presence_get_account(presence2), "score", 0); idle1 = gaim_presence_is_idle(presence1); idle2 = gaim_presence_is_idle(presence2); if (idle1) score1 += primitive_scores[SCORE_IDLE]; if (idle2) score2 += primitive_scores[SCORE_IDLE]; idle_time_1 = time(NULL) - gaim_presence_get_idle_time(presence1); idle_time_2 = time(NULL) - gaim_presence_get_idle_time(presence2); if (idle_time_1 > idle_time_2) score1 += primitive_scores[SCORE_IDLE_TIME]; else if (idle_time_1 < idle_time_2) score2 += primitive_scores[SCORE_IDLE_TIME]; if (score1 < score2) return 1; else if (score1 > score2) return -1; return 0; } /************************************************************************** * Status subsystem **************************************************************************/ static void score_pref_changed_cb(const char *name, GaimPrefType type, gconstpointer value, gpointer data) { int index = GPOINTER_TO_INT(data); primitive_scores[index] = GPOINTER_TO_INT(value); } static guint gaim_buddy_presences_hash(gconstpointer key) { const GaimStatusBuddyKey *me = key; guint ret; char *str; str = g_strdup_printf("%p%s", me->account, me->name); ret = g_str_hash(str); g_free(str); return ret; } static gboolean gaim_buddy_presences_equal(gconstpointer a, gconstpointer b) { GaimStatusBuddyKey *key_a = (GaimStatusBuddyKey *)a; GaimStatusBuddyKey *key_b = (GaimStatusBuddyKey *)b; if(key_a->account == key_b->account && !strcmp(key_a->name, key_b->name)) return TRUE; else return FALSE; } static void gaim_buddy_presences_key_free(gpointer a) { GaimStatusBuddyKey *key = (GaimStatusBuddyKey *)a; g_free(key->name); g_free(key); } void * gaim_status_get_handle(void) { static int handle; return &handle; } void gaim_status_init(void) { void *handle = gaim_status_get_handle; gaim_prefs_add_none("/core/status"); gaim_prefs_add_none("/core/status/scores"); gaim_prefs_add_int("/core/status/scores/offline", primitive_scores[GAIM_STATUS_OFFLINE]); gaim_prefs_add_int("/core/status/scores/available", primitive_scores[GAIM_STATUS_AVAILABLE]); gaim_prefs_add_int("/core/status/scores/invisible", primitive_scores[GAIM_STATUS_INVISIBLE]); gaim_prefs_add_int("/core/status/scores/away", primitive_scores[GAIM_STATUS_AWAY]); gaim_prefs_add_int("/core/status/scores/extended_away", primitive_scores[GAIM_STATUS_EXTENDED_AWAY]); gaim_prefs_add_int("/core/status/scores/idle", primitive_scores[SCORE_IDLE]); gaim_prefs_connect_callback(handle, "/core/status/scores/offline", score_pref_changed_cb, GINT_TO_POINTER(GAIM_STATUS_OFFLINE)); gaim_prefs_connect_callback(handle, "/core/status/scores/available", score_pref_changed_cb, GINT_TO_POINTER(GAIM_STATUS_AVAILABLE)); gaim_prefs_connect_callback(handle, "/core/status/scores/invisible", score_pref_changed_cb, GINT_TO_POINTER(GAIM_STATUS_INVISIBLE)); gaim_prefs_connect_callback(handle, "/core/status/scores/away", score_pref_changed_cb, GINT_TO_POINTER(GAIM_STATUS_AWAY)); gaim_prefs_connect_callback(handle, "/core/status/scores/extended_away", score_pref_changed_cb, GINT_TO_POINTER(GAIM_STATUS_EXTENDED_AWAY)); gaim_prefs_connect_callback(handle, "/core/status/scores/idle", score_pref_changed_cb, GINT_TO_POINTER(SCORE_IDLE)); buddy_presences = g_hash_table_new_full(gaim_buddy_presences_hash, gaim_buddy_presences_equal, gaim_buddy_presences_key_free, NULL); } void gaim_status_uninit(void) { if (buddy_presences != NULL) { g_hash_table_destroy(buddy_presences); buddy_presences = NULL; } }