static void
test_cb(GntWidget *button, gpointer null)
{
PurpleSoundEventID id = GPOINTER_TO_INT(gnt_tree_get_selection_data(GNT_TREE(pref_dialog->events)));
FinchSoundEvent * event = &sounds[id];
char *enabled, *file, *tmpfile, *volpref;
gboolean temp_value;
int volume;
enabled = g_strdup_printf(FINCH_PREFS_ROOT "/sound/profiles/%s/enabled/%s",
finch_sound_get_active_profile(), event->pref);
file = g_strdup_printf(FINCH_PREFS_ROOT "/sound/profiles/%s/file/%s",
finch_sound_get_active_profile(), event->pref);
volpref = g_strdup(make_pref("/volume"));
temp_value = purple_prefs_get_bool(enabled);
tmpfile = g_strdup(purple_prefs_get_path(file));
volume = purple_prefs_get_int(volpref);
purple_prefs_set_path(file, event->file);
if (!temp_value) purple_prefs_set_bool(enabled, TRUE);
purple_prefs_set_int(volpref, gnt_slider_get_value(GNT_SLIDER(pref_dialog->volume)));
purple_sound_play_event(id, NULL);
if (!temp_value) purple_prefs_set_bool(enabled, FALSE);
purple_prefs_set_path(file, tmpfile);
purple_prefs_set_int(volpref, volume);
g_free(enabled);
g_free(file);
g_free(tmpfile);
g_free(volpref);
}
static void blist_save_state() {
if(blist_ab) {
if(purple_prefs_get_bool(PREF_DBLIST_DOCKABLE) && blist_ab->docked) {
purple_prefs_set_int(PREF_DBLIST_HEIGHT, blist_ab->undocked_height);
purple_prefs_set_int(PREF_DBLIST_SIDE, blist_ab->side);
purple_prefs_set_bool(PREF_DBLIST_DOCKED, blist_ab->docked);
} else
purple_prefs_set_bool(PREF_DBLIST_DOCKED, FALSE);
}
}
void
otrg_prefs_global_save(gboolean enabled, gboolean automatic,
gboolean onlyprivate, gboolean avoidloggingotr)
{
if (!purple_prefs_exists("/OTR"))
purple_prefs_add_none("/OTR");
purple_prefs_set_bool("/OTR/enabled", enabled);
purple_prefs_set_bool("/OTR/automatic", automatic);
purple_prefs_set_bool("/OTR/onlyprivate", onlyprivate);
purple_prefs_set_bool("/OTR/avoidloggingotr", avoidloggingotr);
otrg_dialog_resensitize_all();
}
static VALUE init(int argc, VALUE* argv, VALUE self)
{
VALUE debug, path;
const char *prefs_path = NULL;
if( rb_cv_get( self, "@@prefs_path" ) != Qnil ) {
prefs_path = RSTRING_PTR( rb_cv_get( self, "@@prefs_path" ) );
}
rb_scan_args(argc, argv, "02", &debug, &path);
signal(SIGCHLD, SIG_IGN);
signal(SIGPIPE, SIG_IGN);
signal(SIGINT, sighandler);
signal(SIGQUIT, sighandler);
signal(SIGTERM, sighandler);
data_hash_table = g_hash_table_new(NULL, NULL);
fd_hash_table = g_hash_table_new(NULL, NULL);
purple_debug_set_enabled((NIL_P(debug) || debug == Qfalse) ? FALSE : TRUE);
if (!NIL_P(path)) {
Check_Type(path, T_STRING);
purple_util_set_user_dir(RSTRING_PTR(path));
}
purple_core_set_ui_ops(&core_uiops);
purple_eventloop_set_ui_ops(&glib_eventloops);
if (!purple_core_init(UI_ID)) {
rb_raise(rb_eRuntimeError, "libpurple initialization failed");
}
purple_util_set_user_dir( (const char *) prefs_path );
/* Create and load the buddylist. */
purple_set_blist(purple_blist_new());
purple_blist_load();
/* Load the preferences. */
purple_prefs_load();
purple_prefs_set_bool( "/purple/logging/log_ims", FALSE );
purple_prefs_set_bool( "/purple/logging/log_chats", FALSE );
/* Load the pounces. */
purple_pounces_load();
return Qnil;
}
static
void cb_custom_toggled(GtkCellRendererToggle *cell, char *path, gpointer data)
{
GtkTreeIter iter;
GtkTreeModel *model = (GtkTreeModel*) data;
if (gtk_tree_model_get_iter_from_string(model, &iter, path)) {
PurpleAccount *account;
GValue value;
memset(&value, 0, sizeof(value));
gtk_tree_model_get_value(model, &iter, 5, &value);
assert(G_VALUE_HOLDS_POINTER(&value));
account = g_value_get_pointer(&value);
g_value_unset(&value);
gboolean flag;
char pref[STRLEN];
build_pref(pref, PREF_CUSTOM_DISABLED, purple_account_get_username(account), purple_account_get_protocol_name(account));
memset(&value, 0, sizeof(value));
gtk_tree_model_get_value(model, &iter, 3, &value);
assert(G_VALUE_HOLDS_BOOLEAN(&value));
flag = !g_value_get_boolean(&value);
g_value_unset(&value);
gtk_list_store_set(GTK_LIST_STORE(model), &iter, 3, flag, -1);
purple_prefs_set_bool(pref, flag);
if (flag) {
set_status(account, "", 0);
}
}
}
static gboolean plugin_load(PurplePlugin *plugin)
{
void *conv_handle;
PurpleConversationUiOps *ui_ops;
purple_prefs_set_bool(PURPLE_NICKCHANGE_PREF, FALSE);
userstable = g_hash_table_new_full((GHashFunc)joinpart_key_hash,
(GEqualFunc)joinpart_key_equal,
(GDestroyNotify)joinpart_key_destroy,
g_free);
conv_handle = purple_conversations_get_handle();
//purple_signal_connect(conv_handle, "chat-buddy-joining", plugin, PURPLE_CALLBACK(chat_buddy_joining_cb), userstable);
//purple_signal_connect(conv_handle, "chat-buddy-leaving", plugin, PURPLE_CALLBACK(chat_buddy_leaving_cb), userstable);
purple_signal_connect(conv_handle, "received-chat-msg", plugin, PURPLE_CALLBACK(received_chat_msg_cb), userstable);
//purple_prefs_connect_callback(plugin, const char *name, PurplePrefCallback cb, gpointer data)
//Attempt overriding the global UI ops
ui_ops = pidgin_conversations_get_conv_ui_ops();
/* Cleanup every 5 minutes */
clean_user_timeout = purple_timeout_add_seconds(60 * 5, (GSourceFunc)clean_users_hash, userstable);
if (ui_ops) {
orig_chat_rename_user = ui_ops->chat_rename_user;
ui_ops->chat_rename_user = nickchange_chat_rename_user;
} else {
//TODO make it work for !Pidgin too
return FALSE;
}
return TRUE;
}
static gboolean
plugin_unload(PurplePlugin *plugin, GError **error)
{
purple_prefs_set_bool(PIDGIN_PREFS_ROOT "/webview/inspector_enabled", FALSE);
return TRUE;
}
static void
toggle_keep_open_cb(GtkWidget *w, PidginXferDialog *dialog)
{
dialog->keep_open = !dialog->keep_open;
purple_prefs_set_bool(PIDGIN_PREFS_ROOT "/filetransfer/keep_open",
dialog->keep_open);
}
static void
toggle_clear_finished_cb(GtkWidget *w, PidginXferDialog *dialog)
{
dialog->auto_clear = !dialog->auto_clear;
purple_prefs_set_bool(PIDGIN_PREFS_ROOT "/filetransfer/clear_finished",
dialog->auto_clear);
}
/**************************************************************************
* Callbacks
**************************************************************************/
static void
toggle_keep_open_cb(GntWidget *w)
{
xfer_dialog->keep_open = !xfer_dialog->keep_open;
purple_prefs_set_bool("/finch/filetransfer/keep_open",
xfer_dialog->keep_open);
}
static void
alert_config_cb(GtkWidget *widget, gpointer data)
{
gboolean on = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
purple_prefs_set_bool("/plugins/gtk/unity/alert_chat_nick", on);
alert_chat_nick = on;
}
static void
pref_update(GtkWidget *widget, char *pref)
{
if (purple_prefs_get_type(pref) == PURPLE_PREF_INT)
purple_prefs_set_int(pref, gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(widget)));
if (purple_prefs_get_type(pref) == PURPLE_PREF_BOOLEAN)
purple_prefs_set_bool(pref, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)));
}
void
action_toggle_status(PurplePluginAction *action)
{
gboolean flag = !purple_prefs_get_bool("/plugins/core/musictracker/bool_disabled");
purple_prefs_set_bool("/plugins/core/musictracker/bool_disabled", flag);
if (flag)
set_userstatus_for_active_accounts("", 0);
}
static
void cb_filter_toggled(GtkToggleButton *button, gpointer data)
{
gboolean state = gtk_toggle_button_get_active(button);
purple_prefs_set_bool(PREF_FILTER_ENABLE, state);
gtk_widget_set_sensitive(filter_list, state);
gtk_widget_set_sensitive(filter_mask, state);
}
static void set_blist_trans(GtkWidget *w, const char *pref) {
gboolean enabled = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(w));
purple_prefs_set_bool(pref, enabled);
if (blist) {
set_wintrans(blist, purple_prefs_get_int(OPT_WINTRANS_BL_ALPHA),
purple_prefs_get_bool(OPT_WINTRANS_BL_ENABLED),
purple_prefs_get_bool(OPT_WINTRANS_IM_ONTOP));
}
}
/* Save the global OTR UI options */
static void otrg_gtk_ui_global_options_save(gboolean showotrbutton)
{
if (! purple_prefs_exists("/OTR")) {
purple_prefs_add_none("/OTR");
}
if (! purple_prefs_exists("/OTR/showotrbutton")) {
purple_prefs_add_bool("/OTR/showotrbutton", showotrbutton);
}
purple_prefs_set_bool("/OTR/showotrbutton", showotrbutton);
}
/* General callbacks from main preferences */
static void logstats_response_cb (GtkDialog *dialog, gint id,
GtkWidget *widget)
{
purple_prefs_set_bool (
"/plugins/gtk/autoprofile/components/logstat/enabled", TRUE);
logstats_load (NULL);
gtk_widget_set_sensitive (widget, TRUE);
gtk_widget_destroy (GTK_WIDGET(dialog));
}
xmlnode * _h_elim_set_prefs ( const char *name ,
const char *id ,
SEXP_VALUE *args ,
gpointer data )
{
ASSERT_ALISTP( args, id, name );
elim_ping();
xmlnode *rval = xnode_new( "alist" );
xmlnode *set = xnode_new( "alist" );
GHashTable *prefs = ALIST_VAL_ALIST( args, "prefs" );
SEXP_VALUE *PREFS = ALIST_VAL ( args, "prefs" );
AL_NODE( rval, "prefs", set );
fprintf( stderr, "hash: %p; sexp: %p\n", prefs, PREFS );
if( prefs )
{
GList *key = NULL;
GList *keys = g_hash_table_get_keys( prefs );
fprintf( stderr, "keys: %p", keys );
for( key = keys; key; key = key->next )
{
gboolean done = TRUE;
const char *pref = key->data;
PurplePrefType type = purple_prefs_get_type( pref );
switch( type )
{
case PURPLE_PREF_BOOLEAN:
purple_prefs_set_bool ( pref, ALIST_VAL_BOOL( PREFS, pref ) );
break;
case PURPLE_PREF_INT:
purple_prefs_set_int ( pref, ALIST_VAL_INT ( PREFS, pref ) );
break;
case PURPLE_PREF_STRING:
purple_prefs_set_string( pref, ALIST_VAL_STR ( PREFS, pref ) );
break;
case PURPLE_PREF_PATH:
purple_prefs_set_path ( pref, ALIST_VAL_STR ( PREFS, pref ) );
break;
default:
done = FALSE;
}
AL_BOOL( set, pref, done );
}
g_list_free( keys );
}
sexp_val_free( args );
return response_value( 0, id, name, rval );
}
static void
type_toggle_cb(GtkWidget *widget, gpointer data)
{
gboolean on = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
gchar pref[256];
g_snprintf(pref, sizeof(pref), "/plugins/gtk/X11/notify/%s",
(char *)data);
purple_prefs_set_bool(pref, on);
}
void IM::setVoicedBuddies(bool enabled)
{
if(hasVoicedBuddies() != enabled)
{
map<string, Account> accs = getAccountsList();
purple_prefs_set_bool("/minbif/voiced_buddies", enabled);
for(map<string, Account>::iterator it = accs.begin(); it != accs.end(); ++it)
it->second.updatedAllBuddies();
}
}
static void
save_cb(GntWidget *button, gpointer win)
{
GList * itr;
purple_prefs_set_string(make_pref("/method"), gnt_combo_box_get_selected_data(GNT_COMBO_BOX(pref_dialog->method)));
purple_prefs_set_path(make_pref("/command"), gnt_entry_get_text(GNT_ENTRY(pref_dialog->command)));
purple_prefs_set_bool(make_pref("/conv_focus"), gnt_check_box_get_checked(GNT_CHECK_BOX(pref_dialog->conv_focus)));
purple_prefs_set_int("/purple/sound/while_status", GPOINTER_TO_INT(gnt_combo_box_get_selected_data(GNT_COMBO_BOX(pref_dialog->while_status))));
for (itr = gnt_tree_get_rows(GNT_TREE(pref_dialog->events)); itr; itr = itr->next) {
FinchSoundEvent * event = &sounds[GPOINTER_TO_INT(itr->data)];
char * filepref = g_strdup_printf(FINCH_PREFS_ROOT "/sound/profiles/%s/file/%s", finch_sound_get_active_profile(), event->pref);
char * boolpref = g_strdup_printf(FINCH_PREFS_ROOT "/sound/profiles/%s/enabled/%s", finch_sound_get_active_profile(), event->pref);
purple_prefs_set_bool(boolpref, gnt_tree_get_choice(GNT_TREE(pref_dialog->events), itr->data));
purple_prefs_set_path(filepref, event->file ? event->file : "");
g_free(filepref);
g_free(boolpref);
}
gnt_widget_destroy(GNT_WIDGET(win));
}
void finch_request_save_in_prefs(gpointer null, PurpleRequestFields *allfields)
{
GList *list;
for (list = purple_request_fields_get_groups(allfields); list; list = list->next) {
PurpleRequestFieldGroup *group = list->data;
GList *fields = purple_request_field_group_get_fields(group);
for (; fields ; fields = fields->next) {
PurpleRequestField *field = fields->data;
PurpleRequestFieldType type = purple_request_field_get_type(field);
PurplePrefType pt;
gpointer val = NULL;
const char *id = purple_request_field_get_id(field);
switch (type) {
case PURPLE_REQUEST_FIELD_LIST:
val = purple_request_field_list_get_selected(field)->data;
break;
case PURPLE_REQUEST_FIELD_BOOLEAN:
val = GINT_TO_POINTER(purple_request_field_bool_get_value(field));
break;
case PURPLE_REQUEST_FIELD_INTEGER:
val = GINT_TO_POINTER(purple_request_field_int_get_value(field));
break;
case PURPLE_REQUEST_FIELD_STRING:
val = (gpointer)purple_request_field_string_get_value(field);
break;
default:
break;
}
pt = purple_prefs_get_type(id);
switch (pt) {
case PURPLE_PREF_INT:
{
long int tmp = GPOINTER_TO_INT(val);
if (type == PURPLE_REQUEST_FIELD_LIST) /* Lists always return string */
sscanf(val, "%ld", &tmp);
purple_prefs_set_int(id, (gint)tmp);
break;
}
case PURPLE_PREF_BOOLEAN:
purple_prefs_set_bool(id, GPOINTER_TO_INT(val));
break;
case PURPLE_PREF_STRING:
purple_prefs_set_string(id, val);
break;
default:
break;
}
}
}
}
static void
toggle_clear_finished_cb(GntWidget *w)
{
xfer_dialog->auto_clear = !xfer_dialog->auto_clear;
purple_prefs_set_bool("/finch/filetransfer/clear_finished",
xfer_dialog->auto_clear);
if (xfer_dialog->auto_clear) {
GList *iter = purple_xfers_get_all();
while (iter) {
PurpleXfer *xfer = iter->data;
iter = iter->next;
if (purple_xfer_is_completed(xfer) || purple_xfer_is_canceled(xfer))
finch_xfer_dialog_remove_xfer(xfer);
}
}
}
static void update_convs_wintrans(GtkWidget *toggle_btn, const char *pref) {
purple_prefs_set_bool(pref, gtk_toggle_button_get_active(
GTK_TOGGLE_BUTTON(toggle_btn)));
if (purple_prefs_get_bool(OPT_WINTRANS_IM_ENABLED)) {
GList *wins;
for (wins = pidgin_conv_windows_get_list(); wins; wins = wins->next) {
PidginWindow *win = wins->data;
set_conv_window_trans(NULL, win);
}
if (!purple_prefs_get_bool(OPT_WINTRANS_IM_SLIDER))
remove_sliders();
}
else
remove_convs_wintrans(FALSE);
}
void
purple_prefs_rename_boolean_toggle(const char *oldname, const char *newname)
{
struct purple_pref *oldpref, *newpref;
oldpref = find_pref(oldname);
/* it's already been renamed, call off the cats */
if(!oldpref)
return;
if (oldpref->type != PURPLE_PREF_BOOLEAN)
{
purple_debug_error("prefs", "Unable to rename %s to %s: old pref not a boolean\n", oldname, newname);
return;
}
if (oldpref->first_child != NULL) /* can't rename parents */
{
purple_debug_error("prefs", "Unable to rename %s to %s: can't rename parents\n", oldname, newname);
return;
}
newpref = find_pref(newname);
if (newpref == NULL)
{
purple_debug_error("prefs", "Unable to rename %s to %s: new pref not created\n", oldname, newname);
return;
}
if (oldpref->type != newpref->type)
{
purple_debug_error("prefs", "Unable to rename %s to %s: differing types\n", oldname, newname);
return;
}
purple_debug_info("prefs", "Renaming and toggling %s to %s\n", oldname, newname);
purple_prefs_set_bool(newname, !(oldpref->value.boolean));
remove_pref(oldpref);
}
static gboolean plugin_unload(PurplePlugin *plugin)
{
PurpleConversationUiOps *ui_ops;
purple_prefs_set_bool(PURPLE_NICKCHANGE_PREF, TRUE);
/* Destroy the hash table. The core plugin code will
* disconnect the signals, and since Purple is single-threaded,
* we don't have to worry one will be called after this. */
g_hash_table_destroy(userstable);
purple_timeout_remove(clean_user_timeout);
if (orig_chat_rename_user) {
ui_ops = pidgin_conversations_get_conv_ui_ops();
ui_ops->chat_rename_user = orig_chat_rename_user;
}
return TRUE;
}
static void
method_toggle_cb(GtkWidget *widget, gpointer data)
{
gboolean on = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
gchar pref[256];
g_snprintf(pref, sizeof(pref), "/plugins/gtk/X11/notify/%s",
(char *)data);
purple_prefs_set_bool(pref, on);
if (!strcmp(data, "method_string")) {
GtkWidget *entry = g_object_get_data(G_OBJECT(widget), "title-entry");
gtk_widget_set_sensitive(entry, on);
purple_prefs_set_string("/plugins/gtk/X11/notify/title_string",
gtk_entry_get_text(GTK_ENTRY(entry)));
}
apply_method();
}
static void toggle_enable (GtkButton *button, gpointer data)
{
GtkWidget *popup, *vbox, *label;
vbox = data;
if (purple_prefs_get_bool (
"/plugins/gtk/autoprofile/components/logstat/enabled")) {
logstats_unload (NULL);
purple_prefs_set_bool (
"/plugins/gtk/autoprofile/components/logstat/enabled", FALSE);
gtk_widget_set_sensitive (vbox, FALSE);
} else {
popup = gtk_dialog_new_with_buttons (
"Enable stats for logs", NULL, 0,
GTK_STOCK_OK, 42, NULL);
g_signal_connect (G_OBJECT(popup), "response",
G_CALLBACK(logstats_response_cb), vbox);
label = gtk_label_new(NULL);
gtk_label_set_markup(GTK_LABEL(label),
"\nEnabling this component will have some minor side effects. Doing so "
"will cause Purple to take slightly longer to start up because it must "
"parse a large amount of data to gather statistics. On average, this "
"can take slightly over a second for every 100,000 messages in your "
"logs.\n\nThe time from when you press the OK button to the time "
"when this dialog vanishes is a good approximation of how much extra "
"time will elapse before the login screen is shown.\n"
);
gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(popup)->vbox), label,
FALSE, FALSE, 0);
gtk_widget_show_all (popup);
}
}
static gboolean
receiving_im_cb(PurpleAccount *account, char **sender, char **buffer,
PurpleConversation *conv, PurpleMessageFlags *flags, void *data)
{
twitter_debug("called\n");
twitter_debug("buffer = %s suppress_oops = %d\n", *buffer, suppress_oops);
gint service;
service = get_service_type_by_account(account, *sender);
twitter_debug("service = %d\n", service);
#ifdef _WIN32
/* suppress notification of incoming messages. */
if(service != unknown_service &&
purple_prefs_get_bool(OPT_PREVENT_NOTIFICATION)) {
if(!blink_modified) {
blink_modified = TRUE;
blink_state = purple_prefs_get_bool(OPT_PIDGIN_BLINK_IM);
purple_prefs_set_bool(OPT_PIDGIN_BLINK_IM, FALSE);
}
}
else {
if(blink_modified) {
purple_prefs_set_bool(OPT_PIDGIN_BLINK_IM, blink_state);
blink_modified = FALSE;
}
}
#endif
if(service == wassr_service) {
gchar *stripped = strip_html_markup(*buffer);
/* suppress annoying completion message from wassr */
if(strstr(*buffer, "<body>チャンネル投稿完了:")) {
twitter_debug("clearing channel parrot message\n");
g_free(*sender); *sender = NULL;
g_free(*buffer); *buffer = NULL;
}
/* discard parrot message */
else {
GList *current = g_list_first(wassr_parrot_list);
while(current) {
GList *next = g_list_next(current);
if(strstr(stripped, current->data)) {
twitter_debug("parrot clearing: buf = %s post = %s\n",
*buffer, (char *)current->data);
g_free(*sender); *sender = NULL;
g_free(*buffer); *buffer = NULL;
g_free(current->data);
current->data = NULL;
wassr_parrot_list =
g_list_delete_link(wassr_parrot_list, current);
break;
}
current = next;
}
}
g_free(stripped);
}
else if(service == identica_service) {
/* discard parrot message */
gchar *stripped = strip_html_markup(*buffer);
GList *current = g_list_first(identica_parrot_list);
while(current) {
GList *next = g_list_next(current);
if(strstr(stripped, current->data)) {
twitter_debug("identica parrot clearing: buf = %s post = %s\n",
*buffer, (char *)current->data);
g_free(*sender); *sender = NULL;
g_free(*buffer); *buffer = NULL;
g_free(current->data);
current->data = NULL;
identica_parrot_list =
g_list_delete_link(identica_parrot_list, current);
break;
}
current = next;
}
g_free(stripped);
}
else if(service == ffeed_service) {
/* discard parrot message */
gchar *stripped = strip_html_markup(*buffer);
GList *current = g_list_first(ffeed_parrot_list);
while(current) {
GList *next = g_list_next(current);
if(strstr(stripped, current->data)) {
twitter_debug("ffeed parrot clearing: buf = %s post = %s\n",
*buffer, (char *)current->data);
g_free(*sender); *sender = NULL;
g_free(*buffer); *buffer = NULL;
g_free(current->data);
current->data = NULL;
ffeed_parrot_list =
g_list_delete_link(ffeed_parrot_list, current);
break;
}
current = next;
}
g_free(stripped);
}
/* filtering */
if(purple_prefs_get_bool(OPT_FILTER)) {
apply_filter(sender, buffer, flags, service);
}
/* return here if it is not twitter */
if(service != twitter_service) {
return FALSE;
}
/* if we use api, discard all incoming IM messages. */
if(purple_prefs_get_bool(OPT_API_BASE_POST)) {
g_free(*sender); *sender = NULL;
g_free(*buffer); *buffer = NULL;
}
if(!suppress_oops || !purple_prefs_get_bool(OPT_SUPPRESS_OOPS))
return FALSE;
if(strstr(*buffer, OOPS_MESSAGE)) {
twitter_debug("clearing sender and buffer\n");
g_free(*sender); *sender = NULL;
g_free(*buffer); *buffer = NULL;
suppress_oops = FALSE;
}
return FALSE;
}
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) {
PurpleCertificatePool *pool;
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();
if (proxytype == PROXY_SOCKS4A) {
/* do this here after loading prefs. yes, i know, it sucks */
purple_prefs_set_bool("/purple/proxy/socks4_remotedns", TRUE);
}
/* re-create the certificate cache directory */
pool = purple_certificate_find_pool("x509", "tls_peers");
dir = purple_certificate_pool_mkpath(pool, NULL);
purple_build_dir(dir, 0700);
g_free(dir);
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;
s = set_add(&acc->set, "mail_notifications_handle", NULL, NULL, acc);
s->flags |= ACC_SET_OFFLINE_ONLY | SET_NULL_OK;
}
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);
}
