int BuddyListNode::getBuddyStatusWeight(PurpleBuddy *buddy) const
{
if (!purple_account_is_connected(purple_buddy_get_account(buddy)))
return 0;
PurplePresence *presence = purple_buddy_get_presence(buddy);
PurpleStatus *status = purple_presence_get_active_status(presence);
PurpleStatusType *status_type = purple_status_get_type(status);
PurpleStatusPrimitive prim = purple_status_type_get_primitive(status_type);
switch (prim) {
case PURPLE_STATUS_OFFLINE:
return 0;
default:
return 1;
case PURPLE_STATUS_UNSET:
return 2;
case PURPLE_STATUS_UNAVAILABLE:
return 3;
case PURPLE_STATUS_AWAY:
return 4;
case PURPLE_STATUS_EXTENDED_AWAY:
return 5;
case PURPLE_STATUS_MOBILE:
return 6;
case PURPLE_STATUS_MOOD:
return 7;
case PURPLE_STATUS_TUNE:
return 8;
case PURPLE_STATUS_INVISIBLE:
return 9;
case PURPLE_STATUS_AVAILABLE:
return 10;
}
}
static void purple_set_away( struct im_connection *ic, char *state_txt, char *message )
{
PurpleAccount *pa = ic->proto_data;
GList *status_types = purple_account_get_status_types( pa ), *st;
PurpleStatusType *pst = NULL;
GList *args = NULL;
for( st = status_types; st; st = st->next )
{
pst = st->data;
if( state_txt == NULL &&
purple_status_type_get_primitive( pst ) == PURPLE_STATUS_AVAILABLE )
break;
if( state_txt != NULL &&
g_strcasecmp( state_txt, purple_status_type_get_name( pst ) ) == 0 )
break;
}
if( message && purple_status_type_get_attr( pst, "message" ) )
{
args = g_list_append( args, "message" );
args = g_list_append( args, message );
}
purple_account_set_status_list( pa, st ? purple_status_type_get_id( pst ) : "away",
TRUE, args );
g_list_free( args );
}
static void fb_set_status_p(PurpleAccount *account, PurpleStatus *status)
{
const gchar *message;
gchar *stripped;
FacebookAccount *fba = account->gc->proto_data;
/* if "away" set idle */
if (fba && purple_status_type_get_primitive(purple_status_get_type(status)) == PURPLE_STATUS_AWAY)
{
fba->is_idle = TRUE;
}
//VOXOX - CJC - 2009.07.06 We always want to do this
///* first check that we actually want to set this through Pidgin */
//if (!purple_account_get_bool(account,
// "facebook_set_status_through_pidgin", FALSE))
//{
// return;
//}
//message = purple_status_get_attr_string(status, "message");
//if (message == NULL)
// message = "";
message = purple_status_get_attr_string(status, "message");
if (message == NULL)
//VOXOX CHANGE CJC DO NOT SET MESSAGE IF BLANK
return;
stripped = purple_markup_strip_html(message);
fb_set_status_ok_cb(account->gc, stripped);
g_free(stripped);
}
void jabber_set_status(PurpleAccount *account, PurpleStatus *status)
{
PurpleConnection *gc;
JabberStream *js;
if (!purple_account_is_connected(account))
return;
if (purple_status_is_exclusive(status) && !purple_status_is_active(status)) {
/* An exclusive status can't be deactivated. You should just
* activate some other exclusive status. */
return;
}
gc = purple_account_get_connection(account);
js = purple_connection_get_protocol_data(gc);
/* it's a mood update */
if (purple_status_type_get_primitive(purple_status_get_type(status)) == PURPLE_STATUS_MOOD) {
const char *mood =
purple_status_get_attr_string(status, PURPLE_MOOD_NAME);
const char *mood_text =
purple_status_get_attr_string(status, PURPLE_MOOD_COMMENT);
jabber_mood_set(js, mood, mood_text);
return;
}
jabber_presence_send(js, FALSE);
}
static void buddy_status_changed(PurpleBuddy *buddy, PurpleStatus *old_status, PurpleStatus *status) {
PurplePlugin *prpl;
PurplePluginProtocolInfo *prpl_info = NULL;
char *sip_from = find_sip_user(buddy->name);
int d = hashtable_get_counter(buddy->name);
PurpleStatusPrimitive primitive;
enum purple_publish_basic basic;
enum purple_publish_activity activity;
char *statustext = NULL, *tmp = NULL, *new;
const char *end;
LM_DBG("buddy <%s> has changed status\n", buddy->name);
if ((sip_from) && (d>0)) {
primitive = purple_status_type_get_primitive(purple_status_get_type(status));
primitive_parse(primitive, &basic, &activity);
// char *note = purple_status_get_attr_string(status, "message");
prpl = purple_find_prpl(purple_account_get_protocol_id(buddy->account));
if (prpl != NULL)
prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(prpl);
if (prpl_info && prpl_info->status_text && buddy->account->gc) {
tmp = prpl_info->status_text(buddy);
if(tmp && !g_utf8_validate(tmp, -1, &end)) {
new = g_strndup(tmp, g_utf8_pointer_to_offset(tmp, end));
g_free(tmp);
tmp = new;
}
EntryStatus FromPurpleStatus (PurpleAccount *account, PurpleStatus *status)
{
const auto id = purple_status_get_id (status);
const auto statusType = purple_account_get_status_type (account, id);
const auto message = purple_status_get_attr_string (status, "message");
return EntryStatus (FromPurpleState (purple_status_type_get_primitive (statusType)),
message ? QString::fromUtf8 (message) : QString ());
}
static gboolean purple_status_is_avaliable(PurpleStatus *status)
{
PurpleStatusPrimitive primitive = PURPLE_STATUS_UNSET;
if (!status)
return FALSE;
primitive = purple_status_type_get_primitive(purple_status_get_type(status));
return (primitive == PURPLE_STATUS_AVAILABLE);
}
static VALUE buddy_get_status( VALUE self ) {
PurpleBuddy *buddy = NULL;
PurpleStatus *status = NULL;
PurpleStatusType *type = NULL;
PURPLE_BUDDY( self, buddy );
status = purple_presence_get_active_status( purple_buddy_get_presence( buddy ) );
type = purple_status_get_type( status );
return INT2NUM( purple_status_type_get_primitive( type ) );
}
void flist_purple_set_status(PurpleAccount *account, PurpleStatus *status) {
PurpleConnection *pc = purple_account_get_connection(account);
FListAccount *fla = pc->proto_data;
PurpleStatusType *statusType = purple_status_get_type(status);
GList *statusTypes = flist_status_types(account);
GList *cur = statusTypes;
FListStatus fStatus = FLIST_STATUS_UNKNOWN;
// The status isn't active! bail!
if (!purple_status_is_active(status))
return;
// First, get the presence. If it's idle, we default to idle.
PurplePresence *presence = purple_status_get_presence(status);
if(purple_presence_is_idle(presence)) {
flist_set_status(fla, FLIST_STATUS_IDLE, purple_status_get_attr_string(status, FLIST_STATUS_MESSAGE_KEY));
}
// Alright, not idle. Next, compare StatusType IDs. If it's a match, use that.
while(cur) {
PurpleStatusType *type = cur->data;
if(strcmp(purple_status_type_get_id(type), purple_status_type_get_id(statusType)) == 0){
fStatus = flist_parse_status(purple_status_type_get_id(statusType));
break;
} else {
cur = g_list_next(cur);
}
}
// Found a matching F-list Status. Use it!
if(fStatus != FLIST_STATUS_UNKNOWN) {
flist_set_status(fla, fStatus, purple_status_get_attr_string(status, FLIST_STATUS_MESSAGE_KEY));
} else {
// Alright, seems the status we chose isn't an F-list one. Let's convert to the next best primitive.
switch (purple_status_type_get_primitive(statusType)) {
case PURPLE_STATUS_AWAY:
case PURPLE_STATUS_EXTENDED_AWAY:
flist_set_status(fla, FLIST_STATUS_AWAY, purple_status_get_attr_string(status, FLIST_STATUS_MESSAGE_KEY));
break;
case PURPLE_STATUS_UNAVAILABLE:
flist_set_status(fla, FLIST_STATUS_DND, purple_status_get_attr_string(status, FLIST_STATUS_MESSAGE_KEY));
break;
// Assume AVAILABLE by default if it's not an AWAY/DND status
default:
flist_set_status(fla, FLIST_STATUS_AVAILABLE, purple_status_get_attr_string(status, FLIST_STATUS_MESSAGE_KEY));
}
}
g_list_free(statusTypes);
flist_update_server_status(fla);
}
static GList *purple_away_states( struct im_connection *ic )
{
PurpleAccount *pa = ic->proto_data;
GList *st, *ret = NULL;
for( st = purple_account_get_status_types( pa ); st; st = st->next )
{
PurpleStatusPrimitive prim = purple_status_type_get_primitive( st->data );
if( prim != PURPLE_STATUS_AVAILABLE && prim != PURPLE_STATUS_OFFLINE )
ret = g_list_append( ret, (void*) purple_status_type_get_name( st->data ) );
}
return ret;
}
/*------------------------------------------------------------------------
* The user changed their current presence state.
*
* @param account The MXit account object
* @param status The new status (libPurple status type)
*/
static void mxit_set_status( PurpleAccount* account, PurpleStatus* status )
{
struct MXitSession* session = purple_connection_get_protocol_data( purple_account_get_connection( account ) );
const char* statusid;
int presence;
char* statusmsg1;
char* statusmsg2;
/* Handle mood changes */
if ( purple_status_type_get_primitive( purple_status_get_type( status ) ) == PURPLE_STATUS_MOOD ) {
const char* moodid = purple_status_get_attr_string( status, PURPLE_MOOD_NAME );
int mood;
/* convert the purple mood to a mxit mood */
mood = mxit_convert_mood( moodid );
if ( mood < 0 ) {
/* error, mood not found */
purple_debug_info( MXIT_PLUGIN_ID, "Mood status NOT found! (id = %s)\n", moodid );
return;
}
/* update mood state */
mxit_send_mood( session, mood );
return;
}
/* get the status id (reference: "libpurple/status.h") */
statusid = purple_status_get_id( status );
/* convert the purple status to a mxit status */
presence = mxit_convert_presence( statusid );
if ( presence < 0 ) {
/* error, status not found */
purple_debug_info( MXIT_PLUGIN_ID, "Presence status NOT found! (id = %s)\n", statusid );
return;
}
statusmsg1 = purple_markup_strip_html( purple_status_get_attr_string( status, "message" ) );
statusmsg2 = g_strndup( statusmsg1, CP_MAX_STATUS_MSG );
purple_debug_info( MXIT_PLUGIN_ID, "mxit_set_status: '%s'\n", statusmsg2 );
/* update presence state */
mxit_send_presence( session, presence, statusmsg2 );
g_free( statusmsg1 );
g_free( statusmsg2 );
}
/////////////////////////////////////////////////////////////////////////////
// Determines whether Lock'n'Roll should update the status message when the
// workstation is locked. This returns false if the current status is away
// already, invisible, or offline (fixes bug in 1.0.1)
/////////////////////////////////////////////////////////////////////////////
static gboolean lnr_should_change_message(PurpleAccount *acct)
{
PurpleStatusType *activeStatusType = NULL;
activeStatusType = purple_status_get_type(purple_account_get_active_status(acct));
switch (purple_status_type_get_primitive(activeStatusType))
{
case PURPLE_STATUS_AWAY:
case PURPLE_STATUS_EXTENDED_AWAY:
case PURPLE_STATUS_UNAVAILABLE:
case PURPLE_STATUS_INVISIBLE:
case PURPLE_STATUS_OFFLINE:
return FALSE;
default:
return TRUE;
}
}
bool SpectrumBuddy::getStatus(PurpleStatusPrimitive &status, std::string &statusMessage) {
PurplePresence *pres = purple_buddy_get_presence(m_buddy);
if (pres == NULL)
return false;
PurpleStatus *stat = purple_presence_get_active_status(pres);
if (stat == NULL)
return false;
status = purple_status_type_get_primitive(purple_status_get_type(stat));
const char *message = purple_status_get_attr_string(stat, "message");
if (message != NULL) {
char *stripped = purple_markup_strip_html(message);
statusMessage = std::string(stripped);
g_free(stripped);
}
else
statusMessage = "";
return true;
}
static void plainprpl_close(PurpleConnection *gc)
{
purple_debug_info("plainprpl", "plainprpl_close\n");
PurpleAccount *account;
PurpleBuddy *buddy;
plain_plugin_state *pstate;
plain_buddy_state *bstate;
const char *on_logout;
/* notify other plainprpl accounts */
account = purple_connection_get_account(gc);
pstate = purple_connection_get_protocol_data(gc);
/* Notifiy all buddies that we are gone */
GSList *iter = pstate->all_buddies;
while (iter) {
buddy = iter->data;
bstate = purple_buddy_get_protocol_data(buddy);
PurplePresence *presence = purple_buddy_get_presence(buddy);
PurpleStatus *status = purple_presence_get_active_status(presence);
PurpleStatusType *status_type = purple_status_get_type(status);
PurpleStatusPrimitive status_primitive = purple_status_type_get_primitive(status_type);
if (bstate && status_primitive == PURPLE_STATUS_AVAILABLE) {
send_msg(pstate, bstate, "/bye");
}
iter = iter->next;
}
//remove timers
purple_timeout_remove(pstate->receive_timer);
on_logout = purple_account_get_string(account, "on_logout", NULL);
exec_process(on_logout, NULL, NULL, gc, NULL);
free_plugin_data(pstate);
}
static void _elim_status_changed ( PurpleAccount *account ,
PurpleStatus *status )
{
xmlnode *alist = xnode_new( "alist" );
char *ID = new_elim_id();
fprintf( stderr, "(_elim_status_changed)\n" );
PurpleStatusType *type = purple_status_get_type( status );
PurpleStatusPrimitive statp = purple_status_type_get_primitive( type );
AL_PTR ( alist, "account-uid" , account );
AL_STR ( alist, "account-name", purple_account_get_username ( account ) );
AL_STR ( alist, "im-protocol" , purple_account_get_protocol_id( account ) );
AL_STR ( alist, "status-name" , purple_status_get_name ( status ) );
AL_ENUM( alist, "status-type" , statp, ":status-primitive" );
AL_BOOL( alist, "connected" , purple_account_is_connected ( account ) );
xmlnode *mcall = func_call( "elim-account-status-changed", ID, alist );
g_free( ID );
add_outbound_sexp( mcall );
}
std::string get_account_status()
{
std::string result;
// :fixme:
// atm we get the status only for the first account (assuming the status is
// identical forall active accounts - which may not be true)
GList *p_accounts = purple_accounts_get_all_active();
if (p_accounts) {
PurpleStatus *p_status = purple_account_get_active_status(
reinterpret_cast<PurpleAccount*>(g_list_first(p_accounts)->data));
const char *p_status_text = purple_primitive_get_name_from_type(
purple_status_type_get_primitive(purple_status_get_type(p_status)));
if (p_status_text) {
result = p_status_text;
} else {
result = "Unknown";
}
} else {
// no active accounts -> offline
result = "Offline";
}
return result;
}
/**
* This method motivates Purple's Host (e.g. Pidgin) to update its UI
* by using standard Purple's means of signals and saved statuses.
*
* Thus all UI elements get updated: Status Button with Note, docklet.
* This is ablolutely important as both our status and note can come
* inbound (roaming) or be updated programmatically (e.g. based on our
* calendar data).
*/
void sipe_backend_status_and_note(struct sipe_core_public *sipe_public,
guint activity,
const gchar *message)
{
struct sipe_backend_private *purple_private = sipe_public->backend_private;
PurpleAccount *account = purple_private->account;
const gchar *status_id = sipe_purple_activity_to_token(activity);
PurpleSavedStatus *saved_status;
const PurpleStatusType *acct_status_type =
purple_status_type_find_with_id(account->status_types, status_id);
PurpleStatusPrimitive primitive = purple_status_type_get_primitive(acct_status_type);
saved_status = purple_savedstatus_find_transient_by_type_and_message(primitive, message);
if (saved_status) {
purple_savedstatus_set_substatus(saved_status, account, acct_status_type, message);
}
/* If this type+message is unique then create a new transient saved status
* Ref: gtkstatusbox.c
*/
if (!saved_status) {
GList *tmp;
GList *active_accts = purple_accounts_get_all_active();
saved_status = purple_savedstatus_new(NULL, primitive);
purple_savedstatus_set_message(saved_status, message);
for (tmp = active_accts; tmp != NULL; tmp = tmp->next) {
purple_savedstatus_set_substatus(saved_status,
(PurpleAccount *)tmp->data, acct_status_type, message);
}
g_list_free(active_accts);
}
/* Set the status for each account */
purple_savedstatus_activate(saved_status);
}
char *getColorSchemeString(const char *base_color_scheme, PurpleBuddy *buddy)
{
if (!purple_account_is_connected(purple_buddy_get_account(buddy))) {
return g_strdup_printf("%s_offline", base_color_scheme);
}
PurplePresence *presence = purple_buddy_get_presence(buddy);
PurpleStatus *status = purple_presence_get_active_status(presence);
PurpleStatusType *status_type = purple_status_get_type(status);
PurpleStatusPrimitive prim = purple_status_type_get_primitive(status_type);
switch (prim) {
case PURPLE_STATUS_UNSET:
return g_strdup_printf("%s_offline", base_color_scheme);
case PURPLE_STATUS_OFFLINE:
return g_strdup_printf("%s_offline", base_color_scheme);
case PURPLE_STATUS_AVAILABLE:
return g_strdup_printf("%s_online", base_color_scheme);
case PURPLE_STATUS_UNAVAILABLE:
return g_strdup_printf("%s_na", base_color_scheme);
case PURPLE_STATUS_INVISIBLE:
return g_strdup_printf("%s_na", base_color_scheme);
case PURPLE_STATUS_AWAY:
return g_strdup_printf("%s_away", base_color_scheme);
case PURPLE_STATUS_EXTENDED_AWAY:
return g_strdup_printf("%s_away", base_color_scheme);
case PURPLE_STATUS_MOBILE:
return g_strdup_printf("%s_online", base_color_scheme);
case PURPLE_STATUS_TUNE:
return g_strdup_printf("%s_online", base_color_scheme);
case PURPLE_STATUS_MOOD:
return g_strdup_printf("%s_online", base_color_scheme);
default:
return g_strdup_printf("%s_offline", base_color_scheme);
}
}
static void received_im_msg_cb(PurpleAccount *account, char *who, char *buffer,
PurpleConversation *conv, PurpleMessageFlags flags, void *data) {
// A workaround to avoid skipping of the first message as a result on NULL-conv:
if (conv == NULL) conv = purple_conversation_new(PURPLE_CONV_TYPE_IM,
account, who);
PurpleBuddy *buddy = purple_find_buddy(account, who);
PurplePresence *presence = purple_buddy_get_presence(buddy);
msg_metadata_t msg;
//Get message
msg.text = purple_markup_strip_html(buffer);
msg.remote_username = who;
//LOCAL USER:
msg.local_alias = purple_account_get_alias(account);
msg.local_username = (char *) purple_account_get_name_for_display(account);
//REMOTE USER (Buddy):
//Get buddy alias
msg.remote_alias = purple_buddy_get_alias(buddy);
if(msg.remote_alias == NULL) msg.remote_alias = "";
//Get buddy group
PurpleGroup *group = purple_buddy_get_group(buddy);
//return empty string if not in group
msg.remote_from_group = group != NULL ? purple_group_get_name(group) : "";
//Get protocol ID
msg.protocol_id = purple_account_get_protocol_id(account);
//trim out PROTOCOL_PREFIX (eg.: "prpl-irc" => "irc")
if(!strncmp(msg.protocol_id,PROTOCOL_PREFIX,strlen(PROTOCOL_PREFIX)))
msg.protocol_id += strlen(PROTOCOL_PREFIX);
//Get status
PurpleStatus *status = purple_account_get_active_status(account);
PurpleStatusType *type = purple_status_get_type(status);
//remote
PurpleStatus *r_status = purple_presence_get_active_status(presence);
PurpleStatusType *r_status_type = purple_status_get_type(r_status);
//Get status id
msg.local_status_id = NULL;
msg.local_status_id = purple_primitive_get_id_from_type(
purple_status_type_get_primitive(type));
//remote
msg.remote_status_id = NULL;
msg.remote_status_id = purple_primitive_get_id_from_type(
purple_status_type_get_primitive(r_status_type));
//Get status message
msg.local_status_msg = NULL;
if (purple_status_type_get_attr(type, "message") != NULL) {
msg.local_status_msg = purple_status_get_attr_string(status, "message");
} else {
PurpleSavedStatus *savedstatus = purple_savedstatus_get_current();
if(savedstatus)
msg.local_status_msg = purple_savedstatus_get_message(savedstatus);
}
//remote
msg.remote_status_msg = NULL;
if (purple_status_type_get_attr(r_status_type, "message") != NULL) {
msg.remote_status_msg = purple_status_get_attr_string(r_status, "message");
} else {
msg.remote_status_msg = "";
}
run_lua(conv, msg);
}
/**************************************************************************
* Account signal callbacks
**************************************************************************/
static void
account_status_changed_cb(PurpleAccount *account,
PurpleStatus *old_status, PurpleStatus *new_status)
{
acc_status = purple_status_type_get_primitive( purple_status_get_type(new_status) );
}
static void pipe_handle_subscribe(struct purple_subscribe *subscribe) {
PurpleAccount *account = NULL;
extern_account_t *accounts = NULL;
extern_user_t *users = NULL;
int naccounts = 0, nusers = 0;
int i, j;
PurpleBuddy *buddy = NULL;
int d = 0;
const char *note;
enum purple_publish_basic basic;
enum purple_publish_activity activity;
LM_DBG("calling find_accounts(\"%s\", &naccounts)\n", subscribe->from);
accounts = find_accounts(subscribe->from, &naccounts);
LM_DBG("found %d extra account(s) for <%s>", naccounts, subscribe->from);
LM_DBG("calling find_users(\"%s\", &nusers)\n", subscribe->to);
users = find_users(subscribe->to, &nusers);
LM_DBG("found %d extra user(s) for <%s>", nusers, subscribe->to);
for (i = 0; i < naccounts; i++) {
LM_DBG("calling client_find_account(\"%s\")\n", accounts[i].username);
account = client_find_account(&accounts[i]);
//if ((account) && (purple_account_is_connected(account) || purple_account_is_connecting(account))) {
if (account) {
for (j = 0; j < nusers; j++) {
if (!strcmp(accounts[i].protocol, users[j].protocol)) {
LM_DBG("found matching protocol: %s\n", accounts[i].protocol);
LM_DBG("subscribe expires : %d\n", subscribe->expires);
if (subscribe->expires == 0)
d = hashtable_dec_counter(users[j].username);
else
d = hashtable_inc_counter(users[j].username);
LM_DBG("<%s> is now referenced %d times\n", users[j].username, d);
if (d == 0) {
LM_DBG("<%s> is no more referenced, removing presence...\n", users[j].username);
if (purple_send_sip_publish(subscribe->to, users[j].username, PURPLE_BASIC_CLOSED, 0, NULL) < 0)
LM_ERR("error sending presence for %s", subscribe->to);
else
LM_DBG("presence message sent successfully\n");
}
else {
buddy = purple_find_buddy(account, users[j].username);
if (buddy == NULL) {
LM_DBG("<%s> not found in <%s> buddy list, adding\n", users[j].username, accounts[i].username);
buddy = purple_buddy_new(account, users[j].username, users[j].username);
//purple_blist_add_buddy(buddy, NULL, NULL, NULL);
purple_account_add_buddy(account, buddy);
}
else {
LM_DBG("<%s> found in <%s> buddy list, sending publish\n", users[j].username, accounts[i].username);
PurplePresence *presence = purple_buddy_get_presence(buddy);
PurpleStatus *status = purple_presence_get_active_status(presence);
PurpleStatusType *type = purple_status_get_type(status);
PurpleStatusPrimitive primitive = purple_status_type_get_primitive(type);
note = purple_status_get_attr_string(status, "message");
primitive_parse(primitive, &basic, &activity);
if (purple_send_sip_publish(subscribe->to, users[j].username, basic, activity, note) < 0)
LM_ERR("error sending presence for %s", subscribe->to);
else
LM_DBG("presence message sent successfully\n");
}
}
break;
}
}
}
}
if (accounts)
extern_account_free(accounts, naccounts);
if (users)
extern_user_free(users, nusers);
}
static void purple_init( account_t *acc )
{
PurplePlugin *prpl = purple_plugins_find_with_id( (char*) acc->prpl->data );
PurplePluginProtocolInfo *pi = prpl->info->extra_info;
PurpleAccount *pa;
GList *i, *st;
set_t *s;
char help_title[64];
GString *help;
static gboolean dir_fixed = FALSE;
/* Layer violation coming up: Making an exception for libpurple here.
Dig in the IRC state a bit to get a username. Ideally we should
check if s/he identified but this info doesn't seem *that* important.
It's just that fecking libpurple can't *not* store this shit.
Remember that libpurple is not really meant to be used on public
servers anyway! */
if( !dir_fixed )
{
irc_t *irc = acc->bee->ui_data;
char *dir;
dir = g_strdup_printf( "%s/purple/%s", global.conf->configdir, irc->user->nick );
purple_util_set_user_dir( dir );
g_free( dir );
purple_blist_load();
purple_prefs_load();
dir_fixed = TRUE;
}
help = g_string_new( "" );
g_string_printf( help, "BitlBee libpurple module %s (%s).\n\nSupported settings:",
(char*) acc->prpl->name, prpl->info->name );
if( pi->user_splits )
{
GList *l;
g_string_append_printf( help, "\n* username: Username" );
for( l = pi->user_splits; l; l = l->next )
g_string_append_printf( help, "%c%s",
purple_account_user_split_get_separator( l->data ),
purple_account_user_split_get_text( l->data ) );
}
/* Convert all protocol_options into per-account setting variables. */
for( i = pi->protocol_options; i; i = i->next )
{
PurpleAccountOption *o = i->data;
const char *name;
char *def = NULL;
set_eval eval = NULL;
void *eval_data = NULL;
GList *io = NULL;
GSList *opts = NULL;
name = purple_account_option_get_setting( o );
switch( purple_account_option_get_type( o ) )
{
case PURPLE_PREF_STRING:
def = g_strdup( purple_account_option_get_default_string( o ) );
g_string_append_printf( help, "\n* %s (%s), %s, default: %s",
name, purple_account_option_get_text( o ),
"string", def );
break;
case PURPLE_PREF_INT:
def = g_strdup_printf( "%d", purple_account_option_get_default_int( o ) );
eval = set_eval_int;
g_string_append_printf( help, "\n* %s (%s), %s, default: %s",
name, purple_account_option_get_text( o ),
"integer", def );
break;
case PURPLE_PREF_BOOLEAN:
if( purple_account_option_get_default_bool( o ) )
def = g_strdup( "true" );
else
def = g_strdup( "false" );
eval = set_eval_bool;
g_string_append_printf( help, "\n* %s (%s), %s, default: %s",
name, purple_account_option_get_text( o ),
"boolean", def );
break;
case PURPLE_PREF_STRING_LIST:
def = g_strdup( purple_account_option_get_default_list_value( o ) );
g_string_append_printf( help, "\n* %s (%s), %s, default: %s",
name, purple_account_option_get_text( o ),
"list", def );
g_string_append( help, "\n Possible values: " );
for( io = purple_account_option_get_list( o ); io; io = io->next )
{
PurpleKeyValuePair *kv = io->data;
opts = g_slist_append( opts, kv->value );
/* TODO: kv->value is not a char*, WTF? */
if( strcmp( kv->value, kv->key ) != 0 )
g_string_append_printf( help, "%s (%s), ", (char*) kv->value, kv->key );
else
g_string_append_printf( help, "%s, ", (char*) kv->value );
}
g_string_truncate( help, help->len - 2 );
eval = set_eval_list;
eval_data = opts;
break;
default:
/** No way to talk to the user right now, invent one when
this becomes important.
irc_rootmsg( acc->irc, "Setting with unknown type: %s (%d) Expect stuff to break..\n",
name, purple_account_option_get_type( o ) );
*/
g_string_append_printf( help, "\n* [%s] UNSUPPORTED (type %d)",
name, purple_account_option_get_type( o ) );
name = NULL;
}
if( name != NULL )
{
s = set_add( &acc->set, name, def, eval, acc );
s->flags |= ACC_SET_OFFLINE_ONLY;
s->eval_data = eval_data;
g_free( def );
}
}
g_snprintf( help_title, sizeof( help_title ), "purple %s", (char*) acc->prpl->name );
help_add_mem( &global.help, help_title, help->str );
g_string_free( help, TRUE );
s = set_add( &acc->set, "display_name", NULL, set_eval_display_name, acc );
s->flags |= ACC_SET_ONLINE_ONLY;
if( pi->options & OPT_PROTO_MAIL_CHECK )
{
s = set_add( &acc->set, "mail_notifications", "false", set_eval_bool, acc );
s->flags |= ACC_SET_OFFLINE_ONLY;
}
if( strcmp( prpl->info->name, "Gadu-Gadu" ) == 0 )
s = set_add( &acc->set, "gg_sync_contacts", "true", set_eval_bool, acc );
/* Go through all away states to figure out if away/status messages
are possible. */
pa = purple_account_new( acc->user, (char*) acc->prpl->data );
for( st = purple_account_get_status_types( pa ); st; st = st->next )
{
PurpleStatusPrimitive prim = purple_status_type_get_primitive( st->data );
if( prim == PURPLE_STATUS_AVAILABLE )
{
if( purple_status_type_get_attr( st->data, "message" ) )
acc->flags |= ACC_FLAG_STATUS_MESSAGE;
}
else if( prim != PURPLE_STATUS_OFFLINE )
{
if( purple_status_type_get_attr( st->data, "message" ) )
acc->flags |= ACC_FLAG_AWAY_MESSAGE;
}
}
purple_accounts_remove( pa );
}
