pidgin/pidgin

Make it possible so that libpurple plugins can use functions defined in libpurple/glibcompat.h

4 months ago, Gary Kramlich
797f5a0f602c
Make it possible so that libpurple plugins can use functions defined in libpurple/glibcompat.h

Testing Done:
Compiled on linux and raspberry pi os which fixes that build.

Reviewed at https://reviews.imfreedom.org/r/169/
/* 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 <glib/gi18n-lib.h>
#include "internal.h"
#include "purpleprivate.h"
#include "buddylist.h"
#include "core.h"
#include "debug.h"
#include "notify.h"
#include "prefs.h"
#include "purpleaccountpresence.h"
#include "purplebuddypresence.h"
#include "status.h"
typedef struct _PurpleStatusPrivate PurpleStatusPrivate;
/*
* A type of status.
*/
struct _PurpleStatusType
{
int box_count;
PurpleStatusPrimitive primitive;
char *id;
char *name;
gboolean saveable;
gboolean user_settable;
gboolean independent;
GList *attrs;
};
/*
* A status attribute.
*/
struct _PurpleStatusAttribute
{
char *id;
char *name;
GValue *value_type;
};
/**
* PurpleStatus:
*
* A PurpleStatus can be thought of as an "instance" of a PurpleStatusType.
* If you're familiar with object-oriented programming languages
* then this should be immediately clear. Say, for example, that
* one of your AIM buddies has set himself as "away." You have a
* PurpleBuddy node for this person in your buddy list. Purple wants
* to mark this buddy as "away," so it creates a new PurpleStatus.
* The PurpleStatus has its PurpleStatusType set to the "away" state
* for the oscar protocol. The PurpleStatus also contains the buddy's
* away message. PurpleStatuses are sometimes saved, depending on
* the context. The current PurpleStatuses associated with each of
* your accounts are saved so that the next time you start Purple,
* your accounts will be set to their last known statuses. There
* is also a list of saved statuses that are written to the
* status.xml file. Also, each PurpleStatus has a "saveable" boolean.
* If "saveable" is set to FALSE then the status is NEVER saved.
* All PurpleStatuses should be inside a PurplePresence.
*
* A PurpleStatus is either "independent" or "exclusive."
* Independent statuses can be active or inactive and they don't
* affect anything else. However, you can only have one exclusive
* status per PurplePresence. If you activate one exclusive status,
* then the previous exclusive status is automatically deactivated.
*
* A PurplePresence is like a collection of PurpleStatuses (plus some
* other random info).
*
* See <link linkend="libpurple-presence">Presence API</link>
*/
struct _PurpleStatus
{
GObject parent;
};
/*
* Private data for PurpleStatus
*/
struct _PurpleStatusPrivate
{
PurpleStatusType *status_type;
PurplePresence *presence;
gboolean active;
/*
* The current values of the attributes for this status. The
* key is a string containing the name of the attribute. It is
* a borrowed reference from the list of attrs in the
* PurpleStatusType. The value is a GValue.
*/
GHashTable *attr_values;
};
/* GObject property enums */
enum
{
PROP_0,
PROP_STATUS_TYPE,
PROP_PRESENCE,
PROP_ACTIVE,
PROP_LAST
};
typedef struct
{
PurpleAccount *account;
char *name;
} PurpleStatusBuddyKey;
static GParamSpec *properties[PROP_LAST];
G_DEFINE_TYPE_WITH_PRIVATE(PurpleStatus, purple_status, G_TYPE_OBJECT);
static int primitive_scores[] =
{
0, /* unset */
-500, /* offline */
100, /* available */
-75, /* unavailable */
-50, /* invisible */
-100, /* away */
-200, /* extended away */
-400, /* mobile */
0, /* tune */
0, /* mood */
-10, /* idle, special case. */
-5, /* idle time, special case. */
10 /* Offline messageable */
};
#define SCORE_IDLE 9
#define SCORE_IDLE_TIME 10
#define SCORE_OFFLINE_MESSAGE 11
/**************************************************************************
* PurpleStatusPrimitive API
**************************************************************************/
static struct PurpleStatusPrimitiveMap
{
PurpleStatusPrimitive type;
const char *id;
const char *name;
} const status_primitive_map[] =
{
{ PURPLE_STATUS_UNSET, "unset", N_("Unset") },
{ PURPLE_STATUS_OFFLINE, "offline", N_("Offline") },
{ PURPLE_STATUS_AVAILABLE, "available", N_("Available") },
{ PURPLE_STATUS_UNAVAILABLE, "unavailable", N_("Do not disturb") },
{ PURPLE_STATUS_INVISIBLE, "invisible", N_("Invisible") },
{ PURPLE_STATUS_AWAY, "away", N_("Away") },
{ PURPLE_STATUS_EXTENDED_AWAY, "extended_away", N_("Extended away") },
{ PURPLE_STATUS_MOBILE, "mobile", N_("Mobile") },
{ PURPLE_STATUS_TUNE, "tune", N_("Listening to music"), },
{ PURPLE_STATUS_MOOD, "mood", N_("Feeling") },
};
int *
_purple_statuses_get_primitive_scores(void)
{
return primitive_scores;
}
const char *
purple_primitive_get_id_from_type(PurpleStatusPrimitive type)
{
int i;
for (i = 0; i < PURPLE_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 *
purple_primitive_get_name_from_type(PurpleStatusPrimitive type)
{
int i;
for (i = 0; i < PURPLE_STATUS_NUM_PRIMITIVES; i++)
{
if (type == status_primitive_map[i].type)
return _(status_primitive_map[i].name);
}
return _(status_primitive_map[0].name);
}
PurpleStatusPrimitive
purple_primitive_get_type_from_id(const char *id)
{
int i;
g_return_val_if_fail(id != NULL, PURPLE_STATUS_UNSET);
for (i = 0; i < PURPLE_STATUS_NUM_PRIMITIVES; i++)
{
if (purple_strequal(id, status_primitive_map[i].id))
return status_primitive_map[i].type;
}
return status_primitive_map[0].type;
}
/**************************************************************************
* PurpleStatusType API
**************************************************************************/
PurpleStatusType *
purple_status_type_new_full(PurpleStatusPrimitive primitive, const char *id,
const char *name, gboolean saveable,
gboolean user_settable, gboolean independent)
{
PurpleStatusType *status_type;
g_return_val_if_fail(primitive != PURPLE_STATUS_UNSET, NULL);
status_type = g_new0(PurpleStatusType, 1);
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(purple_primitive_get_id_from_type(primitive));
if (name != NULL)
status_type->name = g_strdup(name);
else
status_type->name = g_strdup(purple_primitive_get_name_from_type(primitive));
return status_type;
}
PurpleStatusType *
purple_status_type_new(PurpleStatusPrimitive primitive, const char *id,
const char *name, gboolean user_settable)
{
g_return_val_if_fail(primitive != PURPLE_STATUS_UNSET, NULL);
return purple_status_type_new_full(primitive, id, name, TRUE,
user_settable, FALSE);
}
static void
status_type_add_attr(PurpleStatusType *status_type, const char *id,
const char *name, GValue *value)
{
PurpleStatusAttribute *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 = purple_status_attribute_new(id, name, value);
status_type->attrs = g_list_append(status_type->attrs, attr);
}
static void
status_type_add_attrs_vargs(PurpleStatusType *status_type, va_list args)
{
const char *id, *name;
GValue *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, GValue *);
g_return_if_fail(value != NULL);
status_type_add_attr(status_type, id, name, value);
}
}
PurpleStatusType *
purple_status_type_new_with_attrs(PurpleStatusPrimitive primitive,
const char *id, const char *name,
gboolean saveable, gboolean user_settable,
gboolean independent, const char *attr_id,
const char *attr_name, GValue *attr_value,
...)
{
PurpleStatusType *status_type;
va_list args;
g_return_val_if_fail(primitive != PURPLE_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 = purple_status_type_new_full(primitive, id, name, saveable,
user_settable, independent);
/* Add the first attribute */
status_type_add_attr(status_type, attr_id, attr_name, attr_value);
va_start(args, attr_value);
status_type_add_attrs_vargs(status_type, args);
va_end(args);
return status_type;
}
void
purple_status_type_destroy(PurpleStatusType *status_type)
{
g_return_if_fail(status_type != NULL);
g_free(status_type->id);
g_free(status_type->name);
g_list_free_full(status_type->attrs,
(GDestroyNotify)purple_status_attribute_destroy);
g_free(status_type);
}
PurpleStatusPrimitive
purple_status_type_get_primitive(const PurpleStatusType *status_type)
{
g_return_val_if_fail(status_type != NULL, PURPLE_STATUS_UNSET);
return status_type->primitive;
}
const char *
purple_status_type_get_id(const PurpleStatusType *status_type)
{
g_return_val_if_fail(status_type != NULL, NULL);
return status_type->id;
}
const char *
purple_status_type_get_name(const PurpleStatusType *status_type)
{
g_return_val_if_fail(status_type != NULL, NULL);
return status_type->name;
}
gboolean
purple_status_type_is_saveable(const PurpleStatusType *status_type)
{
g_return_val_if_fail(status_type != NULL, FALSE);
return status_type->saveable;
}
gboolean
purple_status_type_is_user_settable(const PurpleStatusType *status_type)
{
g_return_val_if_fail(status_type != NULL, FALSE);
return status_type->user_settable;
}
gboolean
purple_status_type_is_independent(const PurpleStatusType *status_type)
{
g_return_val_if_fail(status_type != NULL, FALSE);
return status_type->independent;
}
gboolean
purple_status_type_is_exclusive(const PurpleStatusType *status_type)
{
g_return_val_if_fail(status_type != NULL, FALSE);
return !status_type->independent;
}
gboolean
purple_status_type_is_available(const PurpleStatusType *status_type)
{
PurpleStatusPrimitive primitive;
g_return_val_if_fail(status_type != NULL, FALSE);
primitive = purple_status_type_get_primitive(status_type);
return (primitive == PURPLE_STATUS_AVAILABLE);
}
PurpleStatusAttribute *
purple_status_type_get_attr(const PurpleStatusType *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)
{
PurpleStatusAttribute *attr = (PurpleStatusAttribute *)l->data;
if (purple_strequal(purple_status_attribute_get_id(attr), id))
return attr;
}
return NULL;
}
GList *
purple_status_type_get_attrs(const PurpleStatusType *status_type)
{
g_return_val_if_fail(status_type != NULL, NULL);
return status_type->attrs;
}
const PurpleStatusType *
purple_status_type_find_with_id(GList *status_types, const char *id)
{
PurpleStatusType *status_type;
g_return_val_if_fail(id != NULL, NULL);
while (status_types != NULL)
{
status_type = status_types->data;
if (purple_strequal(id, status_type->id))
return status_type;
status_types = status_types->next;
}
return NULL;
}
/**************************************************************************
* PurpleStatusAttribute API
**************************************************************************/
PurpleStatusAttribute *
purple_status_attribute_new(const char *id, const char *name, GValue *value_type)
{
PurpleStatusAttribute *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(PurpleStatusAttribute, 1);
attr->id = g_strdup(id);
attr->name = g_strdup(name);
attr->value_type = value_type;
return attr;
}
void
purple_status_attribute_destroy(PurpleStatusAttribute *attr)
{
g_return_if_fail(attr != NULL);
g_free(attr->id);
g_free(attr->name);
purple_value_free(attr->value_type);
g_free(attr);
}
const char *
purple_status_attribute_get_id(const PurpleStatusAttribute *attr)
{
g_return_val_if_fail(attr != NULL, NULL);
return attr->id;
}
const char *
purple_status_attribute_get_name(const PurpleStatusAttribute *attr)
{
g_return_val_if_fail(attr != NULL, NULL);
return attr->name;
}
GValue *
purple_status_attribute_get_value(const PurpleStatusAttribute *attr)
{
g_return_val_if_fail(attr != NULL, NULL);
return attr->value_type;
}
/**************************************************************************
* PurpleStatus API
**************************************************************************/
static void
notify_buddy_status_update(PurpleBuddy *buddy, PurplePresence *presence,
PurpleStatus *old_status, PurpleStatus *new_status)
{
if (purple_prefs_get_bool("/purple/logging/log_system"))
{
GDateTime *current_time = g_date_time_new_now_utc();
const char *buddy_alias = purple_buddy_get_alias(buddy);
char *tmp, *logtmp;
PurpleLog *log;
if (old_status != NULL)
{
tmp = g_strdup_printf(_("%s (%s) changed status from %s to %s"), buddy_alias,
purple_buddy_get_name(buddy),
purple_status_get_name(old_status),
purple_status_get_name(new_status));
logtmp = g_markup_escape_text(tmp, -1);
}
else
{
/* old_status == NULL when an independent status is toggled. */
if (purple_status_is_active(new_status))
{
tmp = g_strdup_printf(_("%s (%s) is now %s"), buddy_alias,
purple_buddy_get_name(buddy),
purple_status_get_name(new_status));
logtmp = g_markup_escape_text(tmp, -1);
}
else
{
tmp = g_strdup_printf(_("%s (%s) is no longer %s"), buddy_alias,
purple_buddy_get_name(buddy),
purple_status_get_name(new_status));
logtmp = g_markup_escape_text(tmp, -1);
}
}
log = purple_account_get_log(purple_buddy_get_account(buddy), FALSE);
if (log != NULL)
{
purple_log_write(log, PURPLE_MESSAGE_SYSTEM, buddy_alias,
current_time, logtmp);
}
g_date_time_unref(current_time);
g_free(tmp);
g_free(logtmp);
}
}
static void
notify_status_update(PurplePresence *presence, PurpleStatus *old_status,
PurpleStatus *new_status)
{
if (PURPLE_IS_ACCOUNT_PRESENCE(presence))
{
PurpleAccount *account = purple_account_presence_get_account(
PURPLE_ACCOUNT_PRESENCE(presence));
PurpleAccountUiOps *ops = purple_accounts_get_ui_ops();
if (purple_account_get_enabled(account, purple_core_get_ui()))
purple_protocol_change_account_status(account, old_status, new_status);
if (ops != NULL && ops->status_changed != NULL)
{
ops->status_changed(account, new_status);
}
}
else if (PURPLE_IS_BUDDY_PRESENCE(presence))
{
notify_buddy_status_update(purple_buddy_presence_get_buddy(
PURPLE_BUDDY_PRESENCE(presence)), presence, old_status,
new_status);
}
}
static void
status_has_changed(PurpleStatus *status)
{
PurplePresence *presence;
PurpleStatus *old_status;
presence = purple_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 (purple_status_is_exclusive(status))
{
old_status = purple_presence_get_active_status(presence);
if (old_status != NULL && (old_status != status)) {
PurpleStatusPrivate *priv = purple_status_get_instance_private(old_status);
priv->active = FALSE;
g_object_notify_by_pspec(G_OBJECT(old_status),
properties[PROP_ACTIVE]);
}
}
else
old_status = NULL;
g_object_set(presence, "active-status", status, NULL);
g_object_notify_by_pspec(G_OBJECT(status), properties[PROP_ACTIVE]);
notify_status_update(presence, old_status, status);
}
static void
status_set_attr_boolean(PurpleStatus *status, const char *id,
gboolean value)
{
GValue *attr_value;
g_return_if_fail(PURPLE_IS_STATUS(status));
g_return_if_fail(id != NULL);
/* Make sure this attribute exists and is the correct type. */
attr_value = purple_status_get_attr_value(status, id);
g_return_if_fail(attr_value != NULL);
g_return_if_fail(G_VALUE_TYPE(attr_value) == G_TYPE_BOOLEAN);
g_value_set_boolean(attr_value, value);
}
static void
status_set_attr_int(PurpleStatus *status, const char *id, int value)
{
GValue *attr_value;
g_return_if_fail(PURPLE_IS_STATUS(status));
g_return_if_fail(id != NULL);
/* Make sure this attribute exists and is the correct type. */
attr_value = purple_status_get_attr_value(status, id);
g_return_if_fail(attr_value != NULL);
g_return_if_fail(G_VALUE_TYPE(attr_value) == G_TYPE_INT);
g_value_set_int(attr_value, value);
}
static void
status_set_attr_string(PurpleStatus *status, const char *id,
const char *value)
{
GValue *attr_value;
g_return_if_fail(PURPLE_IS_STATUS(status));
g_return_if_fail(id != NULL);
/* Make sure this attribute exists and is the correct type. */
attr_value = purple_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) {
purple_debug_error("status",
"Attempted to set status attribute '%s' for "
"status '%s', which is not legal. Fix "
"this!\n", id,
purple_status_type_get_name(purple_status_get_status_type(status)));
return;
}
g_return_if_fail(G_VALUE_TYPE(attr_value) == G_TYPE_STRING);
/* XXX: Check if the value has actually changed. If it has, and the status
* is active, should this trigger 'status_has_changed'? */
g_value_set_string(attr_value, value);
}
void
purple_status_set_active(PurpleStatus *status, gboolean active)
{
purple_status_set_active_with_attrs_dict(status, active, NULL);
}
/*
* This used to parse the va_list directly, but now it creates a GList
* and passes it to purple_status_set_active_with_attrs_list(). That
* function was created because account.c needs to pass a GList of
* attributes to the status API.
*/
void
purple_status_set_active_with_attrs(PurpleStatus *status, gboolean active, va_list args)
{
GHashTable *attrs = purple_attrs_from_vargs(args);
purple_status_set_active_with_attrs_dict(status, active, attrs);
g_hash_table_destroy(attrs);
}
void
purple_status_set_active_with_attrs_dict(PurpleStatus *status, gboolean active,
GHashTable *attrs)
{
PurpleStatusPrivate *priv = NULL;
gboolean changed = FALSE;
GHashTableIter iter;
gchar *id;
gpointer data;
GList *l;
GList *specified_attr_ids = NULL;
PurpleStatusType *status_type;
g_return_if_fail(PURPLE_IS_STATUS(status));
g_return_if_fail(attrs != NULL);
priv = purple_status_get_instance_private(status);
if (!active && purple_status_is_exclusive(status))
{
purple_debug_error("status",
"Cannot deactivate an exclusive status (%s).\n",
purple_status_get_id(status));
return;
}
if (priv->active != active)
{
changed = TRUE;
}
priv->active = active;
/* Set any attributes */
g_hash_table_iter_init(&iter, attrs);
while (g_hash_table_iter_next(&iter, (gpointer *)&id, (gpointer *)&data)) {
GValue *value;
value = purple_status_get_attr_value(status, id);
if (value == NULL)
{
purple_debug_warning("status", "The attribute \"%s\" on the status \"%s\" is "
"not supported.\n", id, priv->status_type->name);
/* Skip over the data and move on to the next attribute */
continue;
}
specified_attr_ids = g_list_prepend(specified_attr_ids, (gpointer)id);
if (G_VALUE_TYPE(value) == G_TYPE_STRING)
{
const gchar *string_data = data;
if (purple_strequal(string_data, g_value_get_string(value)))
continue;
status_set_attr_string(status, id, string_data);
changed = TRUE;
}
else if (G_VALUE_TYPE(value) == G_TYPE_INT)
{
int int_data = GPOINTER_TO_INT(data);
if (int_data == g_value_get_int(value))
continue;
status_set_attr_int(status, id, int_data);
changed = TRUE;
}
else if (G_VALUE_TYPE(value) == G_TYPE_BOOLEAN)
{
gboolean boolean_data = GPOINTER_TO_INT(data);
if (boolean_data == g_value_get_boolean(value))
continue;
status_set_attr_boolean(status, id, boolean_data);
changed = TRUE;
}
}
/* Reset any unspecified attributes to their default value */
status_type = purple_status_get_status_type(status);
l = purple_status_type_get_attrs(status_type);
while (l != NULL) {
PurpleStatusAttribute *attr;
attr = l->data;
l = l->next;
if (!g_list_find_custom(specified_attr_ids, attr->id, (GCompareFunc)strcmp)) {
GValue *default_value;
default_value = purple_status_attribute_get_value(attr);
if (G_VALUE_TYPE(default_value) == G_TYPE_STRING) {
const char *cur = purple_status_get_attr_string(status, attr->id);
const char *def = g_value_get_string(default_value);
if (purple_strequal(cur, def)) {
continue;
}
status_set_attr_string(status, attr->id, def);
} else if (G_VALUE_TYPE(default_value) == G_TYPE_INT) {
int cur = purple_status_get_attr_int(status, attr->id);
int def = g_value_get_int(default_value);
if (cur == def)
continue;
status_set_attr_int(status, attr->id, def);
} else if (G_VALUE_TYPE(default_value) == G_TYPE_BOOLEAN) {
gboolean cur = purple_status_get_attr_boolean(status, attr->id);
gboolean def = g_value_get_boolean(default_value);
if (cur == def)
continue;
status_set_attr_boolean(status, attr->id, def);
}
changed = TRUE;
}
}
g_list_free(specified_attr_ids);
if (!changed)
return;
status_has_changed(status);
}
PurpleStatusType *
purple_status_get_status_type(PurpleStatus *status)
{
PurpleStatusPrivate *priv = NULL;
g_return_val_if_fail(PURPLE_IS_STATUS(status), NULL);
priv = purple_status_get_instance_private(status);
return priv->status_type;
}
PurplePresence *
purple_status_get_presence(PurpleStatus *status)
{
PurpleStatusPrivate *priv = NULL;
g_return_val_if_fail(PURPLE_IS_STATUS(status), NULL);
priv = purple_status_get_instance_private(status);
return priv->presence;
}
const char *
purple_status_get_id(PurpleStatus *status)
{
g_return_val_if_fail(PURPLE_IS_STATUS(status), NULL);
return purple_status_type_get_id(purple_status_get_status_type(status));
}
const char *
purple_status_get_name(PurpleStatus *status)
{
g_return_val_if_fail(PURPLE_IS_STATUS(status), NULL);
return purple_status_type_get_name(purple_status_get_status_type(status));
}
gboolean
purple_status_is_independent(PurpleStatus *status)
{
g_return_val_if_fail(PURPLE_IS_STATUS(status), FALSE);
return purple_status_type_is_independent(purple_status_get_status_type(status));
}
gboolean
purple_status_is_exclusive(PurpleStatus *status)
{
g_return_val_if_fail(PURPLE_IS_STATUS(status), FALSE);
return purple_status_type_is_exclusive(purple_status_get_status_type(status));
}
gboolean
purple_status_is_available(PurpleStatus *status)
{
g_return_val_if_fail(PURPLE_IS_STATUS(status), FALSE);
return purple_status_type_is_available(purple_status_get_status_type(status));
}
gboolean
purple_status_is_active(PurpleStatus *status)
{
PurpleStatusPrivate *priv = NULL;
g_return_val_if_fail(PURPLE_IS_STATUS(status), FALSE);
priv = purple_status_get_instance_private(status);
return priv->active;
}
gboolean
purple_status_is_online(PurpleStatus *status)
{
PurpleStatusPrimitive primitive;
g_return_val_if_fail(PURPLE_IS_STATUS(status), FALSE);
primitive = purple_status_type_get_primitive(purple_status_get_status_type(status));
return (primitive != PURPLE_STATUS_UNSET &&
primitive != PURPLE_STATUS_OFFLINE);
}
GValue *
purple_status_get_attr_value(PurpleStatus *status, const char *id)
{
PurpleStatusPrivate *priv = NULL;
g_return_val_if_fail(PURPLE_IS_STATUS(status), NULL);
g_return_val_if_fail(id != NULL, NULL);
priv = purple_status_get_instance_private(status);
return (GValue *)g_hash_table_lookup(priv->attr_values, id);
}
gboolean
purple_status_get_attr_boolean(PurpleStatus *status, const char *id)
{
const GValue *value;
g_return_val_if_fail(PURPLE_IS_STATUS(status), FALSE);
g_return_val_if_fail(id != NULL, FALSE);
if ((value = purple_status_get_attr_value(status, id)) == NULL)
return FALSE;
g_return_val_if_fail(G_VALUE_TYPE(value) == G_TYPE_BOOLEAN, FALSE);
return g_value_get_boolean(value);
}
int
purple_status_get_attr_int(PurpleStatus *status, const char *id)
{
const GValue *value;
g_return_val_if_fail(PURPLE_IS_STATUS(status), 0);
g_return_val_if_fail(id != NULL, 0);
if ((value = purple_status_get_attr_value(status, id)) == NULL)
return 0;
g_return_val_if_fail(G_VALUE_TYPE(value) == G_TYPE_INT, 0);
return g_value_get_int(value);
}
const char *
purple_status_get_attr_string(PurpleStatus *status, const char *id)
{
const GValue *value;
g_return_val_if_fail(PURPLE_IS_STATUS(status), NULL);
g_return_val_if_fail(id != NULL, NULL);
if ((value = purple_status_get_attr_value(status, id)) == NULL)
return NULL;
g_return_val_if_fail(G_VALUE_TYPE(value) == G_TYPE_STRING, NULL);
return g_value_get_string(value);
}
gint
purple_status_compare(PurpleStatus *status1, PurpleStatus *status2)
{
PurpleStatusType *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 = purple_status_get_status_type(status1);
type2 = purple_status_get_status_type(status2);
if (purple_status_is_active(status1))
score1 = primitive_scores[purple_status_type_get_primitive(type1)];
if (purple_status_is_active(status2))
score2 = primitive_scores[purple_status_type_get_primitive(type2)];
if (score1 > score2)
return -1;
else if (score1 < score2)
return 1;
return 0;
}
/**************************************************************************
* GBoxed code for PurpleStatusType
**************************************************************************/
static PurpleStatusType *
purple_status_type_ref(PurpleStatusType *status_type)
{
g_return_val_if_fail(status_type != NULL, NULL);
status_type->box_count++;
return status_type;
}
static void
purple_status_type_unref(PurpleStatusType *status_type)
{
g_return_if_fail(status_type != NULL);
g_return_if_fail(status_type->box_count >= 0);
if (!status_type->box_count--)
purple_status_type_destroy(status_type);
}
GType
purple_status_type_get_type(void)
{
static GType type = 0;
if (type == 0) {
type = g_boxed_type_register_static("PurpleStatusType",
(GBoxedCopyFunc)purple_status_type_ref,
(GBoxedFreeFunc)purple_status_type_unref);
}
return type;
}
/**************************************************************************
* GBoxed code for PurpleStatusAttribute
**************************************************************************/
static PurpleStatusAttribute *
purple_status_attribute_copy(PurpleStatusAttribute *status_attr)
{
g_return_val_if_fail(status_attr != NULL, NULL);
return purple_status_attribute_new(status_attr->id,
status_attr->name,
purple_value_dup(status_attr->value_type));
}
GType
purple_status_attribute_get_type(void)
{
static GType type = 0;
if (type == 0) {
type = g_boxed_type_register_static("PurpleStatusAttribute",
(GBoxedCopyFunc)purple_status_attribute_copy,
(GBoxedFreeFunc)purple_status_attribute_destroy);
}
return type;
}
/**************************************************************************
* GBoxed code for PurpleMood
**************************************************************************/
static PurpleMood *
purple_mood_copy(PurpleMood *mood)
{
PurpleMood *mood_copy;
g_return_val_if_fail(mood != NULL, NULL);
mood_copy = g_new(PurpleMood, 1);
mood_copy->mood = g_strdup(mood->mood);
mood_copy->description = g_strdup(mood->description);
return mood_copy;
}
static void
purple_mood_free(PurpleMood *mood)
{
g_free((gchar *)mood->mood);
g_free((gchar *)mood->description);
g_free(mood);
}
GType
purple_mood_get_type(void)
{
static GType type = 0;
if (type == 0) {
type = g_boxed_type_register_static("PurpleMood",
(GBoxedCopyFunc)purple_mood_copy,
(GBoxedFreeFunc)purple_mood_free);
}
return type;
}
/**************************************************************************
* GObject code
**************************************************************************/
/* Set method for GObject properties */
static void
purple_status_set_property(GObject *obj, guint param_id, const GValue *value,
GParamSpec *pspec)
{
PurpleStatus *status = PURPLE_STATUS(obj);
PurpleStatusPrivate *priv = purple_status_get_instance_private(status);
switch (param_id) {
case PROP_STATUS_TYPE:
priv->status_type = g_value_get_pointer(value);
break;
case PROP_PRESENCE:
priv->presence = g_value_get_object(value);
break;
case PROP_ACTIVE:
purple_status_set_active(status, g_value_get_boolean(value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(obj, param_id, pspec);
break;
}
}
/* Get method for GObject properties */
static void
purple_status_get_property(GObject *obj, guint param_id, GValue *value,
GParamSpec *pspec)
{
PurpleStatus *status = PURPLE_STATUS(obj);
switch (param_id) {
case PROP_STATUS_TYPE:
g_value_set_pointer(value, purple_status_get_status_type(status));
break;
case PROP_PRESENCE:
g_value_set_object(value, purple_status_get_presence(status));
break;
case PROP_ACTIVE:
g_value_set_boolean(value, purple_status_is_active(status));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(obj, param_id, pspec);
break;
}
}
/* GObject initialization function */
static void
purple_status_init(PurpleStatus *status)
{
PurpleStatusPrivate *priv = purple_status_get_instance_private(status);
priv->attr_values =
g_hash_table_new_full(g_str_hash, g_str_equal, NULL,
(GDestroyNotify)purple_value_free);
}
/* Called when done constructing */
static void
purple_status_constructed(GObject *object)
{
GList *l;
PurpleStatusPrivate *priv = purple_status_get_instance_private(PURPLE_STATUS(object));
G_OBJECT_CLASS(purple_status_parent_class)->constructed(object);
for (l = purple_status_type_get_attrs(priv->status_type); l != NULL; l = l->next)
{
PurpleStatusAttribute *attr = (PurpleStatusAttribute *)l->data;
GValue *value = purple_status_attribute_get_value(attr);
GValue *new_value = purple_value_dup(value);
g_hash_table_insert(priv->attr_values,
(char *)purple_status_attribute_get_id(attr),
new_value);
}
}
/*
* GObject finalize function
* TODO: If the PurpleStatus is in a PurplePresence, then
* remove it from the PurplePresence?
*/
static void
purple_status_finalize(GObject *obj)
{
PurpleStatusPrivate *priv = purple_status_get_instance_private(PURPLE_STATUS(obj));
g_hash_table_destroy(priv->attr_values);
G_OBJECT_CLASS(purple_status_parent_class)->finalize(obj);
}
/* Class initializer function */
static void
purple_status_class_init(PurpleStatusClass *klass)
{
GObjectClass *obj_class = G_OBJECT_CLASS(klass);
obj_class->finalize = purple_status_finalize;
obj_class->constructed = purple_status_constructed;
/* Setup properties */
obj_class->get_property = purple_status_get_property;
obj_class->set_property = purple_status_set_property;
properties[PROP_STATUS_TYPE] = g_param_spec_pointer("status-type",
"Status type",
"The PurpleStatusType of the status.",
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
G_PARAM_STATIC_STRINGS);
properties[PROP_PRESENCE] = g_param_spec_object("presence", "Presence",
"The presence that the status belongs to.",
PURPLE_TYPE_PRESENCE,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
G_PARAM_STATIC_STRINGS);
properties[PROP_ACTIVE] = g_param_spec_boolean("active", "Active",
"Whether the status is active or not.", FALSE,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
g_object_class_install_properties(obj_class, PROP_LAST, properties);
}
PurpleStatus *
purple_status_new(PurpleStatusType *status_type, PurplePresence *presence)
{
g_return_val_if_fail(status_type != NULL, NULL);
g_return_val_if_fail(PURPLE_IS_PRESENCE(presence), NULL);
return g_object_new(PURPLE_TYPE_STATUS,
"status-type", status_type,
"presence", presence,
NULL);
}
/**************************************************************************
* Status subsystem
**************************************************************************/
static void
score_pref_changed_cb(const char *name, PurplePrefType type,
gconstpointer value, gpointer data)
{
int index = GPOINTER_TO_INT(data);
primitive_scores[index] = GPOINTER_TO_INT(value);
}
void *
purple_statuses_get_handle(void) {
static int handle;
return &handle;
}
void
purple_statuses_init(void)
{
void *handle = purple_statuses_get_handle();
purple_prefs_add_none("/purple/status");
purple_prefs_add_none("/purple/status/scores");
purple_prefs_add_int("/purple/status/scores/offline",
primitive_scores[PURPLE_STATUS_OFFLINE]);
purple_prefs_add_int("/purple/status/scores/available",
primitive_scores[PURPLE_STATUS_AVAILABLE]);
purple_prefs_add_int("/purple/status/scores/invisible",
primitive_scores[PURPLE_STATUS_INVISIBLE]);
purple_prefs_add_int("/purple/status/scores/away",
primitive_scores[PURPLE_STATUS_AWAY]);
purple_prefs_add_int("/purple/status/scores/extended_away",
primitive_scores[PURPLE_STATUS_EXTENDED_AWAY]);
purple_prefs_add_int("/purple/status/scores/idle",
primitive_scores[SCORE_IDLE]);
purple_prefs_add_int("/purple/status/scores/idle_time",
primitive_scores[SCORE_IDLE_TIME]);
purple_prefs_add_int("/purple/status/scores/offline_msg",
primitive_scores[SCORE_OFFLINE_MESSAGE]);
purple_prefs_connect_callback(handle, "/purple/status/scores/offline",
score_pref_changed_cb,
GINT_TO_POINTER(PURPLE_STATUS_OFFLINE));
purple_prefs_connect_callback(handle, "/purple/status/scores/available",
score_pref_changed_cb,
GINT_TO_POINTER(PURPLE_STATUS_AVAILABLE));
purple_prefs_connect_callback(handle, "/purple/status/scores/invisible",
score_pref_changed_cb,
GINT_TO_POINTER(PURPLE_STATUS_INVISIBLE));
purple_prefs_connect_callback(handle, "/purple/status/scores/away",
score_pref_changed_cb,
GINT_TO_POINTER(PURPLE_STATUS_AWAY));
purple_prefs_connect_callback(handle, "/purple/status/scores/extended_away",
score_pref_changed_cb,
GINT_TO_POINTER(PURPLE_STATUS_EXTENDED_AWAY));
purple_prefs_connect_callback(handle, "/purple/status/scores/idle",
score_pref_changed_cb,
GINT_TO_POINTER(SCORE_IDLE));
purple_prefs_connect_callback(handle, "/purple/status/scores/idle_time",
score_pref_changed_cb,
GINT_TO_POINTER(SCORE_IDLE_TIME));
purple_prefs_connect_callback(handle, "/purple/status/scores/offline_msg",
score_pref_changed_cb,
GINT_TO_POINTER(SCORE_OFFLINE_MESSAGE));
purple_prefs_trigger_callback("/purple/status/scores/offline");
purple_prefs_trigger_callback("/purple/status/scores/available");
purple_prefs_trigger_callback("/purple/status/scores/invisible");
purple_prefs_trigger_callback("/purple/status/scores/away");
purple_prefs_trigger_callback("/purple/status/scores/extended_away");
purple_prefs_trigger_callback("/purple/status/scores/idle");
purple_prefs_trigger_callback("/purple/status/scores/idle_time");
purple_prefs_trigger_callback("/purple/status/scores/offline_msg");
}
void
purple_statuses_uninit(void)
{
purple_prefs_disconnect_by_handle(purple_prefs_get_handle());
}
/**************************************************************************/
/* Helpers */
/**************************************************************************/
GHashTable *
purple_attrs_from_vargs(va_list args)
{
GHashTable *attrs = g_hash_table_new(g_str_hash, g_str_equal);
gchar *id;
while ((id = va_arg(args, gchar *)) != NULL)
{
gpointer data = va_arg(args, gpointer);
g_hash_table_insert(attrs, id, data);
}
return attrs;
}