static void
lh_migrate_source_request_cb(void *ignored, PurpleRequestFields *fields)
{
PurpleRequestFields *request;
PurpleRequestFieldGroup *group;
PurpleRequestField *field;
source_account = purple_request_fields_get_account(fields,
"migrate_source_acct");
valid_target_prpl_id = purple_account_get_protocol_id(source_account);
/* It seems Purple is super-picky about the order of these first three calls */
/* create a request */
request = purple_request_fields_new();
/* now create a field group */
group = purple_request_field_group_new(NULL);
/* and add that group to the request created above */
purple_request_fields_add_group(request, group);
/* create a field */
field = purple_request_field_account_new("migrate_target_acct",
_("Account"), NULL);
/* mark the field as required */
purple_request_field_set_required(field, TRUE);
/* filter this list so that only accounts with the same prpl as the
* source account can be chosen as a destination */
purple_request_field_account_set_filter(field, lh_migrate_filter);
/* add the field to the group created above */
purple_request_field_group_add_field(group, field);
/* and finally we can create the request */
purple_request_fields(purple_get_blist(), _("Listhandler - Copying"),
_("Choose the account to add buddies to:"), NULL,
request, _("_Add"),
G_CALLBACK(lh_migrate_target_request_cb), _("_Cancel"),
NULL, NULL, NULL, NULL, NULL);
return;
}
static gboolean plugin_unload(PurplePlugin *plugin)
{
void *conv_handle;
struct crazychat *extra;
assert(plugin);
extra = (struct crazychat*) plugin->info->extra_info;
cc_destroy(extra);
conv_handle = purple_conversations_get_handle();
purple_signal_disconnect(PIDGIN_BLIST
(purple_get_blist()),
"drawing-menu", plugin,
PURPLE_CALLBACK(cc_buddy_menu));
purple_signal_disconnect(conv_handle, "received-im", plugin,
PURPLE_CALLBACK(receive_im_cb));
purple_signal_disconnect(conv_handle, "displaying-im-msg", plugin,
PURPLE_CALLBACK(display_im_cb));
Debug("CrazyChat plugin unloaded.\n");
return TRUE;
}
static gboolean cc_signed_on(PurpleConnection *gc, void *plugin)
{
struct crazychat *extra;
void *conv_handle;
assert(plugin);
extra = (struct crazychat*)((PurplePlugin*)plugin)->info->extra_info;
purple_signal_disconnect
(purple_connections_get_handle(), "signed-on",
plugin, PURPLE_CALLBACK(cc_signed_on));
purple_signal_connect(PIDGIN_BLIST
(purple_get_blist()),
"drawing-menu", plugin,
PURPLE_CALLBACK(cc_buddy_menu), NULL);
conv_handle = purple_conversations_get_handle();
purple_signal_connect(conv_handle, "received-im-msg", plugin,
PURPLE_CALLBACK(receive_im_cb), extra);
purple_signal_connect(conv_handle, "displaying-im-msg", plugin,
PURPLE_CALLBACK(display_im_cb), extra);
return FALSE;
}
static void
use_icon_theme(GtkWidget *w, GtkWidget *window)
{
/* I don't quite understand the icon-theme stuff. For example, I don't
* know why PidginIconTheme needs to be abstract, or how PidginStatusIconTheme
* would be different from other PidginIconTheme's (e.g. PidginStockIconTheme)
* etc., but anyway, this works for now.
*
* Here's an interesting note: A PidginStatusIconTheme can be used for both
* stock and status icons. Like I said, I don't quite know how they could be
* different. So I am going to just keep it as it is, for now anyway, until I
* have the time to dig through this, or someone explains this stuff to me
* clearly.
* -- Sad
*/
PidginStatusIconTheme *theme = create_icon_theme(window);
pidgin_stock_load_status_icon_theme(PIDGIN_STATUS_ICON_THEME(theme));
pidgin_stock_load_stock_icon_theme((PidginStockIconTheme *)theme);
pidgin_blist_refresh(purple_get_blist());
g_object_unref(theme);
}
static gboolean
plugin_load(PurplePlugin *plugin)
{
PurpleBuddyList *list = purple_get_blist();
void *conn_handle = purple_connections_get_handle();
if (!check_timeout(NULL)) {
purple_debug_warning("mailchk", "Could not read $MAIL or /var/spool/mail/$USER\n");
return FALSE;
}
if (list && PURPLE_IS_GTK_BLIST(list) && PIDGIN_BLIST(list)->vbox)
timer = g_timeout_add(2000, check_timeout, NULL);
purple_signal_connect(conn_handle, "signed-on",
plugin, PURPLE_CALLBACK(signon_cb), NULL);
purple_signal_connect(conn_handle, "signed-off",
plugin, PURPLE_CALLBACK(signoff_cb), NULL);
return TRUE;
}
/*
ns_get_buddies
Add buddies to watchlist
*/
void netsoul_get_buddies (PurpleConnection* gc)
{
PurpleBlistNode *gnode, *cnode, *bnode;
purple_debug_info("netsoul", "ns_get_buddies\n");
for(gnode = purple_get_blist()->root; gnode; gnode = gnode->next) {
if(!PURPLE_BLIST_NODE_IS_GROUP(gnode)) continue;
for(cnode = gnode->child; cnode; cnode = cnode->next) {
if(!PURPLE_BLIST_NODE_IS_CONTACT(cnode)) continue;
for(bnode = cnode->child; bnode; bnode = bnode->next) {
if(!PURPLE_BLIST_NODE_IS_BUDDY(bnode)) continue;
if(((PurpleBuddy*)bnode)->account == gc->account)
{
PurpleBuddy *buddy = (PurpleBuddy*)bnode;
gchar *photo = NULL;
purple_debug_info("netsoul", "netsoul_add_buddy %s\n", buddy->name);
NetsoulBuddy *nb = g_new0(NetsoulBuddy, 1);
buddy->proto_data = nb;
nb->login = g_strdup(buddy->name);
// Get photo
photo = g_strdup_printf("%s%s", NETSOUL_PHOTO_URL, buddy->name);
purple_util_fetch_url(photo, TRUE, NULL, FALSE, netsoul_got_photo, buddy);
// if contact is not already is watch list, add it
ns_watch_buddy(gc, buddy);
}
}
}
}
// watch_log_user
NetsoulData *ns = gc->proto_data;
ns_watch_log_user(gc);
ns_list_users(gc, ns->watchlist);
}
void
lh_migrate_action_cb(PurplePluginAction *action)
{
PurpleRequestFields *request;
PurpleRequestFieldGroup *group;
PurpleRequestField *field;
/* It seems Purple is super-picky about the order of these first three calls */
/* create a request */
request = purple_request_fields_new();
/* now create a field group */
group = purple_request_field_group_new(NULL);
/* and add that group to the request created above */
purple_request_fields_add_group(request, group);
/* create a field */
field = purple_request_field_account_new("migrate_source_acct",
_("Account"), NULL);
/* mark the field as required */
purple_request_field_set_required(field, TRUE);
/* let's show offline accounts too */
purple_request_field_account_set_show_all(field, TRUE);
/* add the field to the group created above */
purple_request_field_group_add_field(group, field);
/* and finally we can create the request */
purple_request_fields(purple_get_blist(), _("Listhandler - Copying"),
_("Choose the account to copy from:"), NULL, request,
_("C_opy"), G_CALLBACK(lh_migrate_source_request_cb),
_("_Cancel"), NULL, NULL, NULL, NULL, NULL);
return;
}
static void buddy_set_priority_cb(PurpleBlistNode *node, gpointer priority) {
purple_blist_node_set_int(node, "extended_sort_method_priority", GPOINTER_TO_INT(priority));
pidgin_blist_refresh(purple_get_blist());
}
static void blist_set_ontop(gboolean val) {
if(!blist)
return;
gtk_window_set_keep_above(GTK_WINDOW(PIDGIN_BLIST(purple_get_blist())->window), val);
}
static void sort_method_ext_blist_sort(
PurpleBlistNode *node, PurpleBuddyList *blist,
GtkTreeIter group, GtkTreeIter *cur, GtkTreeIter *ret
) {
GtkTreeIter tmp_iter;
PidginBuddyList *gtkblist;
gtkblist = PIDGIN_BLIST(purple_get_blist());
if(!PURPLE_BLIST_NODE_IS_CONTACT(node) && !PURPLE_BLIST_NODE_IS_CHAT(node)) {
sort_method_none(node, blist, group, cur, ret);
return;
}
/* Get first child of group. Insert immediately if group is empty. */
if (!gtk_tree_model_iter_children(GTK_TREE_MODEL(gtkblist->treemodel), &tmp_iter, &group)) {
gtk_tree_store_insert(gtkblist->treemodel, ret, &group, 0);
return;
}
/* Go trough all children */
do {
GValue val;
PurpleBlistNode *n;
gint cmp1, cmp2, cmp3;
/* Retrieve a BlistNode from a TreeModelNode */
val.g_type=0;
gtk_tree_model_get_value(GTK_TREE_MODEL(gtkblist->treemodel), &tmp_iter, NODE_COLUMN, &val);
n = g_value_get_pointer(&val);
/* Comparing... */
cmp1 = compare(
purple_prefs_get_int(PLUGIN_PREFS_PREFIX "/sort1"),
purple_prefs_get_bool(PLUGIN_PREFS_PREFIX "/sort1_reverse"),
node, n
);
cmp2 = compare(
purple_prefs_get_int(PLUGIN_PREFS_PREFIX "/sort2"),
purple_prefs_get_bool(PLUGIN_PREFS_PREFIX "/sort2_reverse"),
node, n
);
cmp3 = compare(
purple_prefs_get_int(PLUGIN_PREFS_PREFIX "/sort3"),
purple_prefs_get_bool(PLUGIN_PREFS_PREFIX "/sort3_reverse"),
node, n
);
/* Insert node before the current? */
/* TODO: refactor */
if(cmp1 < 0 ||
(cmp1 == 0 &&
(cmp2 < 0 ||
(cmp2 == 0 &&
(cmp3 < 0 ||
(cmp3 == 0 && node < n)))))) {
if(cur == NULL) {
gtk_tree_store_insert_before(gtkblist->treemodel, ret, &group, &tmp_iter);
} else {
gtk_tree_store_move_before(gtkblist->treemodel, cur, &tmp_iter);
*ret = *cur;
}
return;
}
g_value_unset(&val);
/* Get next node */
} while(gtk_tree_model_iter_next(GTK_TREE_MODEL(gtkblist->treemodel), &tmp_iter));
/* Insert at the end */
if(cur == NULL) {
gtk_tree_store_append(gtkblist->treemodel, ret, &group);
} else {
gtk_tree_store_move_before(gtkblist->treemodel, cur, NULL);
*ret = *cur;
}
return;
}
//
// Callback that's invoked once the main JSON file is downloaded.
//
// If the SoupMessage returns a successful response then this callback will
// trigger the processing of the users asynchronously. It will also register a
// a callback that will process all new buddies that are added while Pidgin is
// running.
//
static void
budicons_got_json_response (SoupSession *session, SoupMessage *message, gpointer data) {
BudiconsPlugin *plugin = (BudiconsPlugin *) data;
{
char *url = soup_uri_to_string(soup_message_get_uri(message), FALSE);
g_print("Downloaded URL %s: %d\n", url, message->status_code);
g_free(url);
}
if (! SOUP_STATUS_IS_SUCCESSFUL (message->status_code)) {
g_print("SOUP Message was not successful (%d)\n", message->status_code);
return;
}
const char *buffer = message->response_body->data;
gsize length = (gsize) message->response_body->length;
const char *mime = soup_message_headers_get_content_type(message->response_headers, NULL);
if (! (EQ(mime, "application/json") || EQ(mime, "text/plain"))) {
g_print("Got the wrong mime type (%s) for the JSON file\n", mime);
return;
}
// Parse the JSON file
GError *error = NULL;
plugin->users = budicons_json_parse_users(buffer, length, &error);
if (plugin->users == NULL) {
char *url = soup_uri_to_string(soup_message_get_uri(message), FALSE);
g_print("Failed to parse URL %s: %s\n", url, error->message);
g_free(url);
g_error_free(error);
return;
}
// Register a callback for every new buddy added
purple_signal_connect(
purple_blist_get_handle(),
"buddy-added",
plugin->purple,
PURPLE_CALLBACK(budicons_buddy_added_callback),
plugin
);
// Collect the buddies to process
PurpleBuddyList *list = purple_get_blist();
if (list == NULL) {return;}
plugin->buddies = NULL;
for (PurpleBlistNode *group = list->root; group; group = group->next) {
if (! PURPLE_BLIST_NODE_IS_GROUP(group)) {continue;}
for (PurpleBlistNode *contact = group->child; contact; contact = contact->next) {
if (! PURPLE_BLIST_NODE_IS_CONTACT(contact)) {continue;}
for (PurpleBlistNode *blist = contact->child; blist; blist = blist->next) {
if (! PURPLE_BLIST_NODE_IS_BUDDY(blist)) {continue;}
PurpleBuddy *buddy = (PurpleBuddy *) blist;
plugin->buddies = g_slist_prepend(plugin->buddies, buddy);
}
}
}
// Start a few workers that will process the buddies registered so far
plugin->buddy_iter = plugin->buddies;
guint workers = budicons_prefs_get_workers();
for (guint i = 0; i < workers; ++i) {
// No more buddies to process
if (plugin->buddy_iter == NULL) {break;}
// Create a new worker
BudiconsWorker *worker = g_new0(BudiconsWorker, 1);
worker->plugin = plugin;
worker->id = i;
g_print("[%d] Started a new worker\n", worker->id);
budicons_worker_iter(worker);
}
}
