Mercurial > pidgin.yaz
view pidgin/gtkblist.c @ 26479:f5f08111da52
propagate from branch 'im.pidgin.pidgin' (head a609160715ae18beed98b084aac19bc0f6551362)
to branch 'im.pidgin.pidgin.vv' (head 6e683319559d829234bc548e0795ed03403af478)
| author | Mike Ruprecht <maiku@soc.pidgin.im> |
|---|---|
| date | Wed, 01 Apr 2009 04:25:37 +0000 |
| parents | 38238d41923b 1b2d418c26ff |
| children | bd61f91e669a b290c7b9fc73 1337d2813b2d 5391094529c6 |
line wrap: on
line source
/* * @file gtkblist.c GTK+ BuddyList API * @ingroup pidgin */ /* pidgin * * Pidgin 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 "internal.h" #include "pidgin.h" #include "account.h" #include "connection.h" #include "core.h" #include "debug.h" #include "notify.h" #include "prpl.h" #include "prefs.h" #include "plugin.h" #include "request.h" #include "signals.h" #include "pidginstock.h" #include "theme-loader.h" #include "theme-manager.h" #include "util.h" #include "gtkaccount.h" #include "gtkblist.h" #include "gtkcellrendererexpander.h" #include "gtkcertmgr.h" #include "gtkconv.h" #include "gtkdebug.h" #include "gtkdialogs.h" #include "gtkft.h" #include "gtklog.h" #include "gtkmenutray.h" #include "gtkpounce.h" #include "gtkplugin.h" #include "gtkprefs.h" #include "gtkprivacy.h" #include "gtkroomlist.h" #include "gtkstatusbox.h" #include "gtkscrollbook.h" #include "gtksmiley.h" #include "gtkblist-theme.h" #include "gtkblist-theme-loader.h" #include "gtkutils.h" #include "pidgin/minidialog.h" #include "pidgin/pidgintooltip.h" #include <gdk/gdkkeysyms.h> #include <gtk/gtk.h> #include <gdk/gdk.h> #define HEADLINE_CLOSE_SIZE 11 typedef struct { PurpleAccount *account; GtkWidget *window; GtkWidget *combo; GtkWidget *entry; GtkWidget *entry_for_alias; GtkWidget *account_box; } PidginAddBuddyData; typedef struct { PurpleAccount *account; gchar *default_chat_name; GtkWidget *window; GtkWidget *account_menu; GtkWidget *alias_entry; GtkWidget *group_combo; GtkWidget *entries_box; GtkSizeGroup *sg; GtkWidget *autojoin; GtkWidget *persistent; GList *entries; } PidginAddChatData; typedef struct { PurpleAccount *account; GtkWidget *window; GtkWidget *account_menu; GtkWidget *entries_box; GtkSizeGroup *sg; GList *entries; } PidginJoinChatData; typedef struct { /** Used to hold error minidialogs. Gets packed * inside PidginBuddyList.error_buttons */ PidginScrollBook *error_scrollbook; /** Pointer to the mini-dialog about having signed on elsewhere, if one * is showing; @c NULL otherwise. */ PidginMiniDialog *signed_on_elsewhere; PidginBlistTheme *current_theme; } PidginBuddyListPrivate; #define PIDGIN_BUDDY_LIST_GET_PRIVATE(list) \ ((PidginBuddyListPrivate *)((list)->priv)) static GtkWidget *accountmenu = NULL; static guint visibility_manager_count = 0; static GdkVisibilityState gtk_blist_visibility = GDK_VISIBILITY_UNOBSCURED; static gboolean gtk_blist_focused = FALSE; static gboolean editing_blist = FALSE; static GList *pidgin_blist_sort_methods = NULL; static struct pidgin_blist_sort_method *current_sort_method = NULL; static void sort_method_none(PurpleBlistNode *node, PurpleBuddyList *blist, GtkTreeIter groupiter, GtkTreeIter *cur, GtkTreeIter *iter); /* The functions we use for sorting aren't available in gtk 2.0.x, and * segfault in 2.2.0. 2.2.1 is known to work, so I'll require that */ #if GTK_CHECK_VERSION(2,2,1) static void sort_method_alphabetical(PurpleBlistNode *node, PurpleBuddyList *blist, GtkTreeIter groupiter, GtkTreeIter *cur, GtkTreeIter *iter); static void sort_method_status(PurpleBlistNode *node, PurpleBuddyList *blist, GtkTreeIter groupiter, GtkTreeIter *cur, GtkTreeIter *iter); static void sort_method_log_activity(PurpleBlistNode *node, PurpleBuddyList *blist, GtkTreeIter groupiter, GtkTreeIter *cur, GtkTreeIter *iter); #endif static PidginBuddyList *gtkblist = NULL; static GList *groups_tree(void); static gboolean pidgin_blist_refresh_timer(PurpleBuddyList *list); static void pidgin_blist_update_buddy(PurpleBuddyList *list, PurpleBlistNode *node, gboolean status_change); static void pidgin_blist_selection_changed(GtkTreeSelection *selection, gpointer data); static void pidgin_blist_update(PurpleBuddyList *list, PurpleBlistNode *node); static void pidgin_blist_update_group(PurpleBuddyList *list, PurpleBlistNode *node); static void pidgin_blist_update_contact(PurpleBuddyList *list, PurpleBlistNode *node); static char *pidgin_get_tooltip_text(PurpleBlistNode *node, gboolean full); static const char *item_factory_translate_func (const char *path, gpointer func_data); static gboolean get_iter_from_node(PurpleBlistNode *node, GtkTreeIter *iter); static gboolean buddy_is_displayable(PurpleBuddy *buddy); static void redo_buddy_list(PurpleBuddyList *list, gboolean remove, gboolean rerender); static void pidgin_blist_collapse_contact_cb(GtkWidget *w, PurpleBlistNode *node); static char *pidgin_get_group_title(PurpleBlistNode *gnode, gboolean expanded); static void pidgin_blist_expand_contact_cb(GtkWidget *w, PurpleBlistNode *node); static void set_urgent(void); typedef enum { PIDGIN_BLIST_NODE_HAS_PENDING_MESSAGE = 1 << 0, /* Whether there's pending message in a conversation */ PIDGIN_BLIST_CHAT_HAS_PENDING_MESSAGE_WITH_NICK = 1 << 1, /* Whether there's a pending message in a chat that mentions our nick */ } PidginBlistNodeFlags; typedef struct _pidgin_blist_node { GtkTreeRowReference *row; gboolean contact_expanded; gboolean recent_signonoff; gint recent_signonoff_timer; struct { PurpleConversation *conv; time_t last_message; /* timestamp for last displayed message */ PidginBlistNodeFlags flags; } conv; } PidginBlistNode; /*************************************************** * Callbacks * ***************************************************/ static gboolean gtk_blist_visibility_cb(GtkWidget *w, GdkEventVisibility *event, gpointer data) { GdkVisibilityState old_state = gtk_blist_visibility; gtk_blist_visibility = event->state; if (gtk_blist_visibility == GDK_VISIBILITY_FULLY_OBSCURED && old_state != GDK_VISIBILITY_FULLY_OBSCURED) { /* no longer fully obscured */ pidgin_blist_refresh_timer(purple_get_blist()); } /* continue to handle event normally */ return FALSE; } static gboolean gtk_blist_window_state_cb(GtkWidget *w, GdkEventWindowState *event, gpointer data) { #if GTK_CHECK_VERSION(2,2,0) if(event->changed_mask & GDK_WINDOW_STATE_WITHDRAWN) { if(event->new_window_state & GDK_WINDOW_STATE_WITHDRAWN) purple_prefs_set_bool(PIDGIN_PREFS_ROOT "/blist/list_visible", FALSE); else { purple_prefs_set_bool(PIDGIN_PREFS_ROOT "/blist/list_visible", TRUE); pidgin_blist_refresh_timer(purple_get_blist()); } } if(event->changed_mask & GDK_WINDOW_STATE_MAXIMIZED) { if(event->new_window_state & GDK_WINDOW_STATE_MAXIMIZED) purple_prefs_set_bool(PIDGIN_PREFS_ROOT "/blist/list_maximized", TRUE); else purple_prefs_set_bool(PIDGIN_PREFS_ROOT "/blist/list_maximized", FALSE); } /* Refresh gtkblist if un-iconifying */ if (event->changed_mask & GDK_WINDOW_STATE_ICONIFIED){ if (!(event->new_window_state & GDK_WINDOW_STATE_ICONIFIED)) pidgin_blist_refresh_timer(purple_get_blist()); } #else /* At least gtk+ 2.0.6 does not properly set the change_mask when unsetting a * GdkWindowState flag. To work around, the window state will be explicitly * queried on these older versions of gtk+. See pidgin ticket #739. */ GdkWindowState new_window_state = gdk_window_get_state(G_OBJECT(gtkblist->window->window)); if(new_window_state & GDK_WINDOW_STATE_WITHDRAWN) { purple_prefs_set_bool(PIDGIN_PREFS_ROOT "/blist/list_visible", FALSE); } else { purple_prefs_set_bool(PIDGIN_PREFS_ROOT "/blist/list_visible", TRUE); pidgin_blist_refresh_timer(purple_get_blist()); } if(new_window_state & GDK_WINDOW_STATE_MAXIMIZED) purple_prefs_set_bool(PIDGIN_PREFS_ROOT "/blist/list_maximized", TRUE); else purple_prefs_set_bool(PIDGIN_PREFS_ROOT "/blist/list_maximized", FALSE); if (!(new_window_state & GDK_WINDOW_STATE_ICONIFIED)) pidgin_blist_refresh_timer(purple_get_blist()); #endif return FALSE; } static gboolean gtk_blist_delete_cb(GtkWidget *w, GdkEventAny *event, gpointer data) { if(visibility_manager_count) purple_blist_set_visible(FALSE); else purple_core_quit(); /* we handle everything, event should not propogate further */ return TRUE; } static gboolean gtk_blist_configure_cb(GtkWidget *w, GdkEventConfigure *event, gpointer data) { /* unfortunately GdkEventConfigure ignores the window gravity, but * * the only way we have of setting the position doesn't. we have to * * call get_position because it does pay attention to the gravity. * * this is inefficient and I agree it sucks, but it's more likely * * to work correctly. - Robot101 */ gint x, y; /* check for visibility because when we aren't visible, this will * * give us bogus (0,0) coordinates. - xOr */ if (GTK_WIDGET_VISIBLE(w)) gtk_window_get_position(GTK_WINDOW(w), &x, &y); else return FALSE; /* carry on normally */ #ifdef _WIN32 /* Workaround for GTK+ bug # 169811 - "configure_event" is fired * when the window is being maximized */ if (gdk_window_get_state(w->window) & GDK_WINDOW_STATE_MAXIMIZED) { return FALSE; } #endif /* don't save if nothing changed */ if (x == purple_prefs_get_int(PIDGIN_PREFS_ROOT "/blist/x") && y == purple_prefs_get_int(PIDGIN_PREFS_ROOT "/blist/y") && event->width == purple_prefs_get_int(PIDGIN_PREFS_ROOT "/blist/width") && event->height == purple_prefs_get_int(PIDGIN_PREFS_ROOT "/blist/height")) { return FALSE; /* carry on normally */ } /* don't save off-screen positioning */ if (x + event->width < 0 || y + event->height < 0 || x > gdk_screen_width() || y > gdk_screen_height()) { return FALSE; /* carry on normally */ } /* ignore changes when maximized */ if(purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/blist/list_maximized")) return FALSE; /* store the position */ purple_prefs_set_int(PIDGIN_PREFS_ROOT "/blist/x", x); purple_prefs_set_int(PIDGIN_PREFS_ROOT "/blist/y", y); purple_prefs_set_int(PIDGIN_PREFS_ROOT "/blist/width", event->width); purple_prefs_set_int(PIDGIN_PREFS_ROOT "/blist/height", event->height); /* continue to handle event normally */ return FALSE; } static void gtk_blist_menu_info_cb(GtkWidget *w, PurpleBuddy *b) { PurpleAccount *account = purple_buddy_get_account(b); pidgin_retrieve_user_info(purple_account_get_connection(account), purple_buddy_get_name(b)); } static void gtk_blist_menu_im_cb(GtkWidget *w, PurpleBuddy *b) { pidgin_dialogs_im_with_user(purple_buddy_get_account(b), purple_buddy_get_name(b)); } #ifdef USE_VV static void gtk_blist_menu_audio_call_cb(GtkWidget *w, PurpleBuddy *b) { purple_prpl_initiate_media(purple_buddy_get_account(b), purple_buddy_get_name(b), PURPLE_MEDIA_AUDIO); } static void gtk_blist_menu_video_call_cb(GtkWidget *w, PurpleBuddy *b) { /* if the buddy supports both audio and video, start a combined call, otherwise start a pure video session */ if (purple_prpl_get_media_caps(purple_buddy_get_account(b), purple_buddy_get_name(b)) & PURPLE_MEDIA_CAPS_AUDIO_VIDEO) { purple_prpl_initiate_media(purple_buddy_get_account(b), purple_buddy_get_name(b), PURPLE_MEDIA_AUDIO | PURPLE_MEDIA_VIDEO); } else { purple_prpl_initiate_media(purple_buddy_get_account(b), purple_buddy_get_name(b), PURPLE_MEDIA_VIDEO); } } #endif static void gtk_blist_menu_send_file_cb(GtkWidget *w, PurpleBuddy *b) { PurpleAccount *account = purple_buddy_get_account(b); serv_send_file(purple_account_get_connection(account), purple_buddy_get_name(b), NULL); } static void gtk_blist_menu_move_to_cb(GtkWidget *w, PurpleBlistNode *node) { PurpleGroup *group = g_object_get_data(G_OBJECT(w), "groupnode"); purple_blist_add_contact((PurpleContact *)node, group, NULL); } static void gtk_blist_menu_autojoin_cb(GtkWidget *w, PurpleChat *chat) { purple_blist_node_set_bool((PurpleBlistNode*)chat, "gtk-autojoin", gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(w))); } static void gtk_blist_menu_persistent_cb(GtkWidget *w, PurpleChat *chat) { purple_blist_node_set_bool((PurpleBlistNode*)chat, "gtk-persistent", gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(w))); } static PurpleConversation * find_conversation_with_buddy(PurpleBuddy *buddy) { PidginBlistNode *ui = purple_blist_node_get_ui_data(PURPLE_BLIST_NODE(buddy)); if (ui) return ui->conv.conv; return purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, purple_buddy_get_name(buddy), purple_buddy_get_account(buddy)); } static void gtk_blist_join_chat(PurpleChat *chat) { PurpleAccount *account; PurpleConversation *conv; PurplePluginProtocolInfo *prpl_info; GHashTable *components; const char *name; char *chat_name; account = purple_chat_get_account(chat); prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(purple_find_prpl(purple_account_get_protocol_id(account))); components = purple_chat_get_components(chat); if (prpl_info && prpl_info->get_chat_name) chat_name = prpl_info->get_chat_name(components); else chat_name = NULL; if (chat_name) name = chat_name; else name = purple_chat_get_name(chat); conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_CHAT, name, account); if (conv != NULL) { pidgin_conv_attach_to_conversation(conv); purple_conversation_present(conv); } serv_join_chat(purple_account_get_connection(account), components); g_free(chat_name); } static void gtk_blist_menu_join_cb(GtkWidget *w, PurpleChat *chat) { gtk_blist_join_chat(chat); } #if GTK_CHECK_VERSION(2,6,0) static void gtk_blist_renderer_editing_cancelled_cb(GtkCellRenderer *renderer, PurpleBuddyList *list) { editing_blist = FALSE; g_object_set(G_OBJECT(renderer), "editable", FALSE, NULL); pidgin_blist_refresh(list); } static void gtk_blist_renderer_editing_started_cb(GtkCellRenderer *renderer, GtkCellEditable *editable, gchar *path_str, gpointer user_data) { GtkTreeIter iter; GtkTreePath *path = NULL; GValue val; PurpleBlistNode *node; const char *text = NULL; path = gtk_tree_path_new_from_string (path_str); gtk_tree_model_get_iter (GTK_TREE_MODEL(gtkblist->treemodel), &iter, path); gtk_tree_path_free (path); val.g_type = 0; gtk_tree_model_get_value (GTK_TREE_MODEL(gtkblist->treemodel), &iter, NODE_COLUMN, &val); node = g_value_get_pointer(&val); switch (purple_blist_node_get_type(node)) { case PURPLE_BLIST_CONTACT_NODE: text = purple_contact_get_alias(PURPLE_CONTACT(node)); break; case PURPLE_BLIST_BUDDY_NODE: text = purple_buddy_get_alias(PURPLE_BUDDY(node)); break; case PURPLE_BLIST_GROUP_NODE: text = purple_group_get_name(PURPLE_GROUP(node)); break; default: g_return_if_reached(); } if (GTK_IS_ENTRY (editable)) { GtkEntry *entry = GTK_ENTRY (editable); gtk_entry_set_text(entry, text); } editing_blist = TRUE; } #endif static void gtk_blist_do_personize(GList *merges) { PurpleBlistNode *contact = NULL; int max = 0; GList *tmp; /* First, we find the contact to merge the rest of the buddies into. * This will be the contact with the most buddies in it; ties are broken * by which contact is higher in the list */ for (tmp = merges; tmp; tmp = tmp->next) { PurpleBlistNode *node = tmp->data; PurpleBlistNode *b; PurpleBlistNodeType type; int i = 0; type = purple_blist_node_get_type(node); if(type == PURPLE_BLIST_BUDDY_NODE) node = purple_blist_node_get_parent(node); if(type == PURPLE_BLIST_CONTACT_NODE) continue; for (b = purple_blist_node_get_first_child(node); b; b = purple_blist_node_get_sibling_next(b)) { i++; } if (i > max) { contact = node; max = i; } } if (contact == NULL) return; /* Merge all those buddies into this contact */ for (tmp = merges; tmp; tmp = tmp->next) { PurpleBlistNode *node = tmp->data; if (purple_blist_node_get_type(node) == PURPLE_BLIST_BUDDY_NODE) node = purple_blist_node_get_parent(node); if (node == contact) continue; purple_blist_merge_contact((PurpleContact *)node, contact); } /* And show the expanded contact, so the people know what's going on */ pidgin_blist_expand_contact_cb(NULL, contact); g_list_free(merges); } static void gtk_blist_auto_personize(PurpleBlistNode *group, const char *alias) { PurpleBlistNode *contact; PurpleBlistNode *buddy; GList *merges = NULL; int i = 0; char *a = g_utf8_casefold(alias, -1); for (contact = purple_blist_node_get_first_child(group); contact != NULL; contact = purple_blist_node_get_sibling_next(contact)) { char *node_alias; if (purple_blist_node_get_type(contact) != PURPLE_BLIST_CONTACT_NODE) continue; node_alias = g_utf8_casefold(purple_contact_get_alias((PurpleContact *)contact), -1); if (node_alias && !g_utf8_collate(node_alias, a)) { merges = g_list_append(merges, contact); i++; g_free(node_alias); continue; } g_free(node_alias); for (buddy = purple_blist_node_get_first_child(contact); buddy; buddy = purple_blist_node_get_sibling_next(buddy)) { if (purple_blist_node_get_type(buddy) != PURPLE_BLIST_BUDDY_NODE) continue; node_alias = g_utf8_casefold(purple_buddy_get_alias(PURPLE_BUDDY(buddy)), -1); if (node_alias && !g_utf8_collate(node_alias, a)) { merges = g_list_append(merges, buddy); i++; g_free(node_alias); break; } g_free(node_alias); } } g_free(a); if (i > 1) { char *msg = g_strdup_printf(ngettext("You have %d contact named %s. Would you like to merge them?", "You currently have %d contacts named %s. Would you like to merge them?", i), i, alias); purple_request_action(NULL, NULL, msg, _("Merging these contacts will cause them to share a single entry on the buddy list and use a single conversation window. " "You can separate them again by choosing 'Expand' from the contact's context menu"), 0, NULL, NULL, NULL, merges, 2, _("_Yes"), PURPLE_CALLBACK(gtk_blist_do_personize), _("_No"), PURPLE_CALLBACK(g_list_free)); g_free(msg); } else g_list_free(merges); } static void gtk_blist_renderer_edited_cb(GtkCellRendererText *text_rend, char *arg1, char *arg2, PurpleBuddyList *list) { GtkTreeIter iter; GtkTreePath *path; GValue val; PurpleBlistNode *node; PurpleGroup *dest; editing_blist = FALSE; path = gtk_tree_path_new_from_string (arg1); gtk_tree_model_get_iter (GTK_TREE_MODEL(gtkblist->treemodel), &iter, path); gtk_tree_path_free (path); val.g_type = 0; gtk_tree_model_get_value (GTK_TREE_MODEL(gtkblist->treemodel), &iter, NODE_COLUMN, &val); node = g_value_get_pointer(&val); gtk_tree_view_set_enable_search (GTK_TREE_VIEW(gtkblist->treeview), TRUE); g_object_set(G_OBJECT(gtkblist->text_rend), "editable", FALSE, NULL); switch (purple_blist_node_get_type(node)) { case PURPLE_BLIST_CONTACT_NODE: { PurpleContact *contact = PURPLE_CONTACT(node); struct _pidgin_blist_node *gtknode = (struct _pidgin_blist_node *)purple_blist_node_get_ui_data(node); if (purple_contact_get_alias(contact) || gtknode->contact_expanded) { purple_blist_alias_contact(contact, arg2); gtk_blist_auto_personize(purple_blist_node_get_parent(node), arg2); } else { PurpleBuddy *buddy = purple_contact_get_priority_buddy(contact); purple_blist_alias_buddy(buddy, arg2); serv_alias_buddy(buddy); gtk_blist_auto_personize(purple_blist_node_get_parent(node), arg2); } } break; case PURPLE_BLIST_BUDDY_NODE: { PurpleGroup *group = purple_buddy_get_group(PURPLE_BUDDY(node)); purple_blist_alias_buddy(PURPLE_BUDDY(node), arg2); serv_alias_buddy(PURPLE_BUDDY(node)); gtk_blist_auto_personize(PURPLE_BLIST_NODE(group), arg2); } break; case PURPLE_BLIST_GROUP_NODE: dest = purple_find_group(arg2); if (dest != NULL && purple_utf8_strcasecmp(arg2, purple_group_get_name(PURPLE_GROUP(node)))) { pidgin_dialogs_merge_groups(PURPLE_GROUP(node), arg2); } else { purple_blist_rename_group(PURPLE_GROUP(node), arg2); } break; case PURPLE_BLIST_CHAT_NODE: purple_blist_alias_chat(PURPLE_CHAT(node), arg2); break; default: break; } pidgin_blist_refresh(list); } static void chat_components_edit_ok(PurpleChat *chat, PurpleRequestFields *allfields) { GList *groups, *fields; for (groups = purple_request_fields_get_groups(allfields); groups; groups = groups->next) { fields = purple_request_field_group_get_fields(groups->data); for (; fields; fields = fields->next) { PurpleRequestField *field = fields->data; const char *id; char *val; id = purple_request_field_get_id(field); if (purple_request_field_get_type(field) == PURPLE_REQUEST_FIELD_INTEGER) val = g_strdup_printf("%d", purple_request_field_int_get_value(field)); else val = g_strdup(purple_request_field_string_get_value(field)); if (!val) { g_hash_table_remove(purple_chat_get_components(chat), id); } else { g_hash_table_replace(purple_chat_get_components(chat), g_strdup(id), val); /* val should not be free'd */ } } } } static void chat_components_edit(GtkWidget *w, PurpleBlistNode *node) { PurpleRequestFields *fields = purple_request_fields_new(); PurpleRequestFieldGroup *group = purple_request_field_group_new(NULL); PurpleRequestField *field; GList *parts, *iter; struct proto_chat_entry *pce; PurpleConnection *gc; PurpleChat *chat = (PurpleChat*)node; purple_request_fields_add_group(fields, group); gc = purple_account_get_connection(purple_chat_get_account(chat)); parts = PURPLE_PLUGIN_PROTOCOL_INFO(purple_connection_get_prpl(gc))->chat_info(gc); for (iter = parts; iter; iter = iter->next) { pce = iter->data; if (pce->is_int) { int val; const char *str = g_hash_table_lookup(purple_chat_get_components(chat), pce->identifier); if (!str || sscanf(str, "%d", &val) != 1) val = pce->min; field = purple_request_field_int_new(pce->identifier, pce->label, val); } else { field = purple_request_field_string_new(pce->identifier, pce->label, g_hash_table_lookup(purple_chat_get_components(chat), pce->identifier), FALSE); if (pce->secret) purple_request_field_string_set_masked(field, TRUE); } if (pce->required) purple_request_field_set_required(field, TRUE); purple_request_field_group_add_field(group, field); g_free(pce); } g_list_free(parts); purple_request_fields(NULL, _("Edit Chat"), NULL, _("Please update the necessary fields."), fields, _("Save"), G_CALLBACK(chat_components_edit_ok), _("Cancel"), NULL, NULL, NULL, NULL, chat); } static void gtk_blist_menu_alias_cb(GtkWidget *w, PurpleBlistNode *node) { GtkTreeIter iter; GtkTreePath *path; if (!(get_iter_from_node(node, &iter))) { /* This is either a bug, or the buddy is in a collapsed contact */ node = purple_blist_node_get_parent(node); if (!get_iter_from_node(node, &iter)) /* Now it's definitely a bug */ return; } pidgin_blist_tooltip_destroy(); path = gtk_tree_model_get_path(GTK_TREE_MODEL(gtkblist->treemodel), &iter); g_object_set(G_OBJECT(gtkblist->text_rend), "editable", TRUE, NULL); gtk_tree_view_set_enable_search (GTK_TREE_VIEW(gtkblist->treeview), FALSE); gtk_widget_grab_focus(gtkblist->treeview); #if GTK_CHECK_VERSION(2,2,0) gtk_tree_view_set_cursor_on_cell(GTK_TREE_VIEW(gtkblist->treeview), path, gtkblist->text_column, gtkblist->text_rend, TRUE); #else gtk_tree_view_set_cursor(GTK_TREE_VIEW(gtkblist->treeview), path, gtkblist->text_column, TRUE); #endif gtk_tree_path_free(path); } static void gtk_blist_menu_bp_cb(GtkWidget *w, PurpleBuddy *b) { pidgin_pounce_editor_show(purple_buddy_get_account(b), purple_buddy_get_name(b), NULL); } static void gtk_blist_menu_showlog_cb(GtkWidget *w, PurpleBlistNode *node) { PurpleLogType type; PurpleAccount *account; char *name = NULL; pidgin_set_cursor(gtkblist->window, GDK_WATCH); if (PURPLE_BLIST_NODE_IS_BUDDY(node)) { PurpleBuddy *b = (PurpleBuddy*) node; type = PURPLE_LOG_IM; name = g_strdup(purple_buddy_get_name(b)); account = purple_buddy_get_account(b); } else if (PURPLE_BLIST_NODE_IS_CHAT(node)) { PurpleChat *c = PURPLE_CHAT(node); PurplePluginProtocolInfo *prpl_info = NULL; type = PURPLE_LOG_CHAT; account = purple_chat_get_account(c); prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(purple_find_prpl(purple_account_get_protocol_id(account))); if (prpl_info && prpl_info->get_chat_name) { name = prpl_info->get_chat_name(purple_chat_get_components(c)); } } else if (PURPLE_BLIST_NODE_IS_CONTACT(node)) { pidgin_log_show_contact(PURPLE_CONTACT(node)); pidgin_clear_cursor(gtkblist->window); return; } else { pidgin_clear_cursor(gtkblist->window); /* This callback should not have been registered for a node * that doesn't match the type of one of the blocks above. */ g_return_if_reached(); } if (name && account) { pidgin_log_show(type, name, account); pidgin_clear_cursor(gtkblist->window); } g_free(name); } static void gtk_blist_menu_showoffline_cb(GtkWidget *w, PurpleBlistNode *node) { if (PURPLE_BLIST_NODE_IS_BUDDY(node)) { purple_blist_node_set_bool(node, "show_offline", !purple_blist_node_get_bool(node, "show_offline")); pidgin_blist_update(purple_get_blist(), node); } else if (PURPLE_BLIST_NODE_IS_CONTACT(node)) { PurpleBlistNode *bnode; gboolean setting = !purple_blist_node_get_bool(node, "show_offline"); purple_blist_node_set_bool(node, "show_offline", setting); for (bnode = purple_blist_node_get_first_child(node); bnode != NULL; bnode = purple_blist_node_get_sibling_next(bnode)) { purple_blist_node_set_bool(bnode, "show_offline", setting); pidgin_blist_update(purple_get_blist(), bnode); } } else if (PURPLE_BLIST_NODE_IS_GROUP(node)) { PurpleBlistNode *cnode, *bnode; gboolean setting = !purple_blist_node_get_bool(node, "show_offline"); purple_blist_node_set_bool(node, "show_offline", setting); for (cnode = purple_blist_node_get_first_child(node); cnode != NULL; cnode = purple_blist_node_get_sibling_next(cnode)) { purple_blist_node_set_bool(cnode, "show_offline", setting); for (bnode = purple_blist_node_get_first_child(cnode); bnode != NULL; bnode = purple_blist_node_get_sibling_next(bnode)) { purple_blist_node_set_bool(bnode, "show_offline", setting); pidgin_blist_update(purple_get_blist(), bnode); } } } } static void gtk_blist_show_systemlog_cb(void) { pidgin_syslog_show(); } static void gtk_blist_show_onlinehelp_cb(void) { purple_notify_uri(NULL, PURPLE_WEBSITE "documentation"); } static void do_join_chat(PidginJoinChatData *data) { if (data) { GHashTable *components = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free); GList *tmp; PurpleChat *chat; for (tmp = data->entries; tmp != NULL; tmp = tmp->next) { if (g_object_get_data(tmp->data, "is_spin")) { g_hash_table_replace(components, g_strdup(g_object_get_data(tmp->data, "identifier")), g_strdup_printf("%d", gtk_spin_button_get_value_as_int(tmp->data))); } else { g_hash_table_replace(components, g_strdup(g_object_get_data(tmp->data, "identifier")), g_strdup(gtk_entry_get_text(tmp->data))); } } chat = purple_chat_new(data->account, NULL, components); gtk_blist_join_chat(chat); purple_blist_remove_chat(chat); } } static void do_joinchat(GtkWidget *dialog, int id, PidginJoinChatData *info) { switch(id) { case GTK_RESPONSE_OK: do_join_chat(info); break; case 1: pidgin_roomlist_dialog_show_with_account(info->account); return; break; } gtk_widget_destroy(GTK_WIDGET(dialog)); g_list_free(info->entries); g_free(info); } /* * Check the values of all the text entry boxes. If any required input * strings are empty then don't allow the user to click on "OK." */ static void joinchat_set_sensitive_if_input_cb(GtkWidget *entry, gpointer user_data) { PurplePluginProtocolInfo *prpl_info; PurpleConnection *gc; PidginJoinChatData *data; GList *tmp; const char *text; gboolean required; gboolean sensitive = TRUE; data = user_data; for (tmp = data->entries; tmp != NULL; tmp = tmp->next) { if (!g_object_get_data(tmp->data, "is_spin")) { required = GPOINTER_TO_INT(g_object_get_data(tmp->data, "required")); text = gtk_entry_get_text(tmp->data); if (required && (*text == '\0')) sensitive = FALSE; } } gtk_dialog_set_response_sensitive(GTK_DIALOG(data->window), GTK_RESPONSE_OK, sensitive); gc = purple_account_get_connection(data->account); prpl_info = (gc != NULL) ? PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl) : NULL; sensitive = (prpl_info != NULL && prpl_info->roomlist_get_list != NULL); gtk_dialog_set_response_sensitive(GTK_DIALOG(data->window), 1, sensitive); } static void pidgin_blist_update_privacy_cb(PurpleBuddy *buddy) { struct _pidgin_blist_node *ui_data = purple_blist_node_get_ui_data(PURPLE_BLIST_NODE(buddy)); if (ui_data == NULL || ui_data->row == NULL) return; pidgin_blist_update_buddy(purple_get_blist(), PURPLE_BLIST_NODE(buddy), TRUE); } static void rebuild_joinchat_entries(PidginJoinChatData *data) { PurpleConnection *gc; GList *list = NULL, *tmp; GHashTable *defaults = NULL; struct proto_chat_entry *pce; gboolean focus = TRUE; g_return_if_fail(data->account != NULL); gc = purple_account_get_connection(data->account); gtk_container_foreach(GTK_CONTAINER(data->entries_box), (GtkCallback)gtk_widget_destroy, NULL); g_list_free(data->entries); data->entries = NULL; if (PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl)->chat_info != NULL) list = PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl)->chat_info(gc); if (PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl)->chat_info_defaults != NULL) defaults = PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl)->chat_info_defaults(gc, NULL); for (tmp = list; tmp; tmp = tmp->next) { GtkWidget *input; pce = tmp->data; if (pce->is_int) { GtkObject *adjust; adjust = gtk_adjustment_new(pce->min, pce->min, pce->max, 1, 10, 10); input = gtk_spin_button_new(GTK_ADJUSTMENT(adjust), 1, 0); gtk_widget_set_size_request(input, 50, -1); pidgin_add_widget_to_vbox(GTK_BOX(data->entries_box), pce->label, data->sg, input, FALSE, NULL); } else { char *value; input = gtk_entry_new(); gtk_entry_set_activates_default(GTK_ENTRY(input), TRUE); value = g_hash_table_lookup(defaults, pce->identifier); if (value != NULL) gtk_entry_set_text(GTK_ENTRY(input), value); if (pce->secret) { gtk_entry_set_visibility(GTK_ENTRY(input), FALSE); #if !GTK_CHECK_VERSION(2,16,0) if (gtk_entry_get_invisible_char(GTK_ENTRY(input)) == '*') gtk_entry_set_invisible_char(GTK_ENTRY(input), PIDGIN_INVISIBLE_CHAR); #endif /* Less than GTK+ 2.16 */ } pidgin_add_widget_to_vbox(GTK_BOX(data->entries_box), pce->label, data->sg, input, TRUE, NULL); g_signal_connect(G_OBJECT(input), "changed", G_CALLBACK(joinchat_set_sensitive_if_input_cb), data); } /* Do the following for any type of input widget */ if (focus) { gtk_widget_grab_focus(input); focus = FALSE; } g_object_set_data(G_OBJECT(input), "identifier", (gpointer)pce->identifier); g_object_set_data(G_OBJECT(input), "is_spin", GINT_TO_POINTER(pce->is_int)); g_object_set_data(G_OBJECT(input), "required", GINT_TO_POINTER(pce->required)); data->entries = g_list_append(data->entries, input); g_free(pce); } g_list_free(list); g_hash_table_destroy(defaults); /* Set whether the "OK" button should be clickable initially */ joinchat_set_sensitive_if_input_cb(NULL, data); gtk_widget_show_all(data->entries_box); } static void joinchat_select_account_cb(GObject *w, PurpleAccount *account, PidginJoinChatData *data) { data->account = account; rebuild_joinchat_entries(data); } static gboolean chat_account_filter_func(PurpleAccount *account) { PurpleConnection *gc = purple_account_get_connection(account); PurplePluginProtocolInfo *prpl_info = NULL; prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl); return (prpl_info->chat_info != NULL); } gboolean pidgin_blist_joinchat_is_showable() { GList *c; PurpleConnection *gc; for (c = purple_connections_get_all(); c != NULL; c = c->next) { gc = c->data; if (chat_account_filter_func(purple_connection_get_account(gc))) return TRUE; } return FALSE; } void pidgin_blist_joinchat_show(void) { GtkWidget *hbox, *vbox; GtkWidget *label; PidginBuddyList *gtkblist; GtkWidget *img = NULL; PidginJoinChatData *data = NULL; gtkblist = purple_blist_get_ui_data(); img = gtk_image_new_from_stock(PIDGIN_STOCK_DIALOG_QUESTION, gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_HUGE)); data = g_new0(PidginJoinChatData, 1); data->window = gtk_dialog_new_with_buttons(_("Join a Chat"), NULL, GTK_DIALOG_NO_SEPARATOR, _("Room _List"), 1, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, PIDGIN_STOCK_CHAT, GTK_RESPONSE_OK, NULL); gtk_dialog_set_default_response(GTK_DIALOG(data->window), GTK_RESPONSE_OK); gtk_container_set_border_width(GTK_CONTAINER(data->window), PIDGIN_HIG_BOX_SPACE); gtk_window_set_resizable(GTK_WINDOW(data->window), FALSE); gtk_box_set_spacing(GTK_BOX(GTK_DIALOG(data->window)->vbox), PIDGIN_HIG_BORDER); gtk_container_set_border_width( GTK_CONTAINER(GTK_DIALOG(data->window)->vbox), PIDGIN_HIG_BOX_SPACE); gtk_window_set_role(GTK_WINDOW(data->window), "join_chat"); hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BORDER); gtk_container_add(GTK_CONTAINER(GTK_DIALOG(data->window)->vbox), hbox); gtk_box_pack_start(GTK_BOX(hbox), img, FALSE, FALSE, 0); gtk_misc_set_alignment(GTK_MISC(img), 0, 0); vbox = gtk_vbox_new(FALSE, 5); gtk_container_set_border_width(GTK_CONTAINER(vbox), 0); gtk_container_add(GTK_CONTAINER(hbox), vbox); label = gtk_label_new(_("Please enter the appropriate information " "about the chat you would like to join.\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(vbox), label, FALSE, FALSE, 0); data->sg = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL); data->account_menu = pidgin_account_option_menu_new(NULL, FALSE, G_CALLBACK(joinchat_select_account_cb), chat_account_filter_func, data); pidgin_add_widget_to_vbox(GTK_BOX(vbox), _("_Account:"), data->sg, data->account_menu, TRUE, NULL); data->entries_box = gtk_vbox_new(FALSE, 5); gtk_container_add(GTK_CONTAINER(vbox), data->entries_box); gtk_container_set_border_width(GTK_CONTAINER(data->entries_box), 0); data->account = pidgin_account_option_menu_get_selected(data->account_menu); rebuild_joinchat_entries(data); g_signal_connect(G_OBJECT(data->window), "response", G_CALLBACK(do_joinchat), data); g_object_unref(data->sg); gtk_widget_show_all(data->window); } static void gtk_blist_row_expanded_cb(GtkTreeView *tv, GtkTreeIter *iter, GtkTreePath *path, gpointer user_data) { PurpleBlistNode *node; GValue val; val.g_type = 0; gtk_tree_model_get_value(GTK_TREE_MODEL(gtkblist->treemodel), iter, NODE_COLUMN, &val); node = g_value_get_pointer(&val); if (PURPLE_BLIST_NODE_IS_GROUP(node)) { char *title; title = pidgin_get_group_title(node, TRUE); gtk_tree_store_set(gtkblist->treemodel, iter, NAME_COLUMN, title, -1); g_free(title); purple_blist_node_set_bool(node, "collapsed", FALSE); pidgin_blist_tooltip_destroy(); } } static void gtk_blist_row_collapsed_cb(GtkTreeView *tv, GtkTreeIter *iter, GtkTreePath *path, gpointer user_data) { PurpleBlistNode *node; GValue val; val.g_type = 0; gtk_tree_model_get_value(GTK_TREE_MODEL(gtkblist->treemodel), iter, NODE_COLUMN, &val); node = g_value_get_pointer(&val); if (PURPLE_BLIST_NODE_IS_GROUP(node)) { char *title; struct _pidgin_blist_node *gtknode; PurpleBlistNode *cnode; title = pidgin_get_group_title(node, FALSE); gtk_tree_store_set(gtkblist->treemodel, iter, NAME_COLUMN, title, -1); g_free(title); purple_blist_node_set_bool(node, "collapsed", TRUE); for(cnode = node->child; cnode; cnode = cnode->next) { if (PURPLE_BLIST_NODE_IS_CONTACT(cnode)) { gtknode = cnode->ui_data; if (!gtknode->contact_expanded) continue; gtknode->contact_expanded = FALSE; pidgin_blist_update_contact(NULL, cnode); } } pidgin_blist_tooltip_destroy(); } else if(PURPLE_BLIST_NODE_IS_CONTACT(node)) { pidgin_blist_collapse_contact_cb(NULL, node); } } static void gtk_blist_row_activated_cb(GtkTreeView *tv, GtkTreePath *path, GtkTreeViewColumn *col, gpointer data) { PurpleBlistNode *node; GtkTreeIter iter; GValue val; gtk_tree_model_get_iter(GTK_TREE_MODEL(gtkblist->treemodel), &iter, path); val.g_type = 0; gtk_tree_model_get_value (GTK_TREE_MODEL(gtkblist->treemodel), &iter, NODE_COLUMN, &val); node = g_value_get_pointer(&val); if(PURPLE_BLIST_NODE_IS_CONTACT(node) || PURPLE_BLIST_NODE_IS_BUDDY(node)) { PurpleBuddy *buddy; if(PURPLE_BLIST_NODE_IS_CONTACT(node)) buddy = purple_contact_get_priority_buddy((PurpleContact*)node); else buddy = (PurpleBuddy*)node; pidgin_dialogs_im_with_user(buddy->account, buddy->name); } else if (PURPLE_BLIST_NODE_IS_CHAT(node)) { gtk_blist_join_chat((PurpleChat *)node); } else if (PURPLE_BLIST_NODE_IS_GROUP(node)) { /* if (gtk_tree_view_row_expanded(tv, path)) gtk_tree_view_collapse_row(tv, path); else gtk_tree_view_expand_row(tv,path,FALSE);*/ } } static void pidgin_blist_add_chat_cb(void) { GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(gtkblist->treeview)); GtkTreeIter iter; PurpleBlistNode *node; if(gtk_tree_selection_get_selected(sel, NULL, &iter)){ gtk_tree_model_get(GTK_TREE_MODEL(gtkblist->treemodel), &iter, NODE_COLUMN, &node, -1); if (PURPLE_BLIST_NODE_IS_BUDDY(node)) purple_blist_request_add_chat(NULL, (PurpleGroup*)node->parent->parent, NULL, NULL); if (PURPLE_BLIST_NODE_IS_CONTACT(node) || PURPLE_BLIST_NODE_IS_CHAT(node)) purple_blist_request_add_chat(NULL, (PurpleGroup*)node->parent, NULL, NULL); else if (PURPLE_BLIST_NODE_IS_GROUP(node)) purple_blist_request_add_chat(NULL, (PurpleGroup*)node, NULL, NULL); } else { purple_blist_request_add_chat(NULL, NULL, NULL, NULL); } } static void pidgin_blist_add_buddy_cb(void) { GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(gtkblist->treeview)); GtkTreeIter iter; PurpleBlistNode *node; if(gtk_tree_selection_get_selected(sel, NULL, &iter)){ gtk_tree_model_get(GTK_TREE_MODEL(gtkblist->treemodel), &iter, NODE_COLUMN, &node, -1); if (PURPLE_BLIST_NODE_IS_BUDDY(node)) { purple_blist_request_add_buddy(NULL, NULL, ((PurpleGroup*)node->parent->parent)->name, NULL); } else if (PURPLE_BLIST_NODE_IS_CONTACT(node) || PURPLE_BLIST_NODE_IS_CHAT(node)) { purple_blist_request_add_buddy(NULL, NULL, ((PurpleGroup*)node->parent)->name, NULL); } else if (PURPLE_BLIST_NODE_IS_GROUP(node)) { purple_blist_request_add_buddy(NULL, NULL, ((PurpleGroup*)node)->name, NULL); } } else { purple_blist_request_add_buddy(NULL, NULL, NULL, NULL); } } static void pidgin_blist_remove_cb (GtkWidget *w, PurpleBlistNode *node) { if (PURPLE_BLIST_NODE_IS_BUDDY(node)) { pidgin_dialogs_remove_buddy((PurpleBuddy*)node); } else if (PURPLE_BLIST_NODE_IS_CHAT(node)) { pidgin_dialogs_remove_chat((PurpleChat*)node); } else if (PURPLE_BLIST_NODE_IS_GROUP(node)) { pidgin_dialogs_remove_group((PurpleGroup*)node); } else if (PURPLE_BLIST_NODE_IS_CONTACT(node)) { pidgin_dialogs_remove_contact((PurpleContact*)node); } } struct _expand { GtkTreeView *treeview; GtkTreePath *path; PurpleBlistNode *node; }; static gboolean scroll_to_expanded_cell(gpointer data) { struct _expand *ex = data; gtk_tree_view_scroll_to_cell(ex->treeview, ex->path, NULL, FALSE, 0, 0); pidgin_blist_update_contact(NULL, ex->node); gtk_tree_path_free(ex->path); g_free(ex); return FALSE; } static void pidgin_blist_expand_contact_cb(GtkWidget *w, PurpleBlistNode *node) { struct _pidgin_blist_node *gtknode; GtkTreeIter iter, parent; PurpleBlistNode *bnode; GtkTreePath *path; if(!PURPLE_BLIST_NODE_IS_CONTACT(node)) return; gtknode = (struct _pidgin_blist_node *)node->ui_data; gtknode->contact_expanded = TRUE; for(bnode = node->child; bnode; bnode = bnode->next) { pidgin_blist_update(NULL, bnode); } /* This ensures that the bottom buddy is visible, i.e. not scrolled off the alignment */ if (get_iter_from_node(node, &parent)) { struct _expand *ex = g_new0(struct _expand, 1); gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(gtkblist->treemodel), &iter, &parent, gtk_tree_model_iter_n_children(GTK_TREE_MODEL(gtkblist->treemodel), &parent) -1); path = gtk_tree_model_get_path(GTK_TREE_MODEL(gtkblist->treemodel), &iter); /* Let the treeview draw so it knows where to scroll */ ex->treeview = GTK_TREE_VIEW(gtkblist->treeview); ex->path = path; ex->node = node->child; g_idle_add(scroll_to_expanded_cell, ex); } } static void pidgin_blist_collapse_contact_cb(GtkWidget *w, PurpleBlistNode *node) { PurpleBlistNode *bnode; struct _pidgin_blist_node *gtknode; if(!PURPLE_BLIST_NODE_IS_CONTACT(node)) return; gtknode = (struct _pidgin_blist_node *)node->ui_data; gtknode->contact_expanded = FALSE; for(bnode = node->child; bnode; bnode = bnode->next) { pidgin_blist_update(NULL, bnode); } } static void toggle_privacy(GtkWidget *widget, PurpleBlistNode *node) { PurpleBuddy *buddy; PurpleAccount *account; gboolean permitted; const char *name; if (!PURPLE_BLIST_NODE_IS_BUDDY(node)) return; buddy = (PurpleBuddy *)node; account = purple_buddy_get_account(buddy); name = purple_buddy_get_name(buddy); permitted = purple_privacy_check(account, name); /* XXX: Perhaps ask whether to restore the previous lists where appropirate? */ if (permitted) purple_privacy_deny(account, name, FALSE, FALSE); else purple_privacy_allow(account, name, FALSE, FALSE); pidgin_blist_update(purple_get_blist(), node); } void pidgin_append_blist_node_privacy_menu(GtkWidget *menu, PurpleBlistNode *node) { PurpleBuddy *buddy = (PurpleBuddy *)node; PurpleAccount *account; gboolean permitted; account = purple_buddy_get_account(buddy); permitted = purple_privacy_check(account, purple_buddy_get_name(buddy)); pidgin_new_item_from_stock(menu, permitted ? _("_Block") : _("Un_block"), permitted ? PIDGIN_STOCK_TOOLBAR_BLOCK : PIDGIN_STOCK_TOOLBAR_UNBLOCK, G_CALLBACK(toggle_privacy), node, 0 ,0, NULL); } void pidgin_append_blist_node_proto_menu(GtkWidget *menu, PurpleConnection *gc, PurpleBlistNode *node) { GList *l, *ll; PurplePluginProtocolInfo *prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl); if(!prpl_info || !prpl_info->blist_node_menu) return; for(l = ll = prpl_info->blist_node_menu(node); l; l = l->next) { PurpleMenuAction *act = (PurpleMenuAction *) l->data; pidgin_append_menu_action(menu, act, node); } g_list_free(ll); } void pidgin_append_blist_node_extended_menu(GtkWidget *menu, PurpleBlistNode *node) { GList *l, *ll; for(l = ll = purple_blist_node_get_extended_menu(node); l; l = l->next) { PurpleMenuAction *act = (PurpleMenuAction *) l->data; pidgin_append_menu_action(menu, act, node); } g_list_free(ll); } static void pidgin_append_blist_node_move_to_menu(GtkWidget *menu, PurpleBlistNode *node) { GtkWidget *submenu; GtkWidget *menuitem; PurpleBlistNode *group; menuitem = gtk_menu_item_new_with_label(_("Move to")); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem); gtk_widget_show(menuitem); submenu = gtk_menu_new(); gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), submenu); for (group = purple_blist_get_root(); group; group = group->next) { if (group->type != PURPLE_BLIST_GROUP_NODE) continue; if (group == node->parent) continue; menuitem = pidgin_new_item_from_stock(submenu, purple_group_get_name((PurpleGroup *)group), NULL, G_CALLBACK(gtk_blist_menu_move_to_cb), node, 0, 0, NULL); g_object_set_data(G_OBJECT(menuitem), "groupnode", group); } gtk_widget_show_all(submenu); } void pidgin_blist_make_buddy_menu(GtkWidget *menu, PurpleBuddy *buddy, gboolean sub) { PurplePluginProtocolInfo *prpl_info; PurpleContact *contact; PurpleBlistNode *node; gboolean contact_expanded = FALSE; gboolean show_offline = FALSE; g_return_if_fail(menu); g_return_if_fail(buddy); prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(buddy->account->gc->prpl); node = (PurpleBlistNode*)buddy; contact = purple_buddy_get_contact(buddy); if (contact) { contact_expanded = ((struct _pidgin_blist_node *)(((PurpleBlistNode*)contact)->ui_data))->contact_expanded; } if (prpl_info && prpl_info->get_info) { pidgin_new_item_from_stock(menu, _("Get _Info"), PIDGIN_STOCK_TOOLBAR_USER_INFO, G_CALLBACK(gtk_blist_menu_info_cb), buddy, 0, 0, NULL); } pidgin_new_item_from_stock(menu, _("I_M"), PIDGIN_STOCK_TOOLBAR_MESSAGE_NEW, G_CALLBACK(gtk_blist_menu_im_cb), buddy, 0, 0, NULL); #ifdef USE_VV if (prpl_info && prpl_info->get_media_caps) { PurpleAccount *account = purple_buddy_get_account(buddy); const gchar *who = purple_buddy_get_name(buddy); PurpleMediaCaps caps = purple_prpl_get_media_caps(account, who); if (caps & PURPLE_MEDIA_CAPS_AUDIO) { pidgin_new_item_from_stock(menu, _("_Audio Call"), PIDGIN_STOCK_TOOLBAR_AUDIO_CALL, G_CALLBACK(gtk_blist_menu_audio_call_cb), buddy, 0, 0, NULL); } if (caps & PURPLE_MEDIA_CAPS_AUDIO_VIDEO) { pidgin_new_item_from_stock(menu, _("Audio/_Video Call"), PIDGIN_STOCK_TOOLBAR_VIDEO_CALL, G_CALLBACK(gtk_blist_menu_video_call_cb), buddy, 0, 0, NULL); } else if (caps & PURPLE_MEDIA_CAPS_VIDEO) { pidgin_new_item_from_stock(menu, _("_Video Call"), PIDGIN_STOCK_TOOLBAR_VIDEO_CALL, G_CALLBACK(gtk_blist_menu_video_call_cb), buddy, 0, 0, NULL); } } #endif if (prpl_info && prpl_info->send_file) { if (!prpl_info->can_receive_file || prpl_info->can_receive_file(buddy->account->gc, buddy->name)) { pidgin_new_item_from_stock(menu, _("_Send File..."), PIDGIN_STOCK_TOOLBAR_SEND_FILE, G_CALLBACK(gtk_blist_menu_send_file_cb), buddy, 0, 0, NULL); } } pidgin_new_item_from_stock(menu, _("Add Buddy _Pounce..."), NULL, G_CALLBACK(gtk_blist_menu_bp_cb), buddy, 0, 0, NULL); if (node->parent && node->parent->child->next && !sub && !contact_expanded) { pidgin_new_item_from_stock(menu, _("View _Log"), NULL, G_CALLBACK(gtk_blist_menu_showlog_cb), contact, 0, 0, NULL); } else if (!sub) { pidgin_new_item_from_stock(menu, _("View _Log"), NULL, G_CALLBACK(gtk_blist_menu_showlog_cb), buddy, 0, 0, NULL); } if (!(purple_blist_node_get_flags(node) & PURPLE_BLIST_NODE_FLAG_NO_SAVE)) { show_offline = purple_blist_node_get_bool(node, "show_offline"); pidgin_new_item_from_stock(menu, show_offline ? _("Hide when offline") : _("Show when offline"), NULL, G_CALLBACK(gtk_blist_menu_showoffline_cb), node, 0, 0, NULL); } pidgin_append_blist_node_proto_menu(menu, buddy->account->gc, node); pidgin_append_blist_node_extended_menu(menu, node); if (!contact_expanded && contact != NULL) pidgin_append_blist_node_move_to_menu(menu, (PurpleBlistNode *)contact); if (node->parent && node->parent->child->next && !sub && !contact_expanded) { pidgin_separator(menu); pidgin_append_blist_node_privacy_menu(menu, node); pidgin_new_item_from_stock(menu, _("_Alias..."), PIDGIN_STOCK_ALIAS, G_CALLBACK(gtk_blist_menu_alias_cb), contact, 0, 0, NULL); pidgin_new_item_from_stock(menu, _("_Remove"), GTK_STOCK_REMOVE, G_CALLBACK(pidgin_blist_remove_cb), contact, 0, 0, NULL); } else if (!sub || contact_expanded) { pidgin_separator(menu); pidgin_append_blist_node_privacy_menu(menu, node); pidgin_new_item_from_stock(menu, _("_Alias..."), PIDGIN_STOCK_ALIAS, G_CALLBACK(gtk_blist_menu_alias_cb), buddy, 0, 0, NULL); pidgin_new_item_from_stock(menu, _("_Remove"), GTK_STOCK_REMOVE, G_CALLBACK(pidgin_blist_remove_cb), buddy, 0, 0, NULL); } } static gboolean gtk_blist_key_press_cb(GtkWidget *tv, GdkEventKey *event, gpointer data) { PurpleBlistNode *node; GValue val; GtkTreeIter iter; GtkTreeSelection *sel; sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(tv)); if(!gtk_tree_selection_get_selected(sel, NULL, &iter)) return FALSE; val.g_type = 0; gtk_tree_model_get_value(GTK_TREE_MODEL(gtkblist->treemodel), &iter, NODE_COLUMN, &val); node = g_value_get_pointer(&val); if(event->state & GDK_CONTROL_MASK && (event->keyval == 'o' || event->keyval == 'O')) { PurpleBuddy *buddy; if(PURPLE_BLIST_NODE_IS_CONTACT(node)) { buddy = purple_contact_get_priority_buddy((PurpleContact*)node); } else if(PURPLE_BLIST_NODE_IS_BUDDY(node)) { buddy = (PurpleBuddy*)node; } else { return FALSE; } if(buddy) pidgin_retrieve_user_info(buddy->account->gc, buddy->name); } else if (event->keyval == GDK_F2) { gtk_blist_menu_alias_cb(tv, node); } return FALSE; } static void set_node_custom_icon_cb(const gchar *filename, gpointer data) { if (filename) { PurpleBlistNode *node = (PurpleBlistNode*)data; purple_buddy_icons_node_set_custom_icon_from_file(node, filename); } } static void set_node_custom_icon(GtkWidget *w, PurpleBlistNode *node) { /* This doesn't keep track of the returned dialog (so that successive * calls could be made to re-display that dialog). Do we want that? */ GtkWidget *win = pidgin_buddy_icon_chooser_new(NULL, set_node_custom_icon_cb, node); gtk_widget_show_all(win); } static void remove_node_custom_icon(GtkWidget *w, PurpleBlistNode *node) { purple_buddy_icons_node_set_custom_icon(node, NULL, 0); } static void add_buddy_icon_menu_items(GtkWidget *menu, PurpleBlistNode *node) { GtkWidget *item; pidgin_new_item_from_stock(menu, _("Set Custom Icon"), NULL, G_CALLBACK(set_node_custom_icon), node, 0, 0, NULL); item = pidgin_new_item_from_stock(menu, _("Remove Custom Icon"), NULL, G_CALLBACK(remove_node_custom_icon), node, 0, 0, NULL); if (!purple_buddy_icons_node_has_custom_icon(node)) gtk_widget_set_sensitive(item, FALSE); } static GtkWidget * create_group_menu (PurpleBlistNode *node, PurpleGroup *g) { GtkWidget *menu; GtkWidget *item; menu = gtk_menu_new(); item = pidgin_new_item_from_stock(menu, _("Add _Buddy..."), GTK_STOCK_ADD, G_CALLBACK(pidgin_blist_add_buddy_cb), node, 0, 0, NULL); gtk_widget_set_sensitive(item, purple_connections_get_all() != NULL); item = pidgin_new_item_from_stock(menu, _("Add C_hat..."), GTK_STOCK_ADD, G_CALLBACK(pidgin_blist_add_chat_cb), node, 0, 0, NULL); gtk_widget_set_sensitive(item, pidgin_blist_joinchat_is_showable()); pidgin_new_item_from_stock(menu, _("_Delete Group"), GTK_STOCK_REMOVE, G_CALLBACK(pidgin_blist_remove_cb), node, 0, 0, NULL); pidgin_new_item_from_stock(menu, _("_Rename"), NULL, G_CALLBACK(gtk_blist_menu_alias_cb), node, 0, 0, NULL); if (!(purple_blist_node_get_flags(node) & PURPLE_BLIST_NODE_FLAG_NO_SAVE)) { gboolean show_offline = purple_blist_node_get_bool(node, "show_offline"); pidgin_new_item_from_stock(menu, show_offline ? _("Hide when offline") : _("Show when offline"), NULL, G_CALLBACK(gtk_blist_menu_showoffline_cb), node, 0, 0, NULL); } add_buddy_icon_menu_items(menu, node); pidgin_append_blist_node_extended_menu(menu, node); return menu; } static GtkWidget * create_chat_menu(PurpleBlistNode *node, PurpleChat *c) { GtkWidget *menu; gboolean autojoin, persistent; menu = gtk_menu_new(); autojoin = (purple_blist_node_get_bool(node, "gtk-autojoin") || (purple_blist_node_get_string(node, "gtk-autojoin") != NULL)); persistent = purple_blist_node_get_bool(node, "gtk-persistent"); pidgin_new_item_from_stock(menu, _("_Join"), PIDGIN_STOCK_CHAT, G_CALLBACK(gtk_blist_menu_join_cb), node, 0, 0, NULL); pidgin_new_check_item(menu, _("Auto-Join"), G_CALLBACK(gtk_blist_menu_autojoin_cb), node, autojoin); pidgin_new_check_item(menu, _("Persistent"), G_CALLBACK(gtk_blist_menu_persistent_cb), node, persistent); pidgin_new_item_from_stock(menu, _("View _Log"), NULL, G_CALLBACK(gtk_blist_menu_showlog_cb), node, 0, 0, NULL); pidgin_append_blist_node_proto_menu(menu, c->account->gc, node); pidgin_append_blist_node_extended_menu(menu, node); pidgin_separator(menu); pidgin_new_item_from_stock(menu, _("_Edit Settings..."), NULL, G_CALLBACK(chat_components_edit), node, 0, 0, NULL); pidgin_new_item_from_stock(menu, _("_Alias..."), PIDGIN_STOCK_ALIAS, G_CALLBACK(gtk_blist_menu_alias_cb), node, 0, 0, NULL); pidgin_new_item_from_stock(menu, _("_Remove"), GTK_STOCK_REMOVE, G_CALLBACK(pidgin_blist_remove_cb), node, 0, 0, NULL); add_buddy_icon_menu_items(menu, node); return menu; } static GtkWidget * create_contact_menu (PurpleBlistNode *node) { GtkWidget *menu; menu = gtk_menu_new(); pidgin_new_item_from_stock(menu, _("View _Log"), NULL, G_CALLBACK(gtk_blist_menu_showlog_cb), node, 0, 0, NULL); pidgin_separator(menu); pidgin_new_item_from_stock(menu, _("_Alias..."), PIDGIN_STOCK_ALIAS, G_CALLBACK(gtk_blist_menu_alias_cb), node, 0, 0, NULL); pidgin_new_item_from_stock(menu, _("_Remove"), GTK_STOCK_REMOVE, G_CALLBACK(pidgin_blist_remove_cb), node, 0, 0, NULL); add_buddy_icon_menu_items(menu, node); pidgin_separator(menu); pidgin_new_item_from_stock(menu, _("_Collapse"), GTK_STOCK_ZOOM_OUT, G_CALLBACK(pidgin_blist_collapse_contact_cb), node, 0, 0, NULL); pidgin_append_blist_node_extended_menu(menu, node); return menu; } static GtkWidget * create_buddy_menu(PurpleBlistNode *node, PurpleBuddy *b) { struct _pidgin_blist_node *gtknode = (struct _pidgin_blist_node *)node->ui_data; GtkWidget *menu; GtkWidget *menuitem; gboolean show_offline = purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/blist/show_offline_buddies"); menu = gtk_menu_new(); pidgin_blist_make_buddy_menu(menu, b, FALSE); if(PURPLE_BLIST_NODE_IS_CONTACT(node)) { pidgin_separator(menu); add_buddy_icon_menu_items(menu, node); if(gtknode->contact_expanded) { pidgin_new_item_from_stock(menu, _("_Collapse"), GTK_STOCK_ZOOM_OUT, G_CALLBACK(pidgin_blist_collapse_contact_cb), node, 0, 0, NULL); } else { pidgin_new_item_from_stock(menu, _("_Expand"), GTK_STOCK_ZOOM_IN, G_CALLBACK(pidgin_blist_expand_contact_cb), node, 0, 0, NULL); } if(node->child->next) { PurpleBlistNode *bnode; for(bnode = node->child; bnode; bnode = bnode->next) { PurpleBuddy *buddy = (PurpleBuddy*)bnode; GdkPixbuf *buf; GtkWidget *submenu; GtkWidget *image; if(buddy == b) continue; if(!buddy->account->gc) continue; if(!show_offline && !PURPLE_BUDDY_IS_ONLINE(buddy)) continue; menuitem = gtk_image_menu_item_new_with_label(buddy->name); buf = pidgin_create_prpl_icon(buddy->account,PIDGIN_PRPL_ICON_SMALL); image = gtk_image_new_from_pixbuf(buf); g_object_unref(G_OBJECT(buf)); gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menuitem), image); gtk_widget_show(image); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem); gtk_widget_show(menuitem); submenu = gtk_menu_new(); gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), submenu); gtk_widget_show(submenu); pidgin_blist_make_buddy_menu(submenu, buddy, TRUE); } } } return menu; } static gboolean pidgin_blist_show_context_menu(PurpleBlistNode *node, GtkMenuPositionFunc func, GtkWidget *tv, guint button, guint32 time) { struct _pidgin_blist_node *gtknode; GtkWidget *menu = NULL; gboolean handled = FALSE; gtknode = (struct _pidgin_blist_node *)node->ui_data; /* Create a menu based on the thing we right-clicked on */ if (PURPLE_BLIST_NODE_IS_GROUP(node)) { PurpleGroup *g = (PurpleGroup *)node; menu = create_group_menu(node, g); } else if (PURPLE_BLIST_NODE_IS_CHAT(node)) { PurpleChat *c = (PurpleChat *)node; menu = create_chat_menu(node, c); } else if ((PURPLE_BLIST_NODE_IS_CONTACT(node)) && (gtknode->contact_expanded)) { menu = create_contact_menu(node); } else if (PURPLE_BLIST_NODE_IS_CONTACT(node) || PURPLE_BLIST_NODE_IS_BUDDY(node)) { PurpleBuddy *b; if (PURPLE_BLIST_NODE_IS_CONTACT(node)) b = purple_contact_get_priority_buddy((PurpleContact*)node); else b = (PurpleBuddy *)node; menu = create_buddy_menu(node, b); } #ifdef _WIN32 pidgin_blist_tooltip_destroy(); /* Unhook the tooltip-timeout since we don't want a tooltip * to appear and obscure the context menu we are about to show This is a workaround for GTK+ bug 107320. */ if (gtkblist->timeout) { g_source_remove(gtkblist->timeout); gtkblist->timeout = 0; } #endif /* Now display the menu */ if (menu != NULL) { gtk_widget_show_all(menu); gtk_menu_popup(GTK_MENU(menu), NULL, NULL, func, tv, button, time); handled = TRUE; } return handled; } static gboolean gtk_blist_button_press_cb(GtkWidget *tv, GdkEventButton *event, gpointer user_data) { GtkTreePath *path; PurpleBlistNode *node; GValue val; GtkTreeIter iter; GtkTreeSelection *sel; PurplePlugin *prpl = NULL; PurplePluginProtocolInfo *prpl_info = NULL; struct _pidgin_blist_node *gtknode; gboolean handled = FALSE; /* Here we figure out which node was clicked */ if (!gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(tv), event->x, event->y, &path, NULL, NULL, NULL)) return FALSE; gtk_tree_model_get_iter(GTK_TREE_MODEL(gtkblist->treemodel), &iter, path); val.g_type = 0; gtk_tree_model_get_value(GTK_TREE_MODEL(gtkblist->treemodel), &iter, NODE_COLUMN, &val); node = g_value_get_pointer(&val); gtknode = (struct _pidgin_blist_node *)node->ui_data; /* Right click draws a context menu */ if ((event->button == 3) && (event->type == GDK_BUTTON_PRESS)) { handled = pidgin_blist_show_context_menu(node, NULL, tv, 3, event->time); /* CTRL+middle click expands or collapse a contact */ } else if ((event->button == 2) && (event->type == GDK_BUTTON_PRESS) && (event->state & GDK_CONTROL_MASK) && (PURPLE_BLIST_NODE_IS_CONTACT(node))) { if (gtknode->contact_expanded) pidgin_blist_collapse_contact_cb(NULL, node); else pidgin_blist_expand_contact_cb(NULL, node); handled = TRUE; /* Double middle click gets info */ } else if ((event->button == 2) && (event->type == GDK_2BUTTON_PRESS) && ((PURPLE_BLIST_NODE_IS_CONTACT(node)) || (PURPLE_BLIST_NODE_IS_BUDDY(node)))) { PurpleBuddy *b; if(PURPLE_BLIST_NODE_IS_CONTACT(node)) b = purple_contact_get_priority_buddy((PurpleContact*)node); else b = (PurpleBuddy *)node; prpl = purple_find_prpl(purple_account_get_protocol_id(b->account)); if (prpl != NULL) prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(prpl); if (prpl && prpl_info->get_info) pidgin_retrieve_user_info(b->account->gc, b->name); handled = TRUE; } #if (1) /* * This code only exists because GTK+ doesn't work. If we return * FALSE here, as would be normal the event propoagates down and * somehow gets interpreted as the start of a drag event. * * Um, isn't it _normal_ to return TRUE here? Since the event * was handled? --Mark */ if(handled) { sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(tv)); gtk_tree_selection_select_path(sel, path); gtk_tree_path_free(path); return TRUE; } #endif gtk_tree_path_free(path); return FALSE; } static gboolean pidgin_blist_popup_menu_cb(GtkWidget *tv, void *user_data) { PurpleBlistNode *node; GValue val; GtkTreeIter iter; GtkTreeSelection *sel; gboolean handled = FALSE; sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(tv)); if (!gtk_tree_selection_get_selected(sel, NULL, &iter)) return FALSE; val.g_type = 0; gtk_tree_model_get_value(GTK_TREE_MODEL(gtkblist->treemodel), &iter, NODE_COLUMN, &val); node = g_value_get_pointer(&val); /* Shift+F10 draws a context menu */ handled = pidgin_blist_show_context_menu(node, pidgin_treeview_popup_menu_position_func, tv, 0, GDK_CURRENT_TIME); return handled; } static void pidgin_blist_buddy_details_cb(gpointer data, guint action, GtkWidget *item) { pidgin_set_cursor(gtkblist->window, GDK_WATCH); purple_prefs_set_bool(PIDGIN_PREFS_ROOT "/blist/show_buddy_icons", gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(item))); pidgin_clear_cursor(gtkblist->window); } static void pidgin_blist_show_idle_time_cb(gpointer data, guint action, GtkWidget *item) { pidgin_set_cursor(gtkblist->window, GDK_WATCH); purple_prefs_set_bool(PIDGIN_PREFS_ROOT "/blist/show_idle_time", gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(item))); pidgin_clear_cursor(gtkblist->window); } static void pidgin_blist_show_protocol_icons_cb(gpointer data, guint action, GtkWidget *item) { purple_prefs_set_bool(PIDGIN_PREFS_ROOT "/blist/show_protocol_icons", gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(item))); } static void pidgin_blist_show_empty_groups_cb(gpointer data, guint action, GtkWidget *item) { pidgin_set_cursor(gtkblist->window, GDK_WATCH); purple_prefs_set_bool(PIDGIN_PREFS_ROOT "/blist/show_empty_groups", gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(item))); pidgin_clear_cursor(gtkblist->window); } static void pidgin_blist_edit_mode_cb(gpointer callback_data, guint callback_action, GtkWidget *checkitem) { pidgin_set_cursor(gtkblist->window, GDK_WATCH); purple_prefs_set_bool(PIDGIN_PREFS_ROOT "/blist/show_offline_buddies", gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(checkitem))); pidgin_clear_cursor(gtkblist->window); } static void pidgin_blist_mute_sounds_cb(gpointer data, guint action, GtkWidget *item) { purple_prefs_set_bool(PIDGIN_PREFS_ROOT "/sound/mute", GTK_CHECK_MENU_ITEM(item)->active); } static void pidgin_blist_mute_pref_cb(const char *name, PurplePrefType type, gconstpointer value, gpointer data) { gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(gtk_item_factory_get_item(gtkblist->ift, N_("/Tools/Mute Sounds"))), (gboolean)GPOINTER_TO_INT(value)); } static void pidgin_blist_sound_method_pref_cb(const char *name, PurplePrefType type, gconstpointer value, gpointer data) { gboolean sensitive = TRUE; if(!strcmp(value, "none")) sensitive = FALSE; gtk_widget_set_sensitive(gtk_item_factory_get_widget(gtkblist->ift, N_("/Tools/Mute Sounds")), sensitive); } static void add_buddies_from_vcard(const char *prpl_id, PurpleGroup *group, GList *list, const char *alias) { GList *l; PurpleAccount *account = NULL; PurpleConnection *gc; if (list == NULL) return; for (l = purple_connections_get_all(); l != NULL; l = l->next) { gc = (PurpleConnection *)l->data; account = purple_connection_get_account(gc); if (!strcmp(purple_account_get_protocol_id(account), prpl_id)) break; account = NULL; } if (account != NULL) { for (l = list; l != NULL; l = l->next) { purple_blist_request_add_buddy(account, l->data, (group ? group->name : NULL), alias); } } g_list_foreach(list, (GFunc)g_free, NULL); g_list_free(list); } static gboolean parse_vcard(const char *vcard, PurpleGroup *group) { char *temp_vcard; char *s, *c; char *alias = NULL; GList *aims = NULL; GList *icqs = NULL; GList *yahoos = NULL; GList *msns = NULL; GList *jabbers = NULL; s = temp_vcard = g_strdup(vcard); while (*s != '\0' && strncmp(s, "END:vCard", strlen("END:vCard"))) { char *field, *value; field = s; /* Grab the field */ while (*s != '\r' && *s != '\n' && *s != '\0' && *s != ':') s++; if (*s == '\r') s++; if (*s == '\n') { s++; continue; } if (*s != '\0') *s++ = '\0'; if ((c = strchr(field, ';')) != NULL) *c = '\0'; /* Proceed to the end of the line */ value = s; while (*s != '\r' && *s != '\n' && *s != '\0') s++; if (*s == '\r') *s++ = '\0'; if (*s == '\n') *s++ = '\0'; /* We only want to worry about a few fields here. */ if (!strcmp(field, "FN")) alias = g_strdup(value); else if (!strcmp(field, "X-AIM") || !strcmp(field, "X-ICQ") || !strcmp(field, "X-YAHOO") || !strcmp(field, "X-MSN") || !strcmp(field, "X-JABBER")) { char **values = g_strsplit(value, ":", 0); char **im; for (im = values; *im != NULL; im++) { if (!strcmp(field, "X-AIM")) aims = g_list_append(aims, g_strdup(*im)); else if (!strcmp(field, "X-ICQ")) icqs = g_list_append(icqs, g_strdup(*im)); else if (!strcmp(field, "X-YAHOO")) yahoos = g_list_append(yahoos, g_strdup(*im)); else if (!strcmp(field, "X-MSN")) msns = g_list_append(msns, g_strdup(*im)); else if (!strcmp(field, "X-JABBER")) jabbers = g_list_append(jabbers, g_strdup(*im)); } g_strfreev(values); } } g_free(temp_vcard); if (aims == NULL && icqs == NULL && yahoos == NULL && msns == NULL && jabbers == NULL) { g_free(alias); return FALSE; } add_buddies_from_vcard("prpl-oscar", group, aims, alias); add_buddies_from_vcard("prpl-oscar", group, icqs, alias); add_buddies_from_vcard("prpl-yahoo", group, yahoos, alias); add_buddies_from_vcard("prpl-msn", group, msns, alias); add_buddies_from_vcard("prpl-jabber", group, jabbers, alias); g_free(alias); return TRUE; } #ifdef _WIN32 static void pidgin_blist_drag_begin(GtkWidget *widget, GdkDragContext *drag_context, gpointer user_data) { pidgin_blist_tooltip_destroy(); /* Unhook the tooltip-timeout since we don't want a tooltip * to appear and obscure the dragging operation. * This is a workaround for GTK+ bug 107320. */ if (gtkblist->timeout) { g_source_remove(gtkblist->timeout); gtkblist->timeout = 0; } } #endif static void pidgin_blist_drag_data_get_cb(GtkWidget *widget, GdkDragContext *dc, GtkSelectionData *data, guint info, guint time, gpointer null) { if (data->target == gdk_atom_intern("PURPLE_BLIST_NODE", FALSE)) { GtkTreeRowReference *ref = g_object_get_data(G_OBJECT(dc), "gtk-tree-view-source-row"); GtkTreePath *sourcerow = gtk_tree_row_reference_get_path(ref); GtkTreeIter iter; PurpleBlistNode *node = NULL; GValue val; if(!sourcerow) return; gtk_tree_model_get_iter(GTK_TREE_MODEL(gtkblist->treemodel), &iter, sourcerow); val.g_type = 0; gtk_tree_model_get_value (GTK_TREE_MODEL(gtkblist->treemodel), &iter, NODE_COLUMN, &val); node = g_value_get_pointer(&val); gtk_selection_data_set (data, gdk_atom_intern ("PURPLE_BLIST_NODE", FALSE), 8, /* bits */ (void*)&node, sizeof (node)); gtk_tree_path_free(sourcerow); } else if (data->target == gdk_atom_intern("application/x-im-contact", FALSE)) { GtkTreeRowReference *ref; GtkTreePath *sourcerow; GtkTreeIter iter; PurpleBlistNode *node = NULL; PurpleBuddy *buddy; PurpleConnection *gc; GValue val; GString *str; const char *protocol; ref = g_object_get_data(G_OBJECT(dc), "gtk-tree-view-source-row"); sourcerow = gtk_tree_row_reference_get_path(ref); if (!sourcerow) return; gtk_tree_model_get_iter(GTK_TREE_MODEL(gtkblist->treemodel), &iter, sourcerow); val.g_type = 0; gtk_tree_model_get_value(GTK_TREE_MODEL(gtkblist->treemodel), &iter, NODE_COLUMN, &val); node = g_value_get_pointer(&val); if (PURPLE_BLIST_NODE_IS_CONTACT(node)) { buddy = purple_contact_get_priority_buddy((PurpleContact *)node); } else if (!PURPLE_BLIST_NODE_IS_BUDDY(node)) { gtk_tree_path_free(sourcerow); return; } else { buddy = (PurpleBuddy *)node; } gc = purple_account_get_connection(buddy->account); if (gc == NULL) { gtk_tree_path_free(sourcerow); return; } protocol = PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl)->list_icon(buddy->account, buddy); str = g_string_new(NULL); g_string_printf(str, "MIME-Version: 1.0\r\n" "Content-Type: application/x-im-contact\r\n" "X-IM-Protocol: %s\r\n" "X-IM-Username: %s\r\n", protocol, buddy->name); if (buddy->alias != NULL) { g_string_append_printf(str, "X-IM-Alias: %s\r\n", buddy->alias); } g_string_append(str, "\r\n"); gtk_selection_data_set(data, gdk_atom_intern("application/x-im-contact", FALSE), 8, /* bits */ (const guchar *)str->str, strlen(str->str) + 1); g_string_free(str, TRUE); gtk_tree_path_free(sourcerow); } } static void pidgin_blist_drag_data_rcv_cb(GtkWidget *widget, GdkDragContext *dc, guint x, guint y, GtkSelectionData *sd, guint info, guint t) { if (gtkblist->drag_timeout) { g_source_remove(gtkblist->drag_timeout); gtkblist->drag_timeout = 0; } if (sd->target == gdk_atom_intern("PURPLE_BLIST_NODE", FALSE) && sd->data) { PurpleBlistNode *n = NULL; GtkTreePath *path = NULL; GtkTreeViewDropPosition position; memcpy(&n, sd->data, sizeof(n)); if(gtk_tree_view_get_dest_row_at_pos(GTK_TREE_VIEW(widget), x, y, &path, &position)) { /* if we're here, I think it means the drop is ok */ GtkTreeIter iter; PurpleBlistNode *node; GValue val; struct _pidgin_blist_node *gtknode; gtk_tree_model_get_iter(GTK_TREE_MODEL(gtkblist->treemodel), &iter, path); val.g_type = 0; gtk_tree_model_get_value (GTK_TREE_MODEL(gtkblist->treemodel), &iter, NODE_COLUMN, &val); node = g_value_get_pointer(&val); gtknode = node->ui_data; if (PURPLE_BLIST_NODE_IS_CONTACT(n)) { PurpleContact *c = (PurpleContact*)n; if (PURPLE_BLIST_NODE_IS_CONTACT(node) && gtknode->contact_expanded) { purple_blist_merge_contact(c, node); } else if (PURPLE_BLIST_NODE_IS_CONTACT(node) || PURPLE_BLIST_NODE_IS_CHAT(node)) { switch(position) { case GTK_TREE_VIEW_DROP_AFTER: case GTK_TREE_VIEW_DROP_INTO_OR_AFTER: purple_blist_add_contact(c, (PurpleGroup*)node->parent, node); break; case GTK_TREE_VIEW_DROP_BEFORE: case GTK_TREE_VIEW_DROP_INTO_OR_BEFORE: purple_blist_add_contact(c, (PurpleGroup*)node->parent, node->prev); break; } } else if(PURPLE_BLIST_NODE_IS_GROUP(node)) { purple_blist_add_contact(c, (PurpleGroup*)node, NULL); } else if(PURPLE_BLIST_NODE_IS_BUDDY(node)) { purple_blist_merge_contact(c, node); } } else if (PURPLE_BLIST_NODE_IS_BUDDY(n)) { PurpleBuddy *b = (PurpleBuddy*)n; if (PURPLE_BLIST_NODE_IS_BUDDY(node)) { switch(position) { case GTK_TREE_VIEW_DROP_AFTER: case GTK_TREE_VIEW_DROP_INTO_OR_AFTER: purple_blist_add_buddy(b, (PurpleContact*)node->parent, (PurpleGroup*)node->parent->parent, node); break; case GTK_TREE_VIEW_DROP_BEFORE: case GTK_TREE_VIEW_DROP_INTO_OR_BEFORE: purple_blist_add_buddy(b, (PurpleContact*)node->parent, (PurpleGroup*)node->parent->parent, node->prev); break; } } else if(PURPLE_BLIST_NODE_IS_CHAT(node)) { purple_blist_add_buddy(b, NULL, (PurpleGroup*)node->parent, NULL); } else if (PURPLE_BLIST_NODE_IS_GROUP(node)) { purple_blist_add_buddy(b, NULL, (PurpleGroup*)node, NULL); } else if (PURPLE_BLIST_NODE_IS_CONTACT(node)) { if(gtknode->contact_expanded) { switch(position) { case GTK_TREE_VIEW_DROP_INTO_OR_AFTER: case GTK_TREE_VIEW_DROP_AFTER: case GTK_TREE_VIEW_DROP_INTO_OR_BEFORE: purple_blist_add_buddy(b, (PurpleContact*)node, (PurpleGroup*)node->parent, NULL); break; case GTK_TREE_VIEW_DROP_BEFORE: purple_blist_add_buddy(b, NULL, (PurpleGroup*)node->parent, node->prev); break; } } else { switch(position) { case GTK_TREE_VIEW_DROP_INTO_OR_AFTER: case GTK_TREE_VIEW_DROP_AFTER: purple_blist_add_buddy(b, NULL, (PurpleGroup*)node->parent, NULL); break; case GTK_TREE_VIEW_DROP_INTO_OR_BEFORE: case GTK_TREE_VIEW_DROP_BEFORE: purple_blist_add_buddy(b, NULL, (PurpleGroup*)node->parent, node->prev); break; } } } } else if (PURPLE_BLIST_NODE_IS_CHAT(n)) { PurpleChat *chat = (PurpleChat *)n; if (PURPLE_BLIST_NODE_IS_BUDDY(node)) { switch(position) { case GTK_TREE_VIEW_DROP_AFTER: case GTK_TREE_VIEW_DROP_INTO_OR_AFTER: case GTK_TREE_VIEW_DROP_BEFORE: case GTK_TREE_VIEW_DROP_INTO_OR_BEFORE: purple_blist_add_chat(chat, (PurpleGroup*)node->parent->parent, node->parent); break; } } else if(PURPLE_BLIST_NODE_IS_CONTACT(node) || PURPLE_BLIST_NODE_IS_CHAT(node)) { switch(position) { case GTK_TREE_VIEW_DROP_AFTER: case GTK_TREE_VIEW_DROP_INTO_OR_AFTER: purple_blist_add_chat(chat, (PurpleGroup*)node->parent, node); break; case GTK_TREE_VIEW_DROP_BEFORE: case GTK_TREE_VIEW_DROP_INTO_OR_BEFORE: purple_blist_add_chat(chat, (PurpleGroup*)node->parent, node->prev); break; } } else if (PURPLE_BLIST_NODE_IS_GROUP(node)) { purple_blist_add_chat(chat, (PurpleGroup*)node, NULL); } } else if (PURPLE_BLIST_NODE_IS_GROUP(n)) { PurpleGroup *g = (PurpleGroup*)n; if (PURPLE_BLIST_NODE_IS_GROUP(node)) { switch (position) { case GTK_TREE_VIEW_DROP_INTO_OR_AFTER: case GTK_TREE_VIEW_DROP_AFTER: purple_blist_add_group(g, node); break; case GTK_TREE_VIEW_DROP_INTO_OR_BEFORE: case GTK_TREE_VIEW_DROP_BEFORE: purple_blist_add_group(g, node->prev); break; } } else if(PURPLE_BLIST_NODE_IS_BUDDY(node)) { purple_blist_add_group(g, node->parent->parent); } else if(PURPLE_BLIST_NODE_IS_CONTACT(node) || PURPLE_BLIST_NODE_IS_CHAT(node)) { purple_blist_add_group(g, node->parent); } } gtk_tree_path_free(path); gtk_drag_finish(dc, TRUE, (dc->action == GDK_ACTION_MOVE), t); } } else if (sd->target == gdk_atom_intern("application/x-im-contact", FALSE) && sd->data) { PurpleGroup *group = NULL; GtkTreePath *path = NULL; GtkTreeViewDropPosition position; PurpleAccount *account; char *protocol = NULL; char *username = NULL; char *alias = NULL; if (gtk_tree_view_get_dest_row_at_pos(GTK_TREE_VIEW(widget), x, y, &path, &position)) { GtkTreeIter iter; PurpleBlistNode *node; GValue val; gtk_tree_model_get_iter(GTK_TREE_MODEL(gtkblist->treemodel), &iter, path); val.g_type = 0; gtk_tree_model_get_value (GTK_TREE_MODEL(gtkblist->treemodel), &iter, NODE_COLUMN, &val); node = g_value_get_pointer(&val); if (PURPLE_BLIST_NODE_IS_BUDDY(node)) { group = (PurpleGroup *)node->parent->parent; } else if (PURPLE_BLIST_NODE_IS_CHAT(node) || PURPLE_BLIST_NODE_IS_CONTACT(node)) { group = (PurpleGroup *)node->parent; } else if (PURPLE_BLIST_NODE_IS_GROUP(node)) { group = (PurpleGroup *)node; } } if (pidgin_parse_x_im_contact((const char *)sd->data, FALSE, &account, &protocol, &username, &alias)) { if (account == NULL) { purple_notify_error(NULL, NULL, _("You are not currently signed on with an account that " "can add that buddy."), NULL); } else { purple_blist_request_add_buddy(account, username, (group ? group->name : NULL), alias); } } g_free(username); g_free(protocol); g_free(alias); if (path != NULL) gtk_tree_path_free(path); gtk_drag_finish(dc, TRUE, (dc->action == GDK_ACTION_MOVE), t); } else if (sd->target == gdk_atom_intern("text/x-vcard", FALSE) && sd->data) { gboolean result; PurpleGroup *group = NULL; GtkTreePath *path = NULL; GtkTreeViewDropPosition position; if (gtk_tree_view_get_dest_row_at_pos(GTK_TREE_VIEW(widget), x, y, &path, &position)) { GtkTreeIter iter; PurpleBlistNode *node; GValue val; gtk_tree_model_get_iter(GTK_TREE_MODEL(gtkblist->treemodel), &iter, path); val.g_type = 0; gtk_tree_model_get_value (GTK_TREE_MODEL(gtkblist->treemodel), &iter, NODE_COLUMN, &val); node = g_value_get_pointer(&val); if (PURPLE_BLIST_NODE_IS_BUDDY(node)) { group = (PurpleGroup *)node->parent->parent; } else if (PURPLE_BLIST_NODE_IS_CHAT(node) || PURPLE_BLIST_NODE_IS_CONTACT(node)) { group = (PurpleGroup *)node->parent; } else if (PURPLE_BLIST_NODE_IS_GROUP(node)) { group = (PurpleGroup *)node; } } result = parse_vcard((const gchar *)sd->data, group); gtk_drag_finish(dc, result, (dc->action == GDK_ACTION_MOVE), t); } else if (sd->target == gdk_atom_intern("text/uri-list", FALSE) && sd->data) { GtkTreePath *path = NULL; GtkTreeViewDropPosition position; if (gtk_tree_view_get_dest_row_at_pos(GTK_TREE_VIEW(widget), x, y, &path, &position)) { GtkTreeIter iter; PurpleBlistNode *node; GValue val; gtk_tree_model_get_iter(GTK_TREE_MODEL(gtkblist->treemodel), &iter, path); val.g_type = 0; gtk_tree_model_get_value (GTK_TREE_MODEL(gtkblist->treemodel), &iter, NODE_COLUMN, &val); node = g_value_get_pointer(&val); if (PURPLE_BLIST_NODE_IS_BUDDY(node) || PURPLE_BLIST_NODE_IS_CONTACT(node)) { PurpleBuddy *b = PURPLE_BLIST_NODE_IS_BUDDY(node) ? PURPLE_BUDDY(node) : purple_contact_get_priority_buddy(PURPLE_CONTACT(node)); pidgin_dnd_file_manage(sd, b->account, b->name); gtk_drag_finish(dc, TRUE, (dc->action == GDK_ACTION_MOVE), t); } else { gtk_drag_finish(dc, FALSE, FALSE, t); } } } } /* Altered from do_colorshift in gnome-panel */ static void do_alphashift (GdkPixbuf *dest, GdkPixbuf *src, int shift) { gint i, j; gint width, height, has_alpha, srcrowstride, destrowstride; guchar *target_pixels; guchar *original_pixels; guchar *pixsrc; guchar *pixdest; int val; guchar a; has_alpha = gdk_pixbuf_get_has_alpha (src); if (!has_alpha) return; width = gdk_pixbuf_get_width (src); height = gdk_pixbuf_get_height (src); srcrowstride = gdk_pixbuf_get_rowstride (src); destrowstride = gdk_pixbuf_get_rowstride (dest); target_pixels = gdk_pixbuf_get_pixels (dest); original_pixels = gdk_pixbuf_get_pixels (src); for (i = 0; i < height; i++) { pixdest = target_pixels + i*destrowstride; pixsrc = original_pixels + i*srcrowstride; for (j = 0; j < width; j++) { *(pixdest++) = *(pixsrc++); *(pixdest++) = *(pixsrc++); *(pixdest++) = *(pixsrc++); a = *(pixsrc++); val = a - shift; *(pixdest++) = CLAMP(val, 0, 255); } } } static GdkPixbuf *pidgin_blist_get_buddy_icon(PurpleBlistNode *node, gboolean scaled, gboolean greyed) { gsize len; GdkPixbufLoader *loader; PurpleBuddy *buddy = NULL; PurpleGroup *group = NULL; const guchar *data = NULL; GdkPixbuf *buf, *ret = NULL; PurpleBuddyIcon *icon = NULL; PurpleAccount *account = NULL; PurpleContact *contact = NULL; PurpleStoredImage *custom_img; PurplePluginProtocolInfo *prpl_info = NULL; gint orig_width, orig_height, scale_width, scale_height; if (PURPLE_BLIST_NODE_IS_CONTACT(node)) { buddy = purple_contact_get_priority_buddy((PurpleContact*)node); contact = (PurpleContact*)node; } else if (PURPLE_BLIST_NODE_IS_BUDDY(node)) { buddy = (PurpleBuddy*)node; contact = purple_buddy_get_contact(buddy); } else if (PURPLE_BLIST_NODE_IS_GROUP(node)) { group = (PurpleGroup*)node; } else if (PURPLE_BLIST_NODE_IS_CHAT(node)) { /* We don't need to do anything here. We just need to not fall * into the else block and return. */ } else { return NULL; } if (buddy) { account = purple_buddy_get_account(buddy); } if(account && account->gc) { prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(account->gc->prpl); } #if 0 if (!purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/blist/show_buddy_icons")) return NULL; #endif /* If we have a contact then this is either a contact or a buddy and * we want to fetch the custom icon for the contact. If we don't have * a contact then this is a group or some other type of node and we * want to use that directly. */ if (contact) { custom_img = purple_buddy_icons_node_find_custom_icon((PurpleBlistNode*)contact); } else { custom_img = purple_buddy_icons_node_find_custom_icon(node); } if (custom_img) { data = purple_imgstore_get_data(custom_img); len = purple_imgstore_get_size(custom_img); } if (data == NULL) { if (buddy) { /* Not sure I like this...*/ if (!(icon = purple_buddy_icons_find(buddy->account, buddy->name))) return NULL; data = purple_buddy_icon_get_data(icon, &len); } if(data == NULL) return NULL; } loader = gdk_pixbuf_loader_new(); gdk_pixbuf_loader_write(loader, data, len, NULL); gdk_pixbuf_loader_close(loader, NULL); purple_imgstore_unref(custom_img); purple_buddy_icon_unref(icon); buf = gdk_pixbuf_loader_get_pixbuf(loader); if (buf) g_object_ref(G_OBJECT(buf)); g_object_unref(G_OBJECT(loader)); if (!buf) { return NULL; } if (greyed) { gboolean offline = FALSE, idle = FALSE; if (buddy) { PurplePresence *presence = purple_buddy_get_presence(buddy); if (!PURPLE_BUDDY_IS_ONLINE(buddy)) offline = TRUE; if (purple_presence_is_idle(presence)) idle = TRUE; } else if (group) { if (purple_blist_get_group_online_count(group) == 0) offline = TRUE; } if (offline) gdk_pixbuf_saturate_and_pixelate(buf, buf, 0.0, FALSE); if (idle) gdk_pixbuf_saturate_and_pixelate(buf, buf, 0.25, FALSE); } /* I'd use the pidgin_buddy_icon_get_scale_size() thing, but it won't * tell me the original size, which I need for scaling purposes. */ scale_width = orig_width = gdk_pixbuf_get_width(buf); scale_height = orig_height = gdk_pixbuf_get_height(buf); if (prpl_info && prpl_info->icon_spec.scale_rules & PURPLE_ICON_SCALE_DISPLAY) purple_buddy_icon_get_scale_size(&prpl_info->icon_spec, &scale_width, &scale_height); if (scaled || scale_height > 200 || scale_width > 200) { GdkPixbuf *tmpbuf; float scale_size = scaled ? 32.0 : 200.0; if(scale_height > scale_width) { scale_width = scale_size * (double)scale_width / (double)scale_height; scale_height = scale_size; } else { scale_height = scale_size * (double)scale_height / (double)scale_width; scale_width = scale_size; } /* Scale & round before making square, so rectangular (but * non-square) images get rounded corners too. */ tmpbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, scale_width, scale_height); gdk_pixbuf_fill(tmpbuf, 0x00000000); gdk_pixbuf_scale(buf, tmpbuf, 0, 0, scale_width, scale_height, 0, 0, (double)scale_width/(double)orig_width, (double)scale_height/(double)orig_height, GDK_INTERP_BILINEAR); if (pidgin_gdk_pixbuf_is_opaque(tmpbuf)) pidgin_gdk_pixbuf_make_round(tmpbuf); ret = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, scale_size, scale_size); gdk_pixbuf_fill(ret, 0x00000000); gdk_pixbuf_copy_area(tmpbuf, 0, 0, scale_width, scale_height, ret, (scale_size-scale_width)/2, (scale_size-scale_height)/2); g_object_unref(G_OBJECT(tmpbuf)); } else { ret = gdk_pixbuf_scale_simple(buf,scale_width,scale_height, GDK_INTERP_BILINEAR); } g_object_unref(G_OBJECT(buf)); return ret; } /* # - Status Icon * P - Protocol Icon * A - Buddy Icon * [ - SMALL_SPACE * = - LARGE_SPACE * +--- STATUS_SIZE +--- td->avatar_width * | +-- td->name_width | * +----+ +-------+ +---------+ * | | | | | | * +-------------------------------------------+ * | [ = [ |--- TOOLTIP_BORDER *name_height --+-| ######[BuddyName = PP [ AAAAAAAAAAA |--+ * | | ######[ = PP [ AAAAAAAAAAA | | * STATUS SIZE -| | ######[[[[[[[[[[[[[[[[[[[[[ AAAAAAAAAAA | | * +--+-| ######[Account: So-and-so [ AAAAAAAAAAA | |-- td->avatar_height * | | [Idle: 4h 15m [ AAAAAAAAAAA | | * height --+ | [Foo: Bar, Baz [ AAAAAAAAAAA | | * | | [Status: Awesome [ AAAAAAAAAAA |--+ * +----| [Stop: Hammer Time [ | * | [ [ |--- TOOLTIP_BORDER * +-------------------------------------------+ * | | | | * | +----------------+ | * | | | * | +-- td->width | * | | * +---- TOOLTIP_BORDER +---- TOOLTIP_BORDER * * */ #define STATUS_SIZE 16 #define TOOLTIP_BORDER 12 #define SMALL_SPACE 6 #define LARGE_SPACE 12 #define PRPL_SIZE 16 struct tooltip_data { PangoLayout *layout; PangoLayout *name_layout; GdkPixbuf *prpl_icon; GdkPixbuf *status_icon; GdkPixbuf *avatar; gboolean avatar_is_prpl_icon; int avatar_width; int avatar_height; int name_height; int name_width; int width; int height; int padding; }; static PangoLayout * create_pango_layout(const char *markup, int *width, int *height) { PangoLayout *layout; int w, h; layout = gtk_widget_create_pango_layout(gtkblist->tipwindow, NULL); pango_layout_set_markup(layout, markup, -1); pango_layout_set_wrap(layout, PANGO_WRAP_WORD); pango_layout_set_width(layout, 300000); pango_layout_get_size (layout, &w, &h); if (width) *width = PANGO_PIXELS(w); if (height) *height = PANGO_PIXELS(h); return layout; } static struct tooltip_data * create_tip_for_account(PurpleAccount *account) { struct tooltip_data *td = g_new0(struct tooltip_data, 1); td->status_icon = pidgin_create_prpl_icon(account, PIDGIN_PRPL_ICON_SMALL); /* Yes, status_icon, not prpl_icon */ if (purple_account_is_disconnected(account)) gdk_pixbuf_saturate_and_pixelate(td->status_icon, td->status_icon, 0.0, FALSE); td->layout = create_pango_layout(purple_account_get_username(account), &td->width, &td->height); td->padding = SMALL_SPACE; return td; } static struct tooltip_data * create_tip_for_node(PurpleBlistNode *node, gboolean full) { struct tooltip_data *td = g_new0(struct tooltip_data, 1); PurpleAccount *account = NULL; char *tmp = NULL, *node_name = NULL, *tooltip_text = NULL; if (PURPLE_BLIST_NODE_IS_BUDDY(node)) { account = ((PurpleBuddy*)(node))->account; } else if (PURPLE_BLIST_NODE_IS_CHAT(node)) { account = ((PurpleChat*)(node))->account; } td->padding = TOOLTIP_BORDER; td->status_icon = pidgin_blist_get_status_icon(node, PIDGIN_STATUS_ICON_LARGE); td->avatar = pidgin_blist_get_buddy_icon(node, !full, FALSE); if (account != NULL) { td->prpl_icon = pidgin_create_prpl_icon(account, PIDGIN_PRPL_ICON_SMALL); } tooltip_text = pidgin_get_tooltip_text(node, full); if (tooltip_text && *tooltip_text) { td->layout = create_pango_layout(tooltip_text, &td->width, &td->height); } if (PURPLE_BLIST_NODE_IS_BUDDY(node)) { tmp = g_markup_escape_text(purple_buddy_get_name((PurpleBuddy*)node), -1); } else if (PURPLE_BLIST_NODE_IS_CHAT(node)) { tmp = g_markup_escape_text(purple_chat_get_name((PurpleChat*)node), -1); } else if (PURPLE_BLIST_NODE_IS_GROUP(node)) { tmp = g_markup_escape_text(purple_group_get_name((PurpleGroup*)node), -1); } else { /* I don't believe this can happen currently, I think * everything that calls this function checks for one of the * above node types first. */ tmp = g_strdup(_("Unknown node type")); } node_name = g_strdup_printf("<span size='x-large' weight='bold'>%s</span>", tmp ? tmp : ""); g_free(tmp); td->name_layout = create_pango_layout(node_name, &td->name_width, &td->name_height); td->name_width += SMALL_SPACE + PRPL_SIZE; td->name_height = MAX(td->name_height, PRPL_SIZE + SMALL_SPACE); #if 0 /* PRPL Icon as avatar */ if(!td->avatar && full) { td->avatar = pidgin_create_prpl_icon(account, PIDGIN_PRPL_ICON_LARGE); td->avatar_is_prpl_icon = TRUE; } #endif if (td->avatar) { td->avatar_width = gdk_pixbuf_get_width(td->avatar); td->avatar_height = gdk_pixbuf_get_height(td->avatar); } g_free(node_name); g_free(tooltip_text); return td; } static gboolean pidgin_blist_paint_tip(GtkWidget *widget, gpointer null) { GtkStyle *style; int current_height, max_width; int max_text_width; int max_avatar_width; GList *l; int prpl_col = 0; GtkTextDirection dir = gtk_widget_get_direction(widget); int status_size = 0; if(gtkblist->tooltipdata == NULL) return FALSE; style = gtkblist->tipwindow->style; max_text_width = 0; max_avatar_width = 0; for(l = gtkblist->tooltipdata; l; l = l->next) { struct tooltip_data *td = l->data; max_text_width = MAX(max_text_width, MAX(td->width, td->name_width)); max_avatar_width = MAX(max_avatar_width, td->avatar_width); if (td->status_icon) status_size = STATUS_SIZE; } max_width = TOOLTIP_BORDER + status_size + SMALL_SPACE + max_text_width + SMALL_SPACE + max_avatar_width + TOOLTIP_BORDER; if (dir == GTK_TEXT_DIR_RTL) prpl_col = TOOLTIP_BORDER + max_avatar_width + SMALL_SPACE; else prpl_col = TOOLTIP_BORDER + status_size + SMALL_SPACE + max_text_width - PRPL_SIZE; current_height = 12; for(l = gtkblist->tooltipdata; l; l = l->next) { struct tooltip_data *td = l->data; if (td->avatar && pidgin_gdk_pixbuf_is_opaque(td->avatar)) { if (dir == GTK_TEXT_DIR_RTL) gtk_paint_flat_box(style, gtkblist->tipwindow->window, GTK_STATE_NORMAL, GTK_SHADOW_OUT, NULL, gtkblist->tipwindow, "tooltip", TOOLTIP_BORDER -1, current_height -1, td->avatar_width +2, td->avatar_height + 2); else gtk_paint_flat_box(style, gtkblist->tipwindow->window, GTK_STATE_NORMAL, GTK_SHADOW_OUT, NULL, gtkblist->tipwindow, "tooltip", max_width - (td->avatar_width+ TOOLTIP_BORDER)-1, current_height-1,td->avatar_width+2, td->avatar_height+2); } #if GTK_CHECK_VERSION(2,2,0) if (td->status_icon) { if (dir == GTK_TEXT_DIR_RTL) gdk_draw_pixbuf(GDK_DRAWABLE(gtkblist->tipwindow->window), NULL, td->status_icon, 0, 0, max_width - TOOLTIP_BORDER - status_size, current_height, -1, -1, GDK_RGB_DITHER_NONE, 0, 0); else gdk_draw_pixbuf(GDK_DRAWABLE(gtkblist->tipwindow->window), NULL, td->status_icon, 0, 0, TOOLTIP_BORDER, current_height, -1 , -1, GDK_RGB_DITHER_NONE, 0, 0); } if(td->avatar) { if (dir == GTK_TEXT_DIR_RTL) gdk_draw_pixbuf(GDK_DRAWABLE(gtkblist->tipwindow->window), NULL, td->avatar, 0, 0, TOOLTIP_BORDER, current_height, -1, -1, GDK_RGB_DITHER_NONE, 0, 0); else gdk_draw_pixbuf(GDK_DRAWABLE(gtkblist->tipwindow->window), NULL, td->avatar, 0, 0, max_width - (td->avatar_width + TOOLTIP_BORDER), current_height, -1 , -1, GDK_RGB_DITHER_NONE, 0, 0); } if (!td->avatar_is_prpl_icon && td->prpl_icon) gdk_draw_pixbuf(GDK_DRAWABLE(gtkblist->tipwindow->window), NULL, td->prpl_icon, 0, 0, prpl_col, current_height + ((td->name_height / 2) - (PRPL_SIZE / 2)), -1 , -1, GDK_RGB_DITHER_NONE, 0, 0); #else if (td->status_icon) { gdk_pixbuf_render_to_drawable(td->status_icon, GDK_DRAWABLE(gtkblist->tipwindow->window), NULL, 0, 0, 12, current_height, -1, -1, GDK_RGB_DITHER_NONE, 0, 0); } if(td->avatar) gdk_pixbuf_render_to_drawable(td->avatar, GDK_DRAWABLE(gtkblist->tipwindow->window), NULL, 0, 0, max_width - (td->avatar_width + TOOLTIP_BORDER), current_height, -1, -1, GDK_RGB_DITHER_NONE, 0, 0); #endif if (td->name_layout) { if (dir == GTK_TEXT_DIR_RTL) { gtk_paint_layout(style, gtkblist->tipwindow->window, GTK_STATE_NORMAL, FALSE, NULL, gtkblist->tipwindow, "tooltip", max_width -(TOOLTIP_BORDER + status_size + SMALL_SPACE) - PANGO_PIXELS(300000), current_height, td->name_layout); } else { gtk_paint_layout (style, gtkblist->tipwindow->window, GTK_STATE_NORMAL, FALSE, NULL, gtkblist->tipwindow, "tooltip", TOOLTIP_BORDER + status_size + SMALL_SPACE, current_height, td->name_layout); } } if (td->layout) { if (dir != GTK_TEXT_DIR_RTL) { gtk_paint_layout (style, gtkblist->tipwindow->window, GTK_STATE_NORMAL, FALSE, NULL, gtkblist->tipwindow, "tooltip", TOOLTIP_BORDER + status_size + SMALL_SPACE, current_height + td->name_height, td->layout); } else { gtk_paint_layout(style, gtkblist->tipwindow->window, GTK_STATE_NORMAL, FALSE, NULL, gtkblist->tipwindow, "tooltip", max_width - (TOOLTIP_BORDER + status_size + SMALL_SPACE) - PANGO_PIXELS(300000), current_height + td->name_height, td->layout); } } current_height += MAX(td->name_height + td->height, td->avatar_height) + td->padding; } return FALSE; } static void pidgin_blist_destroy_tooltip_data(void) { while(gtkblist->tooltipdata) { struct tooltip_data *td = gtkblist->tooltipdata->data; if(td->avatar) g_object_unref(td->avatar); if(td->status_icon) g_object_unref(td->status_icon); if(td->prpl_icon) g_object_unref(td->prpl_icon); if (td->layout) g_object_unref(td->layout); if (td->name_layout) g_object_unref(td->name_layout); g_free(td); gtkblist->tooltipdata = g_list_delete_link(gtkblist->tooltipdata, gtkblist->tooltipdata); } } void pidgin_blist_tooltip_destroy() { pidgin_blist_destroy_tooltip_data(); pidgin_tooltip_destroy(); } static void pidgin_blist_align_tooltip(struct tooltip_data *td, GtkWidget *widget) { GtkTextDirection dir = gtk_widget_get_direction(widget); if (dir == GTK_TEXT_DIR_RTL) { char* layout_name = purple_markup_strip_html(pango_layout_get_text(td->name_layout)); PangoDirection dir = pango_find_base_dir(layout_name, -1); if (dir == PANGO_DIRECTION_RTL || dir == PANGO_DIRECTION_NEUTRAL) pango_layout_set_alignment(td->name_layout, PANGO_ALIGN_RIGHT); g_free(layout_name); pango_layout_set_alignment(td->layout, PANGO_ALIGN_RIGHT); } } static gboolean pidgin_blist_create_tooltip_for_node(GtkWidget *widget, gpointer data, int *w, int *h) { PurpleBlistNode *node = data; int width, height; GList *list; int max_text_width = 0; int max_avatar_width = 0; int status_size = 0; if (gtkblist->tooltipdata) { gtkblist->tipwindow = NULL; pidgin_blist_destroy_tooltip_data(); } gtkblist->tipwindow = widget; if (PURPLE_BLIST_NODE_IS_CHAT(node) || PURPLE_BLIST_NODE_IS_BUDDY(node)) { struct tooltip_data *td = create_tip_for_node(node, TRUE); pidgin_blist_align_tooltip(td, gtkblist->tipwindow); gtkblist->tooltipdata = g_list_append(gtkblist->tooltipdata, td); } else if (PURPLE_BLIST_NODE_IS_GROUP(node)) { PurpleGroup *group = (PurpleGroup*)node; GSList *accounts; struct tooltip_data *td = create_tip_for_node(node, TRUE); pidgin_blist_align_tooltip(td, gtkblist->tipwindow); gtkblist->tooltipdata = g_list_append(gtkblist->tooltipdata, td); /* Accounts with buddies in group */ accounts = purple_group_get_accounts(group); for (; accounts != NULL; accounts = g_slist_delete_link(accounts, accounts)) { PurpleAccount *account = accounts->data; td = create_tip_for_account(account); gtkblist->tooltipdata = g_list_append(gtkblist->tooltipdata, td); } } else if (PURPLE_BLIST_NODE_IS_CONTACT(node)) { PurpleBlistNode *child; PurpleBuddy *b = purple_contact_get_priority_buddy((PurpleContact *)node); width = height = 0; for(child = node->child; child; child = child->next) { if(PURPLE_BLIST_NODE_IS_BUDDY(child) && buddy_is_displayable((PurpleBuddy*)child)) { struct tooltip_data *td = create_tip_for_node(child, (b == (PurpleBuddy*)child)); pidgin_blist_align_tooltip(td, gtkblist->tipwindow); if (b == (PurpleBuddy *)child) { gtkblist->tooltipdata = g_list_prepend(gtkblist->tooltipdata, td); } else { gtkblist->tooltipdata = g_list_append(gtkblist->tooltipdata, td); } } } } else { return FALSE; } height = width = 0; for (list = gtkblist->tooltipdata; list; list = list->next) { struct tooltip_data *td = list->data; max_text_width = MAX(max_text_width, MAX(td->width, td->name_width)); max_avatar_width = MAX(max_avatar_width, td->avatar_width); height += MAX(MAX(STATUS_SIZE, td->avatar_height), td->height + td->name_height) + td->padding; if (td->status_icon) status_size = MAX(status_size, STATUS_SIZE); } height += TOOLTIP_BORDER; width = TOOLTIP_BORDER + status_size + SMALL_SPACE + max_text_width + SMALL_SPACE + max_avatar_width + TOOLTIP_BORDER; if (w) *w = width; if (h) *h = height; return TRUE; } static gboolean pidgin_blist_expand_timeout(GtkWidget *tv) { GtkTreePath *path; GtkTreeIter iter; PurpleBlistNode *node; GValue val; struct _pidgin_blist_node *gtknode; if (!gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(tv), gtkblist->tip_rect.x, gtkblist->tip_rect.y + (gtkblist->tip_rect.height/2), &path, NULL, NULL, NULL)) return FALSE; gtk_tree_model_get_iter(GTK_TREE_MODEL(gtkblist->treemodel), &iter, path); val.g_type = 0; gtk_tree_model_get_value (GTK_TREE_MODEL(gtkblist->treemodel), &iter, NODE_COLUMN, &val); node = g_value_get_pointer(&val); if(!PURPLE_BLIST_NODE_IS_CONTACT(node)) { gtk_tree_path_free(path); return FALSE; } gtknode = node->ui_data; if (!gtknode->contact_expanded) { GtkTreeIter i; pidgin_blist_expand_contact_cb(NULL, node); gtk_tree_view_get_cell_area(GTK_TREE_VIEW(tv), path, NULL, >kblist->contact_rect); gdk_drawable_get_size(GDK_DRAWABLE(tv->window), &(gtkblist->contact_rect.width), NULL); gtkblist->mouseover_contact = node; gtk_tree_path_down (path); while (gtk_tree_model_get_iter(GTK_TREE_MODEL(gtkblist->treemodel), &i, path)) { GdkRectangle rect; gtk_tree_view_get_cell_area(GTK_TREE_VIEW(tv), path, NULL, &rect); gtkblist->contact_rect.height += rect.height; gtk_tree_path_next(path); } } gtk_tree_path_free(path); return FALSE; } static gboolean buddy_is_displayable(PurpleBuddy *buddy) { struct _pidgin_blist_node *gtknode; if(!buddy) return FALSE; gtknode = ((PurpleBlistNode*)buddy)->ui_data; return (purple_account_is_connected(buddy->account) && (purple_presence_is_online(buddy->presence) || (gtknode && gtknode->recent_signonoff) || purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/blist/show_offline_buddies") || purple_blist_node_get_bool((PurpleBlistNode*)buddy, "show_offline"))); } void pidgin_blist_draw_tooltip(PurpleBlistNode *node, GtkWidget *widget) { pidgin_tooltip_show(widget, node, pidgin_blist_create_tooltip_for_node, pidgin_blist_paint_tip); } static gboolean pidgin_blist_drag_motion_cb(GtkWidget *tv, GdkDragContext *drag_context, gint x, gint y, guint time, gpointer user_data) { GtkTreePath *path; int delay; GdkRectangle rect; /* * When dragging a buddy into a contact, this is the delay before * the contact auto-expands. */ delay = 900; if (gtkblist->drag_timeout) { if ((y > gtkblist->tip_rect.y) && ((y - gtkblist->tip_rect.height) < gtkblist->tip_rect.y)) return FALSE; /* We've left the cell. Remove the timeout and create a new one below */ g_source_remove(gtkblist->drag_timeout); } gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(tv), x, y, &path, NULL, NULL, NULL); gtk_tree_view_get_cell_area(GTK_TREE_VIEW(tv), path, NULL, &rect); if (path) gtk_tree_path_free(path); /* Only autoexpand when in the middle of the cell to avoid annoying un-intended expands */ if (y < rect.y + (rect.height / 3) || y > rect.y + (2 * (rect.height /3))) return FALSE; rect.height = rect.height / 3; rect.y += rect.height; gtkblist->tip_rect = rect; gtkblist->drag_timeout = g_timeout_add(delay, (GSourceFunc)pidgin_blist_expand_timeout, tv); if (gtkblist->mouseover_contact) { if ((y < gtkblist->contact_rect.y) || ((y - gtkblist->contact_rect.height) > gtkblist->contact_rect.y)) { pidgin_blist_collapse_contact_cb(NULL, gtkblist->mouseover_contact); gtkblist->mouseover_contact = NULL; } } return FALSE; } static gboolean pidgin_blist_create_tooltip(GtkWidget *widget, GtkTreePath *path, gpointer null, int *w, int *h) { GtkTreeIter iter; PurpleBlistNode *node; GValue val; gboolean editable = FALSE; /* If we're editing a cell (e.g. alias editing), don't show the tooltip */ g_object_get(G_OBJECT(gtkblist->text_rend), "editable", &editable, NULL); if (editable) return FALSE; if (gtkblist->tooltipdata) { gtkblist->tipwindow = NULL; pidgin_blist_destroy_tooltip_data(); } gtk_tree_model_get_iter(GTK_TREE_MODEL(gtkblist->treemodel), &iter, path); val.g_type = 0; gtk_tree_model_get_value (GTK_TREE_MODEL(gtkblist->treemodel), &iter, NODE_COLUMN, &val); node = g_value_get_pointer(&val); return pidgin_blist_create_tooltip_for_node(widget, node, w, h); } static gboolean pidgin_blist_motion_cb (GtkWidget *tv, GdkEventMotion *event, gpointer null) { if (gtkblist->mouseover_contact) { if ((event->y < gtkblist->contact_rect.y) || ((event->y - gtkblist->contact_rect.height) > gtkblist->contact_rect.y)) { pidgin_blist_collapse_contact_cb(NULL, gtkblist->mouseover_contact); gtkblist->mouseover_contact = NULL; } } return FALSE; } static gboolean pidgin_blist_leave_cb (GtkWidget *w, GdkEventCrossing *e, gpointer n) { if (gtkblist->timeout) { g_source_remove(gtkblist->timeout); gtkblist->timeout = 0; } if (gtkblist->drag_timeout) { g_source_remove(gtkblist->drag_timeout); gtkblist->drag_timeout = 0; } if (gtkblist->mouseover_contact && !((e->x > gtkblist->contact_rect.x) && (e->x < (gtkblist->contact_rect.x + gtkblist->contact_rect.width)) && (e->y > gtkblist->contact_rect.y) && (e->y < (gtkblist->contact_rect.y + gtkblist->contact_rect.height)))) { pidgin_blist_collapse_contact_cb(NULL, gtkblist->mouseover_contact); gtkblist->mouseover_contact = NULL; } return FALSE; } static void toggle_debug(void) { purple_prefs_set_bool(PIDGIN_PREFS_ROOT "/debug/enabled", !purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/debug/enabled")); } /*************************************************** * Crap * ***************************************************/ static GtkItemFactoryEntry blist_menu[] = { /* Buddies menu */ { N_("/_Buddies"), NULL, NULL, 0, "<Branch>", NULL }, { N_("/Buddies/New Instant _Message..."), "<CTL>M", pidgin_dialogs_im, 0, "<StockItem>", PIDGIN_STOCK_TOOLBAR_MESSAGE_NEW }, { N_("/Buddies/Join a _Chat..."), "<CTL>C", pidgin_blist_joinchat_show, 0, "<StockItem>", PIDGIN_STOCK_CHAT }, { N_("/Buddies/Get User _Info..."), "<CTL>I", pidgin_dialogs_info, 0, "<StockItem>", PIDGIN_STOCK_TOOLBAR_USER_INFO }, { N_("/Buddies/View User _Log..."), "<CTL>L", pidgin_dialogs_log, 0, "<Item>", NULL }, { "/Buddies/sep1", NULL, NULL, 0, "<Separator>", NULL }, { N_("/Buddies/Sh_ow"), NULL, NULL, 0, "<Branch>", NULL}, { N_("/Buddies/Show/_Offline Buddies"), NULL, pidgin_blist_edit_mode_cb, 1, "<CheckItem>", NULL }, { N_("/Buddies/Show/_Empty Groups"), NULL, pidgin_blist_show_empty_groups_cb, 1, "<CheckItem>", NULL }, { N_("/Buddies/Show/Buddy _Details"), NULL, pidgin_blist_buddy_details_cb, 1, "<CheckItem>", NULL }, { N_("/Buddies/Show/Idle _Times"), NULL, pidgin_blist_show_idle_time_cb, 1, "<CheckItem>", NULL }, { N_("/Buddies/Show/_Protocol Icons"), NULL, pidgin_blist_show_protocol_icons_cb, 1, "<CheckItem>", NULL }, { N_("/Buddies/_Sort Buddies"), NULL, NULL, 0, "<Branch>", NULL }, { "/Buddies/sep2", NULL, NULL, 0, "<Separator>", NULL }, { N_("/Buddies/_Add Buddy..."), "<CTL>B", pidgin_blist_add_buddy_cb, 0, "<StockItem>", GTK_STOCK_ADD }, { N_("/Buddies/Add C_hat..."), NULL, pidgin_blist_add_chat_cb, 0, "<StockItem>", GTK_STOCK_ADD }, { N_("/Buddies/Add _Group..."), NULL, purple_blist_request_add_group, 0, "<StockItem>", GTK_STOCK_ADD }, { "/Buddies/sep3", NULL, NULL, 0, "<Separator>", NULL }, { N_("/Buddies/_Quit"), "<CTL>Q", purple_core_quit, 0, "<StockItem>", GTK_STOCK_QUIT }, /* Accounts menu */ { N_("/_Accounts"), NULL, NULL, 0, "<Branch>", NULL }, { N_("/Accounts/Manage Accounts"), "<CTL>A", pidgin_accounts_window_show, 0, "<Item>", NULL }, /* Tools */ { N_("/_Tools"), NULL, NULL, 0, "<Branch>", NULL }, { N_("/Tools/Buddy _Pounces"), NULL, pidgin_pounces_manager_show, 1, "<Item>", NULL }, { N_("/Tools/_Certificates"), NULL, pidgin_certmgr_show, 0, "<Item>", NULL }, { N_("/Tools/Custom Smile_ys"), "<CTL>Y", pidgin_smiley_manager_show, 0, "<StockItem>", PIDGIN_STOCK_TOOLBAR_SMILEY }, { N_("/Tools/Plu_gins"), "<CTL>U", pidgin_plugin_dialog_show, 2, "<StockItem>", PIDGIN_STOCK_TOOLBAR_PLUGINS }, { N_("/Tools/Pr_eferences"), "<CTL>P", pidgin_prefs_show, 0, "<StockItem>", GTK_STOCK_PREFERENCES }, { N_("/Tools/Pr_ivacy"), NULL, pidgin_privacy_dialog_show, 0, "<Item>", NULL }, { "/Tools/sep2", NULL, NULL, 0, "<Separator>", NULL }, { N_("/Tools/_File Transfers"), "<CTL>T", pidgin_xfer_dialog_show, 0, "<StockItem>", PIDGIN_STOCK_TOOLBAR_TRANSFER }, { N_("/Tools/R_oom List"), NULL, pidgin_roomlist_dialog_show, 0, "<Item>", NULL }, { N_("/Tools/System _Log"), NULL, gtk_blist_show_systemlog_cb, 3, "<Item>", NULL }, { "/Tools/sep3", NULL, NULL, 0, "<Separator>", NULL }, { N_("/Tools/Mute _Sounds"), NULL, pidgin_blist_mute_sounds_cb, 0, "<CheckItem>", NULL }, /* Help */ { N_("/_Help"), NULL, NULL, 0, "<Branch>", NULL }, { N_("/Help/Online _Help"), "F1", gtk_blist_show_onlinehelp_cb, 0, "<StockItem>", GTK_STOCK_HELP }, { N_("/Help/_Debug Window"), NULL, toggle_debug, 0, "<Item>", NULL }, #if GTK_CHECK_VERSION(2,6,0) { N_("/Help/_About"), NULL, pidgin_dialogs_about, 4, "<StockItem>", GTK_STOCK_ABOUT }, #else { N_("/Help/_About"), NULL, pidgin_dialogs_about, 4, "<Item>", NULL }, #endif }; /********************************************************* * Private Utility functions * *********************************************************/ static char *pidgin_get_tooltip_text(PurpleBlistNode *node, gboolean full) { GString *str = g_string_new(""); PurplePlugin *prpl; PurplePluginProtocolInfo *prpl_info = NULL; char *tmp; if (PURPLE_BLIST_NODE_IS_CHAT(node)) { PurpleChat *chat; GList *connections; GList *cur; struct proto_chat_entry *pce; char *name, *value; PurpleConversation *conv; PidginBlistNode *bnode = node->ui_data; chat = (PurpleChat *)node; prpl = purple_find_prpl(purple_account_get_protocol_id(chat->account)); prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(prpl); connections = purple_connections_get_all(); if (connections && connections->next) { tmp = g_markup_escape_text(chat->account->username, -1); g_string_append_printf(str, _("<b>Account:</b> %s"), tmp); g_free(tmp); } if (bnode && bnode->conv.conv) { conv = bnode->conv.conv; } else { char *chat_name; if (prpl_info && prpl_info->get_chat_name) chat_name = prpl_info->get_chat_name(chat->components); else chat_name = g_strdup(purple_chat_get_name(chat)); conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_CHAT, chat_name, chat->account); g_free(chat_name); } if (conv && !purple_conv_chat_has_left(PURPLE_CONV_CHAT(conv))) { g_string_append_printf(str, _("\n<b>Occupants:</b> %d"), g_list_length(purple_conv_chat_get_users(PURPLE_CONV_CHAT(conv)))); if (prpl_info && (prpl_info->options & OPT_PROTO_CHAT_TOPIC)) { const char *chattopic = purple_conv_chat_get_topic(PURPLE_CONV_CHAT(conv)); char *topic = chattopic ? g_markup_escape_text(chattopic, -1) : NULL; g_string_append_printf(str, _("\n<b>Topic:</b> %s"), topic ? topic : _("(no topic set)")); g_free(topic); } } if (prpl_info && prpl_info->chat_info != NULL) cur = prpl_info->chat_info(chat->account->gc); else cur = NULL; while (cur != NULL) { pce = cur->data; if (!pce->secret && (!pce->required && g_hash_table_lookup(chat->components, pce->identifier) == NULL)) { tmp = purple_text_strip_mnemonic(pce->label); name = g_markup_escape_text(tmp, -1); g_free(tmp); value = g_markup_escape_text(g_hash_table_lookup( chat->components, pce->identifier), -1); g_string_append_printf(str, "\n<b>%s</b> %s", name ? name : "", value ? value : ""); g_free(name); g_free(value); } g_free(pce); cur = g_list_remove(cur, pce); } } else if (PURPLE_BLIST_NODE_IS_CONTACT(node) || PURPLE_BLIST_NODE_IS_BUDDY(node)) { /* NOTE: THIS FUNCTION IS NO LONGER CALLED FOR CONTACTS. * It is only called by create_tip_for_node(), and create_tip_for_node() is never called for a contact. */ PurpleContact *c; PurpleBuddy *b; PurplePresence *presence; PurpleNotifyUserInfo *user_info; GList *connections; char *tmp; time_t idle_secs, signon; if (PURPLE_BLIST_NODE_IS_CONTACT(node)) { c = (PurpleContact *)node; b = purple_contact_get_priority_buddy(c); } else { b = (PurpleBuddy *)node; c = purple_buddy_get_contact(b); } prpl = purple_find_prpl(purple_account_get_protocol_id(b->account)); prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(prpl); presence = purple_buddy_get_presence(b); user_info = purple_notify_user_info_new(); /* Account */ connections = purple_connections_get_all(); if (full && connections && connections->next) { tmp = g_markup_escape_text(purple_account_get_username( purple_buddy_get_account(b)), -1); purple_notify_user_info_add_pair(user_info, _("Account"), tmp); g_free(tmp); } /* Alias */ /* If there's not a contact alias, the node is being displayed with * this alias, so there's no point in showing it in the tooltip. */ if (full && c && b->alias != NULL && b->alias[0] != '\0' && (c->alias != NULL && c->alias[0] != '\0') && strcmp(c->alias, b->alias) != 0) { tmp = g_markup_escape_text(b->alias, -1); purple_notify_user_info_add_pair(user_info, _("Buddy Alias"), tmp); g_free(tmp); } /* Nickname/Server Alias */ /* I'd like to only show this if there's a contact or buddy * alias, but many people on MSN set long nicknames, which * get ellipsized, so the only way to see the whole thing is * to look at the tooltip. */ if (full && b->server_alias != NULL && b->server_alias[0] != '\0') { tmp = g_markup_escape_text(b->server_alias, -1); purple_notify_user_info_add_pair(user_info, _("Nickname"), tmp); g_free(tmp); } /* Logged In */ signon = purple_presence_get_login_time(presence); if (full && PURPLE_BUDDY_IS_ONLINE(b) && signon > 0) { if (signon > time(NULL)) { /* * They signed on in the future?! Our local clock * must be wrong, show the actual date instead of * "4 days", etc. */ tmp = g_strdup(purple_date_format_long(localtime(&signon))); } else tmp = purple_str_seconds_to_string(time(NULL) - signon); purple_notify_user_info_add_pair(user_info, _("Logged In"), tmp); g_free(tmp); } /* Idle */ if (purple_presence_is_idle(presence)) { idle_secs = purple_presence_get_idle_time(presence); if (idle_secs > 0) { tmp = purple_str_seconds_to_string(time(NULL) - idle_secs); purple_notify_user_info_add_pair(user_info, _("Idle"), tmp); g_free(tmp); } } /* Last Seen */ if (full && c && !PURPLE_BUDDY_IS_ONLINE(b)) { struct _pidgin_blist_node *gtknode = ((PurpleBlistNode *)c)->ui_data; PurpleBlistNode *bnode; int lastseen = 0; if (gtknode && (!gtknode->contact_expanded || PURPLE_BLIST_NODE_IS_CONTACT(node))) { /* We're either looking at a buddy for a collapsed contact or * an expanded contact itself so we show the most recent * (largest) last_seen time for any of the buddies under * the contact. */ for (bnode = ((PurpleBlistNode *)c)->child ; bnode != NULL ; bnode = bnode->next) { int value = purple_blist_node_get_int(bnode, "last_seen"); if (value > lastseen) lastseen = value; } } else { /* We're dealing with a buddy under an expanded contact, * so we show the last_seen time for the buddy. */ lastseen = purple_blist_node_get_int(&b->node, "last_seen"); } if (lastseen > 0) { tmp = purple_str_seconds_to_string(time(NULL) - lastseen); purple_notify_user_info_add_pair(user_info, _("Last Seen"), tmp); g_free(tmp); } } /* Offline? */ /* FIXME: Why is this status special-cased by the core? -- rlaager */ if (!PURPLE_BUDDY_IS_ONLINE(b)) { purple_notify_user_info_add_pair(user_info, _("Status"), _("Offline")); } if (purple_account_is_connected(b->account) && prpl_info && prpl_info->tooltip_text) { /* Additional text from the PRPL */ prpl_info->tooltip_text(b, user_info, full); } /* These are Easter Eggs. Patches to remove them will be rejected. */ if (!g_ascii_strcasecmp(b->name, "robflynn")) purple_notify_user_info_add_pair(user_info, _("Description"), _("Spooky")); if (!g_ascii_strcasecmp(b->name, "seanegn")) purple_notify_user_info_add_pair(user_info, _("Status"), _("Awesome")); if (!g_ascii_strcasecmp(b->name, "chipx86")) purple_notify_user_info_add_pair(user_info, _("Status"), _("Rockin'")); tmp = purple_notify_user_info_get_text_with_newline(user_info, "\n"); g_string_append(str, tmp); g_free(tmp); purple_notify_user_info_destroy(user_info); } else if (PURPLE_BLIST_NODE_IS_GROUP(node)) { gint count; PurpleGroup *group = (PurpleGroup*)node; PurpleNotifyUserInfo *user_info; user_info = purple_notify_user_info_new(); count = purple_blist_get_group_online_count(group); if (count != 0) { /* Online buddies in group */ tmp = g_strdup_printf("%d", count); purple_notify_user_info_add_pair(user_info, _("Online Buddies"), tmp); g_free(tmp); } count = 0; count = purple_blist_get_group_size(group, FALSE); if (count != 0) { /* Total buddies (from online accounts) in group */ tmp = g_strdup_printf("%d", count); purple_notify_user_info_add_pair(user_info, _("Total Buddies"), tmp); g_free(tmp); } count = 0; tmp = purple_notify_user_info_get_text_with_newline(user_info, "\n"); g_string_append(str, tmp); g_free(tmp); purple_notify_user_info_destroy(user_info); } purple_signal_emit(pidgin_blist_get_handle(), "drawing-tooltip", node, str, full); return g_string_free(str, FALSE); } static GHashTable *cached_emblems; static void _cleanup_cached_emblem(gpointer data, GObject *obj) { g_hash_table_remove(cached_emblems, data); } static GdkPixbuf * _pidgin_blist_get_cached_emblem(gchar *path) { GdkPixbuf *pb = g_hash_table_lookup(cached_emblems, path); if (pb != NULL) { /* The caller gets a reference */ g_object_ref(pb); g_free(path); } else { pb = gdk_pixbuf_new_from_file(path, NULL); if (pb != NULL) { /* We don't want to own a ref to the pixbuf, but we need to keep clean up. */ /* I'm not sure if it would be better to just keep our ref and not let the emblem ever be destroyed */ g_object_weak_ref(G_OBJECT(pb), _cleanup_cached_emblem, path); g_hash_table_insert(cached_emblems, path, pb); } else g_free(path); } return pb; } GdkPixbuf * pidgin_blist_get_emblem(PurpleBlistNode *node) { PurpleBuddy *buddy = NULL; struct _pidgin_blist_node *gtknode = node->ui_data; struct _pidgin_blist_node *gtkbuddynode = NULL; PurplePlugin *prpl; PurplePluginProtocolInfo *prpl_info; const char *name = NULL; char *filename, *path; PurplePresence *p; PurpleStatus *tune; if(PURPLE_BLIST_NODE_IS_CONTACT(node)) { if(!gtknode->contact_expanded) { buddy = purple_contact_get_priority_buddy((PurpleContact*)node); gtkbuddynode = ((PurpleBlistNode*)buddy)->ui_data; } } else if(PURPLE_BLIST_NODE_IS_BUDDY(node)) { buddy = (PurpleBuddy*)node; gtkbuddynode = node->ui_data; p = purple_buddy_get_presence(buddy); if (purple_presence_is_status_primitive_active(p, PURPLE_STATUS_MOBILE)) { path = g_build_filename(DATADIR, "pixmaps", "pidgin", "emblems", "16", "mobile.png", NULL); return _pidgin_blist_get_cached_emblem(path); } if (((struct _pidgin_blist_node*)(node->parent->ui_data))->contact_expanded) { if (!purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/blist/show_protocol_icons")) return pidgin_create_prpl_icon(((PurpleBuddy*)node)->account, PIDGIN_PRPL_ICON_SMALL); } } else { return NULL; } g_return_val_if_fail(buddy != NULL, NULL); if (!purple_privacy_check(buddy->account, purple_buddy_get_name(buddy))) { path = g_build_filename(DATADIR, "pixmaps", "pidgin", "emblems", "16", "blocked.png", NULL); return _pidgin_blist_get_cached_emblem(path); } p = purple_buddy_get_presence(buddy); if (purple_presence_is_status_primitive_active(p, PURPLE_STATUS_MOBILE)) { path = g_build_filename(DATADIR, "pixmaps", "pidgin", "emblems", "16", "mobile.png", NULL); return _pidgin_blist_get_cached_emblem(path); } tune = purple_presence_get_status(p, "tune"); if (tune && purple_status_is_active(tune)) { /* Only in MSN. * TODO: Replace "Tune" with generalized "Media" in 3.0. */ if (purple_status_get_attr_string(tune, "game") != NULL) { path = g_build_filename(DATADIR, "pixmaps", "pidgin", "emblems", "16", "game.png", NULL); return _pidgin_blist_get_cached_emblem(path); } /* Only in MSN. * TODO: Replace "Tune" with generalized "Media" in 3.0. */ if (purple_status_get_attr_string(tune, "office") != NULL) { path = g_build_filename(DATADIR, "pixmaps", "pidgin", "emblems", "16", "office.png", NULL); return _pidgin_blist_get_cached_emblem(path); } /* Regular old "tune" is the only one in all protocols. */ path = g_build_filename(DATADIR, "pixmaps", "pidgin", "emblems", "16", "music.png", NULL); return _pidgin_blist_get_cached_emblem(path); } prpl = purple_find_prpl(purple_account_get_protocol_id(buddy->account)); if (!prpl) return NULL; prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(prpl); if (prpl_info && prpl_info->list_emblem) name = prpl_info->list_emblem(buddy); if (name == NULL) return NULL; filename = g_strdup_printf("%s.png", name); path = g_build_filename(DATADIR, "pixmaps", "pidgin", "emblems", "16", filename, NULL); g_free(filename); /* _pidgin_blist_get_cached_emblem() assumes ownership of path */ return _pidgin_blist_get_cached_emblem(path); } GdkPixbuf * pidgin_blist_get_status_icon(PurpleBlistNode *node, PidginStatusIconSize size) { GdkPixbuf *ret; const char *protoname = NULL; const char *icon = NULL; struct _pidgin_blist_node *gtknode = node->ui_data; struct _pidgin_blist_node *gtkbuddynode = NULL; PurpleBuddy *buddy = NULL; PurpleChat *chat = NULL; GtkIconSize icon_size = gtk_icon_size_from_name((size == PIDGIN_STATUS_ICON_LARGE) ? PIDGIN_ICON_SIZE_TANGO_EXTRA_SMALL : PIDGIN_ICON_SIZE_TANGO_MICROSCOPIC); if(PURPLE_BLIST_NODE_IS_CONTACT(node)) { if(!gtknode->contact_expanded) { buddy = purple_contact_get_priority_buddy((PurpleContact*)node); if (buddy != NULL) gtkbuddynode = ((PurpleBlistNode*)buddy)->ui_data; } } else if(PURPLE_BLIST_NODE_IS_BUDDY(node)) { buddy = (PurpleBuddy*)node; gtkbuddynode = node->ui_data; } else if(PURPLE_BLIST_NODE_IS_CHAT(node)) { chat = (PurpleChat*)node; } else { return NULL; } if(buddy || chat) { PurpleAccount *account; PurplePlugin *prpl; PurplePluginProtocolInfo *prpl_info; if(buddy) account = buddy->account; else account = chat->account; prpl = purple_find_prpl(purple_account_get_protocol_id(account)); if(!prpl) return NULL; prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(prpl); if(prpl_info && prpl_info->list_icon) { protoname = prpl_info->list_icon(account, buddy); } } if(buddy) { PurpleConversation *conv = find_conversation_with_buddy(buddy); PurplePresence *p; gboolean trans; if(conv != NULL) { PidginConversation *gtkconv = PIDGIN_CONVERSATION(conv); if (gtkconv == NULL && size == PIDGIN_STATUS_ICON_SMALL) { PidginBlistNode *ui = buddy->node.ui_data; if (ui == NULL || (ui->conv.flags & PIDGIN_BLIST_NODE_HAS_PENDING_MESSAGE)) return gtk_widget_render_icon (GTK_WIDGET(gtkblist->treeview), PIDGIN_STOCK_STATUS_MESSAGE, icon_size, "GtkTreeView"); } } p = purple_buddy_get_presence(buddy); trans = purple_presence_is_idle(p); if (PURPLE_BUDDY_IS_ONLINE(buddy) && gtkbuddynode && gtkbuddynode->recent_signonoff) icon = PIDGIN_STOCK_STATUS_LOGIN; else if (gtkbuddynode && gtkbuddynode->recent_signonoff) icon = PIDGIN_STOCK_STATUS_LOGOUT; else if (purple_presence_is_status_primitive_active(p, PURPLE_STATUS_UNAVAILABLE)) if (trans) icon = PIDGIN_STOCK_STATUS_BUSY_I; else icon = PIDGIN_STOCK_STATUS_BUSY; else if (purple_presence_is_status_primitive_active(p, PURPLE_STATUS_AWAY)) if (trans) icon = PIDGIN_STOCK_STATUS_AWAY_I; else icon = PIDGIN_STOCK_STATUS_AWAY; else if (purple_presence_is_status_primitive_active(p, PURPLE_STATUS_EXTENDED_AWAY)) if (trans) icon = PIDGIN_STOCK_STATUS_XA_I; else icon = PIDGIN_STOCK_STATUS_XA; else if (purple_presence_is_status_primitive_active(p, PURPLE_STATUS_OFFLINE)) icon = PIDGIN_STOCK_STATUS_OFFLINE; else if (trans) icon = PIDGIN_STOCK_STATUS_AVAILABLE_I; else if (purple_presence_is_status_primitive_active(p, PURPLE_STATUS_INVISIBLE)) icon = PIDGIN_STOCK_STATUS_INVISIBLE; else icon = PIDGIN_STOCK_STATUS_AVAILABLE; } else if (chat) { icon = PIDGIN_STOCK_STATUS_CHAT; } else { icon = PIDGIN_STOCK_STATUS_PERSON; } ret = gtk_widget_render_icon (GTK_WIDGET(gtkblist->treeview), icon, icon_size, "GtkTreeView"); return ret; } gchar * pidgin_blist_get_name_markup(PurpleBuddy *b, gboolean selected, gboolean aliased) { const char *name, *name_color, *name_font, *status_color, *status_font; char *text = NULL; PurplePlugin *prpl; PurplePluginProtocolInfo *prpl_info = NULL; PurpleContact *contact; PurplePresence *presence; struct _pidgin_blist_node *gtkcontactnode = NULL; char *idletime = NULL, *statustext = NULL, *nametext = NULL; PurpleConversation *conv = find_conversation_with_buddy(b); gboolean hidden_conv = FALSE; gboolean biglist = purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/blist/show_buddy_icons"); FontColorPair *pair = NULL; PidginBlistTheme *theme; if (conv != NULL) { PidginBlistNode *ui = b->node.ui_data; if (ui) { if (ui->conv.flags & PIDGIN_BLIST_NODE_HAS_PENDING_MESSAGE) hidden_conv = TRUE; } else { if (PIDGIN_CONVERSATION(conv) == NULL) hidden_conv = TRUE; } } /* XXX Good luck cleaning up this crap */ contact = PURPLE_CONTACT(PURPLE_BLIST_NODE(b)->parent); if(contact) gtkcontactnode = purple_blist_node_get_ui_data(PURPLE_BLIST_NODE(contact)); /* Name */ if (gtkcontactnode && !gtkcontactnode->contact_expanded && contact->alias) name = contact->alias; else name = purple_buddy_get_alias(b); nametext = g_markup_escape_text(name, strlen(name)); presence = purple_buddy_get_presence(b); /* Name is all that is needed */ if (!aliased || biglist) { /* Status Info */ prpl = purple_find_prpl(purple_account_get_protocol_id(b->account)); if (prpl != NULL) prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(prpl); if (prpl_info && prpl_info->status_text && b->account->gc) { char *tmp = prpl_info->status_text(b); const char *end; if(tmp && !g_utf8_validate(tmp, -1, &end)) { char *new = g_strndup(tmp, g_utf8_pointer_to_offset(tmp, end)); g_free(tmp); tmp = new; } /* add ... to messages that are too long, GTK 2.6+ does it automatically */ #if !GTK_CHECK_VERSION(2,6,0) if(tmp) { char buf[32]; char *c = tmp; int length = 0, vis=0; gboolean inside = FALSE; g_strdelimit(tmp, "\n", ' '); purple_str_strip_char(tmp, '\r'); while(*c && vis < 20) { if(*c == '&') inside = TRUE; else if(*c == ';') inside = FALSE; if(!inside) vis++; c = g_utf8_next_char(c); /* this is fun */ } length = c - tmp; if(vis == 20) g_snprintf(buf, sizeof(buf), "%%.%ds...", length); else g_snprintf(buf, sizeof(buf), "%%s "); statustext = g_strdup_printf(buf, tmp);purple_presence_is_idle(presence) g_free(tmp); } #else if(tmp) { g_strdelimit(tmp, "\n", ' '); purple_str_strip_char(tmp, '\r'); } statustext = tmp; #endif } if(!purple_presence_is_online(presence) && !statustext) statustext = g_strdup(_("Offline")); /* Idle Text */ if (purple_presence_is_idle(presence) && purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/blist/show_idle_time")) { time_t idle_secs = purple_presence_get_idle_time(presence); if (idle_secs > 0) { int iday, ihrs, imin; time_t t; time(&t); iday = (t - idle_secs) / (24 * 60 * 60); ihrs = ((t - idle_secs) / 60 / 60) % 24; imin = ((t - idle_secs) / 60) % 60; if (iday) idletime = g_strdup_printf(_("Idle %dd %dh %02dm"), iday, ihrs, imin); else if (ihrs) idletime = g_strdup_printf(_("Idle %dh %02dm"), ihrs, imin); else idletime = g_strdup_printf(_("Idle %dm"), imin); } else idletime = g_strdup(_("Idle")); } } /* choose the colors of the text */ theme = pidgin_blist_get_theme(); if (purple_presence_is_idle(presence)) { if (theme) pair = pidgin_blist_theme_get_idle_text_info(theme); status_color = name_color = (pair != NULL && pair->color != NULL) ? pair->color : "dim grey"; status_font = name_font = (pair != NULL && pair->font != NULL) ? pair->font : ""; } else if (!purple_presence_is_online(presence)) { if (theme) pair = pidgin_blist_theme_get_offline_text_info(theme); name_color = (pair != NULL && pair->color != NULL) ? pair->color : NULL; name_font = (pair != NULL && pair->font != NULL) ? pair->font : ""; if (theme) pair = pidgin_blist_theme_get_status_text_info(theme); status_color = (pair != NULL && pair->color != NULL) ? pair->color : "dim grey"; status_font = (pair != NULL && pair->font != NULL) ? pair->font : ""; } else if (purple_presence_is_available(presence)) { if (theme) pair = pidgin_blist_theme_get_online_text_info(theme); name_color = (pair != NULL && pair->color != NULL) ? pair->color : NULL; name_font = (pair != NULL && pair->font != NULL) ? pair->font : ""; if (theme) pair = pidgin_blist_theme_get_status_text_info(theme); status_color = (pair != NULL && pair->color != NULL) ? pair->color : "dim grey"; status_font = (pair != NULL && pair->font != NULL) ? pair->font : ""; } else { if (theme) pair = pidgin_blist_theme_get_away_text_info(theme); name_color = (pair != NULL && pair->color != NULL) ? pair->color : NULL; name_font = (pair != NULL && pair->font != NULL) ? pair->font : ""; if (theme) pair = pidgin_blist_theme_get_status_text_info(theme); status_color = (pair != NULL && pair->color != NULL) ? pair->color : "dim grey"; status_font = (pair != NULL && pair->font != NULL) ? pair->font : ""; } if (aliased && selected) { if (theme) { name_color = "black"; status_color = "black"; } else { name_color = NULL; status_color = NULL; } } /* Put it all together */ if ((!aliased || biglist) && (statustext || idletime)) { /* using <span size='smaller'> breaks the status, so it must be seperated into <small><span>*/ if (name_color) { text = g_strdup_printf("<span font_desc='%s' foreground='%s'>%s</span>\n" "<small><span font_desc='%s' foreground='%s'>%s%s%s</span></small>", name_font, name_color, nametext, status_font, status_color, idletime != NULL ? idletime : "", (idletime != NULL && statustext != NULL) ? " - " : "", statustext != NULL ? statustext : ""); } else if (status_color) { text = g_strdup_printf("<span font_desc='%s'>%s</span>\n" "<small><span font_desc='%s' foreground='%s'>%s%s%s</span></small>", name_font, nametext, status_font, status_color, idletime != NULL ? idletime : "", (idletime != NULL && statustext != NULL) ? " - " : "", statustext != NULL ? statustext : ""); } else { text = g_strdup_printf("<span font_desc='%s'>%s</span>\n" "<small><span font_desc='%s'>%s%s%s</span></small>", name_font, nametext, status_font, idletime != NULL ? idletime : "", (idletime != NULL && statustext != NULL) ? " - " : "", statustext != NULL ? statustext : ""); } } else { if (name_color) { text = g_strdup_printf("<span font_desc='%s' color='%s'>%s</span>", name_font, name_color, nametext); } else { text = g_strdup_printf("<span font_desc='%s'>%s</span>", name_font, nametext); } } g_free(nametext); g_free(statustext); g_free(idletime); if (hidden_conv) { char *tmp = text; text = g_strdup_printf("<b>%s</b>", tmp); g_free(tmp); } return text; } static void pidgin_blist_restore_position(void) { int blist_x, blist_y, blist_width, blist_height; blist_width = purple_prefs_get_int(PIDGIN_PREFS_ROOT "/blist/width"); /* if the window exists, is hidden, we're saving positions, and the * position is sane... */ if (gtkblist && gtkblist->window && !GTK_WIDGET_VISIBLE(gtkblist->window) && blist_width != 0) { blist_x = purple_prefs_get_int(PIDGIN_PREFS_ROOT "/blist/x"); blist_y = purple_prefs_get_int(PIDGIN_PREFS_ROOT "/blist/y"); blist_height = purple_prefs_get_int(PIDGIN_PREFS_ROOT "/blist/height"); /* ...check position is on screen... */ if (blist_x >= gdk_screen_width()) blist_x = gdk_screen_width() - 100; else if (blist_x + blist_width < 0) blist_x = 100; if (blist_y >= gdk_screen_height()) blist_y = gdk_screen_height() - 100; else if (blist_y + blist_height < 0) blist_y = 100; /* ...and move it back. */ gtk_window_move(GTK_WINDOW(gtkblist->window), blist_x, blist_y); gtk_window_resize(GTK_WINDOW(gtkblist->window), blist_width, blist_height); if (purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/blist/list_maximized")) gtk_window_maximize(GTK_WINDOW(gtkblist->window)); } } static gboolean pidgin_blist_refresh_timer(PurpleBuddyList *list) { PurpleBlistNode *gnode, *cnode; if (gtk_blist_visibility == GDK_VISIBILITY_FULLY_OBSCURED || !GTK_WIDGET_VISIBLE(gtkblist->window)) return TRUE; for(gnode = list->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)) { PurpleBuddy *buddy; buddy = purple_contact_get_priority_buddy((PurpleContact*)cnode); if (buddy && purple_presence_is_idle(purple_buddy_get_presence(buddy))) pidgin_blist_update_contact(list, (PurpleBlistNode*)buddy); } } } /* keep on going */ return TRUE; } static void pidgin_blist_hide_node(PurpleBuddyList *list, PurpleBlistNode *node, gboolean update) { struct _pidgin_blist_node *gtknode = (struct _pidgin_blist_node *)node->ui_data; GtkTreeIter iter; if (!gtknode || !gtknode->row || !gtkblist) return; if(gtkblist->selected_node == node) gtkblist->selected_node = NULL; if (get_iter_from_node(node, &iter)) { gtk_tree_store_remove(gtkblist->treemodel, &iter); if(update && (PURPLE_BLIST_NODE_IS_CONTACT(node) || PURPLE_BLIST_NODE_IS_BUDDY(node) || PURPLE_BLIST_NODE_IS_CHAT(node))) { pidgin_blist_update(list, node->parent); } } gtk_tree_row_reference_free(gtknode->row); gtknode->row = NULL; } static const char *require_connection[] = { N_("/Buddies/New Instant Message..."), N_("/Buddies/Join a Chat..."), N_("/Buddies/Get User Info..."), N_("/Buddies/Add Buddy..."), N_("/Buddies/Add Chat..."), N_("/Buddies/Add Group..."), }; static const int require_connection_size = sizeof(require_connection) / sizeof(*require_connection); /** * Rebuild dynamic menus and make menu items sensitive/insensitive * where appropriate. */ static void update_menu_bar(PidginBuddyList *gtkblist) { GtkWidget *widget; gboolean sensitive; int i; g_return_if_fail(gtkblist != NULL); pidgin_blist_update_accounts_menu(); sensitive = (purple_connections_get_all() != NULL); for (i = 0; i < require_connection_size; i++) { widget = gtk_item_factory_get_widget(gtkblist->ift, require_connection[i]); gtk_widget_set_sensitive(widget, sensitive); } widget = gtk_item_factory_get_widget(gtkblist->ift, N_("/Buddies/Join a Chat...")); gtk_widget_set_sensitive(widget, pidgin_blist_joinchat_is_showable()); widget = gtk_item_factory_get_widget(gtkblist->ift, N_("/Buddies/Add Chat...")); gtk_widget_set_sensitive(widget, pidgin_blist_joinchat_is_showable()); widget = gtk_item_factory_get_widget(gtkblist->ift, N_("/Tools/Privacy")); gtk_widget_set_sensitive(widget, sensitive); widget = gtk_item_factory_get_widget(gtkblist->ift, N_("/Tools/Room List")); gtk_widget_set_sensitive(widget, pidgin_roomlist_is_showable()); } static void sign_on_off_cb(PurpleConnection *gc, PurpleBuddyList *blist) { PidginBuddyList *gtkblist = PIDGIN_BLIST(blist); update_menu_bar(gtkblist); } static void plugin_changed_cb(PurplePlugin *p, gpointer *data) { pidgin_blist_update_plugin_actions(); } static void unseen_conv_menu(void) { static GtkWidget *menu = NULL; GList *convs = NULL; GList *chats, *ims; if (menu) { gtk_widget_destroy(menu); menu = NULL; } ims = pidgin_conversations_find_unseen_list(PURPLE_CONV_TYPE_IM, PIDGIN_UNSEEN_TEXT, FALSE, 0); chats = pidgin_conversations_find_unseen_list(PURPLE_CONV_TYPE_CHAT, PIDGIN_UNSEEN_NICK, FALSE, 0); if(ims && chats) convs = g_list_concat(ims, chats); else if(ims && !chats) convs = ims; else if(!ims && chats) convs = chats; if (!convs) /* no conversations added, don't show the menu */ return; menu = gtk_menu_new(); pidgin_conversations_fill_menu(menu, convs); g_list_free(convs); gtk_widget_show_all(menu); gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, 3, gtk_get_current_event_time()); } static gboolean menutray_press_cb(GtkWidget *widget, GdkEventButton *event) { GList *convs; switch (event->button) { case 1: convs = pidgin_conversations_find_unseen_list(PURPLE_CONV_TYPE_IM, PIDGIN_UNSEEN_TEXT, FALSE, 1); if(!convs) convs = pidgin_conversations_find_unseen_list(PURPLE_CONV_TYPE_CHAT, PIDGIN_UNSEEN_NICK, FALSE, 1); if (convs) { pidgin_conv_present_conversation((PurpleConversation*)convs->data); g_list_free(convs); } break; case 3: unseen_conv_menu(); break; } return TRUE; } static void conversation_updated_cb(PurpleConversation *conv, PurpleConvUpdateType type, PidginBuddyList *gtkblist) { GList *convs = NULL; GList *ims, *chats; GList *l = NULL; if (type != PURPLE_CONV_UPDATE_UNSEEN) return; if(conv->account != NULL && conv->name != NULL) { PurpleBuddy *buddy = purple_find_buddy(conv->account, conv->name); if(buddy != NULL) pidgin_blist_update_buddy(NULL, (PurpleBlistNode *)buddy, TRUE); } if (gtkblist->menutrayicon) { gtk_widget_destroy(gtkblist->menutrayicon); gtkblist->menutrayicon = NULL; } ims = pidgin_conversations_find_unseen_list(PURPLE_CONV_TYPE_IM, PIDGIN_UNSEEN_TEXT, FALSE, 0); chats = pidgin_conversations_find_unseen_list(PURPLE_CONV_TYPE_CHAT, PIDGIN_UNSEEN_NICK, FALSE, 0); if(ims && chats) convs = g_list_concat(ims, chats); else if(ims && !chats) convs = ims; else if(!ims && chats) convs = chats; if (convs) { GtkWidget *img = NULL; GString *tooltip_text = NULL; tooltip_text = g_string_new(""); l = convs; while (l != NULL) { int count = 0; PidginConversation *gtkconv = PIDGIN_CONVERSATION((PurpleConversation *)l->data); if(gtkconv) count = gtkconv->unseen_count; else if(purple_conversation_get_data(l->data, "unseen-count")) count = GPOINTER_TO_INT(purple_conversation_get_data(l->data, "unseen-count")); g_string_append_printf(tooltip_text, ngettext("%d unread message from %s\n", "%d unread messages from %s\n", count), count, purple_conversation_get_title(l->data)); l = l->next; } if(tooltip_text->len > 0) { /* get rid of the last newline */ g_string_truncate(tooltip_text, tooltip_text->len -1); img = gtk_image_new_from_stock(PIDGIN_STOCK_TOOLBAR_PENDING, gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_EXTRA_SMALL)); gtkblist->menutrayicon = gtk_event_box_new(); gtk_container_add(GTK_CONTAINER(gtkblist->menutrayicon), img); gtk_widget_show(img); gtk_widget_show(gtkblist->menutrayicon); g_signal_connect(G_OBJECT(gtkblist->menutrayicon), "button-press-event", G_CALLBACK(menutray_press_cb), NULL); pidgin_menu_tray_append(PIDGIN_MENU_TRAY(gtkblist->menutray), gtkblist->menutrayicon, tooltip_text->str); } g_string_free(tooltip_text, TRUE); g_list_free(convs); } } static void conversation_deleting_cb(PurpleConversation *conv, PidginBuddyList *gtkblist) { conversation_updated_cb(conv, PURPLE_CONV_UPDATE_UNSEEN, gtkblist); } static void conversation_deleted_update_ui_cb(PurpleConversation *conv, struct _pidgin_blist_node *ui) { if (ui->conv.conv != conv) return; ui->conv.conv = NULL; ui->conv.flags = 0; ui->conv.last_message = 0; } static void written_msg_update_ui_cb(PurpleAccount *account, const char *who, const char *message, PurpleConversation *conv, PurpleMessageFlags flag, PurpleBlistNode *node) { PidginBlistNode *ui = node->ui_data; if (ui->conv.conv != conv || !pidgin_conv_is_hidden(PIDGIN_CONVERSATION(conv)) || !(flag & (PURPLE_MESSAGE_SEND | PURPLE_MESSAGE_RECV))) return; ui->conv.flags |= PIDGIN_BLIST_NODE_HAS_PENDING_MESSAGE; if (purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_CHAT && (flag & PURPLE_MESSAGE_NICK)) ui->conv.flags |= PIDGIN_BLIST_CHAT_HAS_PENDING_MESSAGE_WITH_NICK; ui->conv.last_message = time(NULL); /* XXX: for lack of better data */ pidgin_blist_update(purple_get_blist(), node); } static void displayed_msg_update_ui_cb(PidginConversation *gtkconv, PurpleBlistNode *node) { PidginBlistNode *ui = node->ui_data; if (ui->conv.conv != gtkconv->active_conv) return; ui->conv.flags &= ~(PIDGIN_BLIST_NODE_HAS_PENDING_MESSAGE | PIDGIN_BLIST_CHAT_HAS_PENDING_MESSAGE_WITH_NICK); pidgin_blist_update(purple_get_blist(), node); } static void conversation_created_cb(PurpleConversation *conv, PidginBuddyList *gtkblist) { switch (conv->type) { case PURPLE_CONV_TYPE_IM: { GSList *buddies = purple_find_buddies(conv->account, conv->name); while (buddies) { PurpleBlistNode *buddy = buddies->data; struct _pidgin_blist_node *ui = buddy->ui_data; buddies = g_slist_delete_link(buddies, buddies); if (!ui) continue; ui->conv.conv = conv; ui->conv.flags = 0; ui->conv.last_message = 0; purple_signal_connect(purple_conversations_get_handle(), "deleting-conversation", ui, PURPLE_CALLBACK(conversation_deleted_update_ui_cb), ui); purple_signal_connect(purple_conversations_get_handle(), "wrote-im-msg", ui, PURPLE_CALLBACK(written_msg_update_ui_cb), buddy); purple_signal_connect(pidgin_conversations_get_handle(), "conversation-displayed", ui, PURPLE_CALLBACK(displayed_msg_update_ui_cb), buddy); } } break; case PURPLE_CONV_TYPE_CHAT: { PurpleChat *chat = purple_blist_find_chat(conv->account, conv->name); struct _pidgin_blist_node *ui; if (!chat) break; ui = chat->node.ui_data; if (!ui) break; ui->conv.conv = conv; ui->conv.flags = 0; ui->conv.last_message = 0; purple_signal_connect(purple_conversations_get_handle(), "deleting-conversation", ui, PURPLE_CALLBACK(conversation_deleted_update_ui_cb), ui); purple_signal_connect(purple_conversations_get_handle(), "wrote-chat-msg", ui, PURPLE_CALLBACK(written_msg_update_ui_cb), chat); purple_signal_connect(pidgin_conversations_get_handle(), "conversation-displayed", ui, PURPLE_CALLBACK(displayed_msg_update_ui_cb), chat); } break; default: break; } } /********************************************************************************** * Public API Functions * **********************************************************************************/ static void pidgin_blist_new_list(PurpleBuddyList *blist) { PidginBuddyList *gtkblist; gtkblist = g_new0(PidginBuddyList, 1); gtkblist->connection_errors = g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, g_free); gtkblist->priv = g_new0(PidginBuddyListPrivate, 1); blist->ui_data = gtkblist; } static void pidgin_blist_new_node(PurpleBlistNode *node) { node->ui_data = g_new0(struct _pidgin_blist_node, 1); } gboolean pidgin_blist_node_is_contact_expanded(PurpleBlistNode *node) { if (PURPLE_BLIST_NODE_IS_BUDDY(node)) { node = node->parent; if (node == NULL) return FALSE; } g_return_val_if_fail(PURPLE_BLIST_NODE_IS_CONTACT(node), FALSE); return ((struct _pidgin_blist_node *)node->ui_data)->contact_expanded; } enum { DRAG_BUDDY, DRAG_ROW, DRAG_VCARD, DRAG_TEXT, DRAG_URI, NUM_TARGETS }; static const char * item_factory_translate_func (const char *path, gpointer func_data) { return _((char *)path); } void pidgin_blist_setup_sort_methods() { pidgin_blist_sort_method_reg("none", _("Manually"), sort_method_none); #if GTK_CHECK_VERSION(2,2,1) pidgin_blist_sort_method_reg("alphabetical", _("Alphabetically"), sort_method_alphabetical); pidgin_blist_sort_method_reg("status", _("By status"), sort_method_status); pidgin_blist_sort_method_reg("log_size", _("By recent log activity"), sort_method_log_activity); #endif pidgin_blist_sort_method_set(purple_prefs_get_string(PIDGIN_PREFS_ROOT "/blist/sort_type")); } static void _prefs_change_redo_list(const char *name, PurplePrefType type, gconstpointer val, gpointer data) { GtkTreeSelection *sel; GtkTreeIter iter; PurpleBlistNode *node = NULL; sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(gtkblist->treeview)); if (gtk_tree_selection_get_selected(sel, NULL, &iter)) { gtk_tree_model_get(GTK_TREE_MODEL(gtkblist->treemodel), &iter, NODE_COLUMN, &node, -1); } redo_buddy_list(purple_get_blist(), FALSE, FALSE); #if GTK_CHECK_VERSION(2,6,0) gtk_tree_view_columns_autosize(GTK_TREE_VIEW(gtkblist->treeview)); #endif if (node) { struct _pidgin_blist_node *gtknode; GtkTreePath *path; gtknode = node->ui_data; if (gtknode && gtknode->row) { path = gtk_tree_row_reference_get_path(gtknode->row); gtk_tree_selection_select_path(sel, path); gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(gtkblist->treeview), path, NULL, FALSE, 0, 0); gtk_tree_path_free(path); } } } static void _prefs_change_sort_method(const char *pref_name, PurplePrefType type, gconstpointer val, gpointer data) { if(!strcmp(pref_name, PIDGIN_PREFS_ROOT "/blist/sort_type")) pidgin_blist_sort_method_set(val); } static gboolean pidgin_blist_select_notebook_page_cb(gpointer user_data) { PidginBuddyList *gtkblist = (PidginBuddyList *)user_data; int errors = 0; GList *list = NULL; PidginBuddyListPrivate *priv; priv = PIDGIN_BUDDY_LIST_GET_PRIVATE(gtkblist); /* this is far too ugly thanks to me not wanting to fix #3989 properly right now */ if (priv->error_scrollbook != NULL) { #if GTK_CHECK_VERSION(2,2,0) errors = gtk_notebook_get_n_pages(GTK_NOTEBOOK(priv->error_scrollbook->notebook)); #else errors = g_list_length(GTK_NOTEBOOK(priv->error_scrollbook->notebook)->children); #endif } if ((list = purple_accounts_get_all_active()) != NULL || errors) { gtk_notebook_set_current_page(GTK_NOTEBOOK(gtkblist->notebook), 1); g_list_free(list); } else gtk_notebook_set_current_page(GTK_NOTEBOOK(gtkblist->notebook), 0); return FALSE; } static void pidgin_blist_select_notebook_page(PidginBuddyList *gtkblist) { purple_timeout_add(0, pidgin_blist_select_notebook_page_cb, gtkblist); } static void account_modified(PurpleAccount *account, PidginBuddyList *gtkblist) { if (!gtkblist) return; pidgin_blist_select_notebook_page(gtkblist); update_menu_bar(gtkblist); } static void account_status_changed(PurpleAccount *account, PurpleStatus *old, PurpleStatus *new, PidginBuddyList *gtkblist) { if (!gtkblist) return; account_modified(account, gtkblist); } static gboolean gtk_blist_window_key_press_cb(GtkWidget *w, GdkEventKey *event, PidginBuddyList *gtkblist) { GtkWidget *widget; if (!gtkblist) return FALSE; /* clear any tooltips */ pidgin_blist_tooltip_destroy(); widget = gtk_window_get_focus(GTK_WINDOW(gtkblist->window)); if (GTK_IS_IMHTML(widget) || GTK_IS_ENTRY(widget)) { if (gtk_bindings_activate(GTK_OBJECT(widget), event->keyval, event->state)) return TRUE; } return FALSE; } static gboolean headline_hover_close(int x, int y) { GtkWidget *w = gtkblist->headline_hbox; if (x <= w->allocation.width && x >= w->allocation.width - HEADLINE_CLOSE_SIZE && y >= 0 && y <= HEADLINE_CLOSE_SIZE) return TRUE; return FALSE; } static gboolean headline_box_enter_cb(GtkWidget *widget, GdkEventCrossing *event, PidginBuddyList *gtkblist) { gdk_window_set_cursor(widget->window, gtkblist->hand_cursor); if (gtkblist->headline_close) { #if GTK_CHECK_VERSION(2,2,0) gdk_draw_pixbuf(widget->window, NULL, gtkblist->headline_close, #else gdk_pixbuf_render_to_drawable(gtkblist->headline_close, GDK_DRAWABLE(widget->window), NULL, #endif 0, 0, widget->allocation.width - 2 - HEADLINE_CLOSE_SIZE, 2, HEADLINE_CLOSE_SIZE, HEADLINE_CLOSE_SIZE, GDK_RGB_DITHER_NONE, 0, 0); #if 0 /* The presence of one opening paren in each branch of * GTK_CHECK_VERSION confuses vim's bracket matching for the * rest of the file. */ ) #endif gtk_paint_focus(widget->style, widget->window, GTK_STATE_PRELIGHT, NULL, widget, NULL, widget->allocation.width - HEADLINE_CLOSE_SIZE - 3, 1, HEADLINE_CLOSE_SIZE + 2, HEADLINE_CLOSE_SIZE + 2); } return FALSE; } #if 0 static gboolean headline_box_motion_cb(GtkWidget *widget, GdkEventMotion *event, PidginBuddyList *gtkblist) { purple_debug_fatal("motion", "%d %d\n", (int)event->x, (int)event->y); if (headline_hover_close((int)event->x, (int)event->y)) gtk_paint_focus(widget->style, widget->window, GTK_STATE_PRELIGHT, NULL, widget, NULL, widget->allocation.width - HEADLINE_CLOSE_SIZE - 3, 1, HEADLINE_CLOSE_SIZE + 2, HEADLINE_CLOSE_SIZE + 2); return FALSE; } #endif static gboolean headline_box_leave_cb(GtkWidget *widget, GdkEventCrossing *event, PidginBuddyList *gtkblist) { gdk_window_set_cursor(widget->window, gtkblist->arrow_cursor); if (gtkblist->headline_close) { GdkRectangle rect = {widget->allocation.width - 3 - HEADLINE_CLOSE_SIZE, 1, HEADLINE_CLOSE_SIZE + 2, HEADLINE_CLOSE_SIZE + 2}; gdk_window_invalidate_rect(widget->window, &rect, TRUE); } return FALSE; } static void reset_headline(PidginBuddyList *gtkblist) { gtkblist->headline_callback = NULL; gtkblist->headline_data = NULL; gtkblist->headline_destroy = NULL; pidgin_set_urgent(GTK_WINDOW(gtkblist->window), FALSE); } static gboolean headline_click_callback(gpointer unused) { if (gtkblist->headline_callback) ((GSourceFunc) gtkblist->headline_callback)(gtkblist->headline_data); reset_headline(gtkblist); return FALSE; } static gboolean headline_box_press_cb(GtkWidget *widget, GdkEventButton *event, PidginBuddyList *gtkblist) { gtk_widget_hide(gtkblist->headline_hbox); if (gtkblist->headline_callback && !headline_hover_close((int)event->x, (int)event->y)) g_idle_add(headline_click_callback, NULL); else { if (gtkblist->headline_destroy) gtkblist->headline_destroy(gtkblist->headline_data); reset_headline(gtkblist); } return TRUE; } /***********************************/ /* Connection error handling stuff */ /***********************************/ #define OBJECT_DATA_KEY_ACCOUNT "account" #define DO_NOT_CLEAR_ERROR "do-not-clear-error" static gboolean find_account_widget(GObject *widget, PurpleAccount *account) { if (g_object_get_data(widget, OBJECT_DATA_KEY_ACCOUNT) == account) return 0; /* found */ else return 1; } static void pack_prpl_icon_start(GtkWidget *box, PurpleAccount *account) { GdkPixbuf *pixbuf; GtkWidget *image; pixbuf = pidgin_create_prpl_icon(account, PIDGIN_PRPL_ICON_SMALL); if (pixbuf != NULL) { image = gtk_image_new_from_pixbuf(pixbuf); g_object_unref(pixbuf); gtk_box_pack_start(GTK_BOX(box), image, FALSE, FALSE, 0); } } static void add_error_dialog(PidginBuddyList *gtkblist, GtkWidget *dialog) { PidginBuddyListPrivate *priv = PIDGIN_BUDDY_LIST_GET_PRIVATE(gtkblist); gtk_container_add(GTK_CONTAINER(priv->error_scrollbook), dialog); } static GtkWidget * find_child_widget_by_account(GtkContainer *container, PurpleAccount *account) { GList *l = NULL; GList *children = NULL; GtkWidget *ret = NULL; /* XXX: Workaround for the currently incomplete implementation of PidginScrollBook */ if (PIDGIN_IS_SCROLL_BOOK(container)) container = GTK_CONTAINER(PIDGIN_SCROLL_BOOK(container)->notebook); children = gtk_container_get_children(container); l = g_list_find_custom(children, account, (GCompareFunc) find_account_widget); if (l) ret = GTK_WIDGET(l->data); g_list_free(children); return ret; } static void remove_child_widget_by_account(GtkContainer *container, PurpleAccount *account) { GtkWidget *widget = find_child_widget_by_account(container, account); if(widget) { /* Since we are destroying the widget in response to a change in * error, we should not clear the error. */ g_object_set_data(G_OBJECT(widget), DO_NOT_CLEAR_ERROR, GINT_TO_POINTER(TRUE)); gtk_widget_destroy(widget); } } /* Generic error buttons */ static void generic_error_modify_cb(PurpleAccount *account) { purple_account_clear_current_error(account); pidgin_account_dialog_show(PIDGIN_MODIFY_ACCOUNT_DIALOG, account); } static void generic_error_enable_cb(PurpleAccount *account) { purple_account_clear_current_error(account); purple_account_set_enabled(account, purple_core_get_ui(), TRUE); } static void generic_error_destroy_cb(GtkObject *dialog, PurpleAccount *account) { g_hash_table_remove(gtkblist->connection_errors, account); /* If the error dialog is being destroyed in response to the * account-error-changed signal, we don't want to clear the current * error. */ if (g_object_get_data(G_OBJECT(dialog), DO_NOT_CLEAR_ERROR) == NULL) purple_account_clear_current_error(account); } #define SSL_FAQ_URI "http://d.pidgin.im/wiki/FAQssl" static void ssl_faq_clicked_cb(PidginMiniDialog *mini_dialog, GtkButton *button, gpointer ignored) { purple_notify_uri(NULL, SSL_FAQ_URI); } static void add_generic_error_dialog(PurpleAccount *account, const PurpleConnectionErrorInfo *err) { GtkWidget *mini_dialog; const char *username = purple_account_get_username(account); gboolean enabled = purple_account_get_enabled(account, purple_core_get_ui()); char *primary; if (enabled) primary = g_strdup_printf(_("%s disconnected"), username); else primary = g_strdup_printf(_("%s disabled"), username); mini_dialog = pidgin_make_mini_dialog(NULL, PIDGIN_STOCK_DIALOG_ERROR, primary, err->description, account, (enabled ? _("Reconnect") : _("Re-enable")), (enabled ? PURPLE_CALLBACK(purple_account_connect) : PURPLE_CALLBACK(generic_error_enable_cb)), _("Modify Account"), PURPLE_CALLBACK(generic_error_modify_cb), NULL); g_free(primary); g_object_set_data(G_OBJECT(mini_dialog), OBJECT_DATA_KEY_ACCOUNT, account); if(err->type == PURPLE_CONNECTION_ERROR_NO_SSL_SUPPORT) pidgin_mini_dialog_add_button(PIDGIN_MINI_DIALOG(mini_dialog), _("SSL FAQs"), ssl_faq_clicked_cb, NULL); g_signal_connect_after(mini_dialog, "destroy", (GCallback)generic_error_destroy_cb, account); add_error_dialog(gtkblist, mini_dialog); } static void remove_generic_error_dialog(PurpleAccount *account) { PidginBuddyListPrivate *priv = PIDGIN_BUDDY_LIST_GET_PRIVATE(gtkblist); remove_child_widget_by_account( GTK_CONTAINER(priv->error_scrollbook), account); } static void update_generic_error_message(PurpleAccount *account, const char *description) { PidginBuddyListPrivate *priv = PIDGIN_BUDDY_LIST_GET_PRIVATE(gtkblist); GtkWidget *mini_dialog = find_child_widget_by_account( GTK_CONTAINER(priv->error_scrollbook), account); pidgin_mini_dialog_set_description(PIDGIN_MINI_DIALOG(mini_dialog), description); } /* Notifications about accounts which were disconnected with * PURPLE_CONNECTION_ERROR_NAME_IN_USE */ typedef void (*AccountFunction)(PurpleAccount *); static void elsewhere_foreach_account(PidginMiniDialog *mini_dialog, AccountFunction f) { PurpleAccount *account; GList *labels = gtk_container_get_children( GTK_CONTAINER(mini_dialog->contents)); GList *l; for (l = labels; l; l = l->next) { account = g_object_get_data(G_OBJECT(l->data), OBJECT_DATA_KEY_ACCOUNT); if (account) f(account); else purple_debug_warning("gtkblist", "mini_dialog's child " "didn't have an account stored in it!"); } g_list_free(labels); } static void enable_account(PurpleAccount *account) { purple_account_set_enabled(account, purple_core_get_ui(), TRUE); } static void reconnect_elsewhere_accounts(PidginMiniDialog *mini_dialog, GtkButton *button, gpointer unused) { elsewhere_foreach_account(mini_dialog, enable_account); } static void clear_elsewhere_errors(PidginMiniDialog *mini_dialog, gpointer unused) { elsewhere_foreach_account(mini_dialog, purple_account_clear_current_error); } static void ensure_signed_on_elsewhere_minidialog(PidginBuddyList *gtkblist) { PidginBuddyListPrivate *priv = PIDGIN_BUDDY_LIST_GET_PRIVATE(gtkblist); PidginMiniDialog *mini_dialog; if(priv->signed_on_elsewhere) return; mini_dialog = priv->signed_on_elsewhere = pidgin_mini_dialog_new(_("Welcome back!"), NULL, PIDGIN_STOCK_DISCONNECT); pidgin_mini_dialog_add_button(mini_dialog, _("Re-enable"), reconnect_elsewhere_accounts, NULL); /* Make dismissing the dialog clear the errors. The "destroy" signal * does not appear to fire at quit, which is fortunate! */ g_signal_connect(G_OBJECT(mini_dialog), "destroy", (GCallback) clear_elsewhere_errors, NULL); add_error_dialog(gtkblist, GTK_WIDGET(mini_dialog)); /* Set priv->signed_on_elsewhere to NULL when the dialog is destroyed */ g_signal_connect(G_OBJECT(mini_dialog), "destroy", (GCallback) gtk_widget_destroyed, &(priv->signed_on_elsewhere)); } static void update_signed_on_elsewhere_minidialog_title(void) { PidginBuddyListPrivate *priv = PIDGIN_BUDDY_LIST_GET_PRIVATE(gtkblist); PidginMiniDialog *mini_dialog = priv->signed_on_elsewhere; guint accounts; char *title; if (mini_dialog == NULL) return; accounts = pidgin_mini_dialog_get_num_children(mini_dialog); if (accounts == 0) { gtk_widget_destroy(GTK_WIDGET(mini_dialog)); return; } title = g_strdup_printf( ngettext("%d account was disabled because you signed on from another location:", "%d accounts were disabled because you signed on from another location:", accounts), accounts); pidgin_mini_dialog_set_description(mini_dialog, title); g_free(title); } static GtkWidget * create_account_label(PurpleAccount *account) { GtkWidget *hbox, *label; const char *username = purple_account_get_username(account); char *markup; hbox = gtk_hbox_new(FALSE, 6); g_object_set_data(G_OBJECT(hbox), OBJECT_DATA_KEY_ACCOUNT, account); pack_prpl_icon_start(hbox, account); label = gtk_label_new(NULL); markup = g_strdup_printf("<span size=\"smaller\">%s</span>", username); gtk_label_set_markup(GTK_LABEL(label), markup); g_free(markup); gtk_misc_set_alignment(GTK_MISC(label), 0, 0); #if GTK_CHECK_VERSION(2,6,0) g_object_set(G_OBJECT(label), "ellipsize", PANGO_ELLIPSIZE_END, NULL); #endif #if GTK_CHECK_VERSION(2,12,0) { /* avoid unused variable warnings on pre-2.12 Gtk */ char *description = purple_account_get_current_error(account)->description; if (description != NULL && *description != '\0') gtk_widget_set_tooltip_text(label, description); } #endif gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 0); return hbox; } static void add_to_signed_on_elsewhere(PurpleAccount *account) { PidginBuddyListPrivate *priv = PIDGIN_BUDDY_LIST_GET_PRIVATE(gtkblist); PidginMiniDialog *mini_dialog; GtkWidget *account_label; ensure_signed_on_elsewhere_minidialog(gtkblist); mini_dialog = priv->signed_on_elsewhere; if(find_child_widget_by_account(GTK_CONTAINER(mini_dialog->contents), account)) return; account_label = create_account_label(account); gtk_box_pack_start(mini_dialog->contents, account_label, FALSE, FALSE, 0); gtk_widget_show_all(account_label); update_signed_on_elsewhere_minidialog_title(); } static void remove_from_signed_on_elsewhere(PurpleAccount *account) { PidginBuddyListPrivate *priv = PIDGIN_BUDDY_LIST_GET_PRIVATE(gtkblist); PidginMiniDialog *mini_dialog = priv->signed_on_elsewhere; if(mini_dialog == NULL) return; remove_child_widget_by_account(GTK_CONTAINER(mini_dialog->contents), account); update_signed_on_elsewhere_minidialog_title(); } static void update_signed_on_elsewhere_tooltip(PurpleAccount *account, const char *description) { #if GTK_CHECK_VERSION(2,12,0) PidginBuddyListPrivate *priv = PIDGIN_BUDDY_LIST_GET_PRIVATE(gtkblist); GtkContainer *c = GTK_CONTAINER(priv->signed_on_elsewhere->contents); GtkWidget *label = find_child_widget_by_account(c, account); gtk_widget_set_tooltip_text(label, description); #endif } /* Call appropriate error notification code based on error types */ static void update_account_error_state(PurpleAccount *account, const PurpleConnectionErrorInfo *old, const PurpleConnectionErrorInfo *new, PidginBuddyList *gtkblist) { gboolean descriptions_differ; const char *desc; if (old == NULL && new == NULL) return; /* For backwards compatibility: */ if (new) pidgin_blist_update_account_error_state(account, new->description); else pidgin_blist_update_account_error_state(account, NULL); if (new != NULL) pidgin_blist_select_notebook_page(gtkblist); if (old != NULL && new == NULL) { if(old->type == PURPLE_CONNECTION_ERROR_NAME_IN_USE) remove_from_signed_on_elsewhere(account); else remove_generic_error_dialog(account); return; } if (old == NULL && new != NULL) { if(new->type == PURPLE_CONNECTION_ERROR_NAME_IN_USE) add_to_signed_on_elsewhere(account); else add_generic_error_dialog(account, new); return; } /* else, new and old are both non-NULL */ descriptions_differ = strcmp(old->description, new->description); desc = new->description; switch (new->type) { case PURPLE_CONNECTION_ERROR_NAME_IN_USE: if (old->type == PURPLE_CONNECTION_ERROR_NAME_IN_USE && descriptions_differ) { update_signed_on_elsewhere_tooltip(account, desc); } else { remove_generic_error_dialog(account); add_to_signed_on_elsewhere(account); } break; default: if (old->type == PURPLE_CONNECTION_ERROR_NAME_IN_USE) { remove_from_signed_on_elsewhere(account); add_generic_error_dialog(account, new); } else if (descriptions_differ) { update_generic_error_message(account, desc); } break; } } /* In case accounts are loaded before the blist (which they currently are), * let's call update_account_error_state ourselves on every account's current * state when the blist starts. */ static void show_initial_account_errors(PidginBuddyList *gtkblist) { GList *l = purple_accounts_get_all(); PurpleAccount *account; const PurpleConnectionErrorInfo *err; for (; l; l = l->next) { account = l->data; err = purple_account_get_current_error(account); update_account_error_state(account, NULL, err, gtkblist); } } void pidgin_blist_update_account_error_state(PurpleAccount *account, const char *text) { /* connection_errors isn't actually used anywhere; it's just kept in * sync with reality in case a plugin uses it. */ if (text == NULL) g_hash_table_remove(gtkblist->connection_errors, account); else g_hash_table_insert(gtkblist->connection_errors, account, g_strdup(text)); } static gboolean paint_headline_hbox (GtkWidget *widget, GdkEventExpose *event, gpointer user_data) { gtk_paint_flat_box (widget->style, widget->window, GTK_STATE_NORMAL, GTK_SHADOW_OUT, NULL, widget, "tooltip", widget->allocation.x + 1, widget->allocation.y + 1, widget->allocation.width - 2, widget->allocation.height - 2); return FALSE; } /* This assumes there are not things like groupless buddies or multi-leveled groups. * I'm sure other things in this code assumes that also. */ static void treeview_style_set (GtkWidget *widget, GtkStyle *prev_style, gpointer data) { PurpleBuddyList *list = data; PurpleBlistNode *node = list->root; while (node) { pidgin_blist_update_group(list, node); node = node->next; } } static void headline_style_set (GtkWidget *widget, GtkStyle *prev_style) { GtkTooltips *tooltips; GtkStyle *style; if (gtkblist->changing_style) return; tooltips = gtk_tooltips_new (); #if GLIB_CHECK_VERSION(2,10,0) g_object_ref_sink (tooltips); #else g_object_ref(tooltips); gtk_object_sink(GTK_OBJECT(tooltips)); #endif gtk_tooltips_force_window (tooltips); #if GTK_CHECK_VERSION(2, 12, 0) gtk_widget_set_name (tooltips->tip_window, "gtk-tooltips"); #endif gtk_widget_ensure_style (tooltips->tip_window); style = gtk_widget_get_style (tooltips->tip_window); gtkblist->changing_style = TRUE; gtk_widget_set_style (gtkblist->headline_hbox, style); gtkblist->changing_style = FALSE; g_object_unref (tooltips); } /******************************************/ /* End of connection error handling stuff */ /******************************************/ static int blist_focus_cb(GtkWidget *widget, GdkEventFocus *event, PidginBuddyList *gtkblist) { if(event->in) { gtk_blist_focused = TRUE; pidgin_set_urgent(GTK_WINDOW(gtkblist->window), FALSE); } else { gtk_blist_focused = FALSE; } return 0; } #if 0 static GtkWidget * kiosk_page() { GtkWidget *ret = gtk_vbox_new(FALSE, PIDGIN_HIG_BOX_SPACE); GtkWidget *label; GtkWidget *entry; GtkWidget *bbox; GtkWidget *button; label = gtk_label_new(NULL); gtk_box_pack_start(GTK_BOX(ret), label, TRUE, TRUE, 0); label = gtk_label_new(NULL); gtk_label_set_markup(GTK_LABEL(label), _("<b>Username:</b>")); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_box_pack_start(GTK_BOX(ret), label, FALSE, FALSE, 0); entry = gtk_entry_new(); gtk_box_pack_start(GTK_BOX(ret), entry, FALSE, FALSE, 0); label = gtk_label_new(NULL); gtk_label_set_markup(GTK_LABEL(label), _("<b>Password:</b>")); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_box_pack_start(GTK_BOX(ret), label, FALSE, FALSE, 0); entry = gtk_entry_new(); gtk_entry_set_visibility(GTK_ENTRY(entry), FALSE); gtk_box_pack_start(GTK_BOX(ret), entry, FALSE, FALSE, 0); label = gtk_label_new(" "); gtk_box_pack_start(GTK_BOX(ret), label, FALSE, FALSE, 0); bbox = gtk_hbutton_box_new(); button = gtk_button_new_with_mnemonic(_("_Login")); gtk_box_pack_start(GTK_BOX(ret), bbox, FALSE, FALSE, 0); gtk_container_add(GTK_CONTAINER(bbox), button); label = gtk_label_new(NULL); gtk_box_pack_start(GTK_BOX(ret), label, TRUE, TRUE, 0); gtk_container_set_border_width(GTK_CONTAINER(ret), PIDGIN_HIG_BORDER); gtk_widget_show_all(ret); return ret; } #endif /* builds the blist layout according to to the current theme */ static void pidgin_blist_build_layout(PurpleBuddyList *list) { GtkTreeViewColumn *column; PidginBlistLayout *layout; PidginBlistTheme *theme; GtkCellRenderer *rend; gint i, status_icon = 0, text = 1, emblem = 2, protocol_icon = 3, buddy_icon = 4; column = gtkblist->text_column; if ((theme = pidgin_blist_get_theme()) != NULL && (layout = pidgin_blist_theme_get_layout(theme)) != NULL) { status_icon = layout->status_icon ; text = layout->text; emblem = layout->emblem; protocol_icon = layout->protocol_icon; buddy_icon = layout->buddy_icon; } gtk_tree_view_column_clear(column); /* group */ rend = pidgin_cell_renderer_expander_new(); gtk_tree_view_column_pack_start(column, rend, FALSE); gtk_tree_view_column_set_attributes(column, rend, "visible", GROUP_EXPANDER_VISIBLE_COLUMN, "expander-visible", GROUP_EXPANDER_COLUMN, #if GTK_CHECK_VERSION(2,6,0) "sensitive", GROUP_EXPANDER_COLUMN, "cell-background-gdk", BGCOLOR_COLUMN, #endif NULL); /* contact */ rend = pidgin_cell_renderer_expander_new(); gtk_tree_view_column_pack_start(column, rend, FALSE); gtk_tree_view_column_set_attributes(column, rend, "visible", CONTACT_EXPANDER_VISIBLE_COLUMN, "expander-visible", CONTACT_EXPANDER_COLUMN, #if GTK_CHECK_VERSION(2,6,0) "sensitive", CONTACT_EXPANDER_COLUMN, "cell-background-gdk", BGCOLOR_COLUMN, #endif NULL); for (i = 0; i < 5; i++) { if (status_icon == i) { /* status icons */ rend = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start(column, rend, FALSE); gtk_tree_view_column_set_attributes(column, rend, "pixbuf", STATUS_ICON_COLUMN, "visible", STATUS_ICON_VISIBLE_COLUMN, #if GTK_CHECK_VERSION(2,6,0) "cell-background-gdk", BGCOLOR_COLUMN, #endif NULL); g_object_set(rend, "xalign", 0.0, "xpad", 6, "ypad", 0, NULL); } else if (text == i) { /* name */ gtkblist->text_rend = rend = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, rend, TRUE); gtk_tree_view_column_set_attributes(column, rend, #if GTK_CHECK_VERSION(2,6,0) "cell-background-gdk", BGCOLOR_COLUMN, #endif "markup", NAME_COLUMN, NULL); #if GTK_CHECK_VERSION(2,6,0) g_signal_connect(G_OBJECT(rend), "editing-started", G_CALLBACK(gtk_blist_renderer_editing_started_cb), NULL); g_signal_connect(G_OBJECT(rend), "editing-canceled", G_CALLBACK(gtk_blist_renderer_editing_cancelled_cb), list); #endif g_signal_connect(G_OBJECT(rend), "edited", G_CALLBACK(gtk_blist_renderer_edited_cb), list); g_object_set(rend, "ypad", 0, "yalign", 0.5, NULL); #if GTK_CHECK_VERSION(2,6,0) g_object_set(rend, "ellipsize", PANGO_ELLIPSIZE_END, NULL); #endif /* idle */ rend = gtk_cell_renderer_text_new(); g_object_set(rend, "xalign", 1.0, "ypad", 0, NULL); gtk_tree_view_column_pack_start(column, rend, FALSE); gtk_tree_view_column_set_attributes(column, rend, "markup", IDLE_COLUMN, "visible", IDLE_VISIBLE_COLUMN, #if GTK_CHECK_VERSION(2,6,0) "cell-background-gdk", BGCOLOR_COLUMN, #endif NULL); } else if (emblem == i) { /* emblem */ rend = gtk_cell_renderer_pixbuf_new(); g_object_set(rend, "xalign", 1.0, "yalign", 0.5, "ypad", 0, "xpad", 3, NULL); gtk_tree_view_column_pack_start(column, rend, FALSE); gtk_tree_view_column_set_attributes(column, rend, "pixbuf", EMBLEM_COLUMN, #if GTK_CHECK_VERSION(2,6,0) "cell-background-gdk", BGCOLOR_COLUMN, #endif "visible", EMBLEM_VISIBLE_COLUMN, NULL); } else if (protocol_icon == i) { /* protocol icon */ rend = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start(column, rend, FALSE); gtk_tree_view_column_set_attributes(column, rend, "pixbuf", PROTOCOL_ICON_COLUMN, "visible", PROTOCOL_ICON_VISIBLE_COLUMN, #if GTK_CHECK_VERSION(2,6,0) "cell-background-gdk", BGCOLOR_COLUMN, #endif NULL); g_object_set(rend, "xalign", 0.0, "xpad", 3, "ypad", 0, NULL); } else if (buddy_icon == i) { /* buddy icon */ rend = gtk_cell_renderer_pixbuf_new(); g_object_set(rend, "xalign", 1.0, "ypad", 0, NULL); gtk_tree_view_column_pack_start(column, rend, FALSE); gtk_tree_view_column_set_attributes(column, rend, "pixbuf", BUDDY_ICON_COLUMN, #if GTK_CHECK_VERSION(2,6,0) "cell-background-gdk", BGCOLOR_COLUMN, #endif "visible", BUDDY_ICON_VISIBLE_COLUMN, NULL); } }/* end for loop */ } static void pidgin_blist_show(PurpleBuddyList *list) { PidginBuddyListPrivate *priv; void *handle; GtkTreeViewColumn *column; GtkWidget *menu; GtkWidget *ebox; GtkWidget *sw; GtkWidget *sep; GtkWidget *label; char *pretty, *tmp; GtkAccelGroup *accel_group; GtkTreeSelection *selection; GtkTargetEntry dte[] = {{"PURPLE_BLIST_NODE", GTK_TARGET_SAME_APP, DRAG_ROW}, {"application/x-im-contact", 0, DRAG_BUDDY}, {"text/x-vcard", 0, DRAG_VCARD }, {"text/uri-list", 0, DRAG_URI}, {"text/plain", 0, DRAG_TEXT}}; GtkTargetEntry ste[] = {{"PURPLE_BLIST_NODE", GTK_TARGET_SAME_APP, DRAG_ROW}, {"application/x-im-contact", 0, DRAG_BUDDY}, {"text/x-vcard", 0, DRAG_VCARD }}; if (gtkblist && gtkblist->window) { purple_blist_set_visible(purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/blist/list_visible")); return; } gtkblist = PIDGIN_BLIST(list); priv = PIDGIN_BUDDY_LIST_GET_PRIVATE(gtkblist); priv->current_theme = PIDGIN_BLIST_THEME(purple_theme_manager_find_theme(purple_prefs_get_string(PIDGIN_PREFS_ROOT "/blist/theme"), "blist")); gtkblist->empty_avatar = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, 32, 32); gdk_pixbuf_fill(gtkblist->empty_avatar, 0x00000000); gtkblist->window = pidgin_create_window(_("Buddy List"), 0, "buddy_list", TRUE); g_signal_connect(G_OBJECT(gtkblist->window), "focus-in-event", G_CALLBACK(blist_focus_cb), gtkblist); g_signal_connect(G_OBJECT(gtkblist->window), "focus-out-event", G_CALLBACK(blist_focus_cb), gtkblist); GTK_WINDOW(gtkblist->window)->allow_shrink = TRUE; gtkblist->main_vbox = gtk_vbox_new(FALSE, 0); gtk_widget_show(gtkblist->main_vbox); gtk_container_add(GTK_CONTAINER(gtkblist->window), gtkblist->main_vbox); g_signal_connect(G_OBJECT(gtkblist->window), "delete_event", G_CALLBACK(gtk_blist_delete_cb), NULL); g_signal_connect(G_OBJECT(gtkblist->window), "configure_event", G_CALLBACK(gtk_blist_configure_cb), NULL); g_signal_connect(G_OBJECT(gtkblist->window), "visibility_notify_event", G_CALLBACK(gtk_blist_visibility_cb), NULL); g_signal_connect(G_OBJECT(gtkblist->window), "window_state_event", G_CALLBACK(gtk_blist_window_state_cb), NULL); g_signal_connect(G_OBJECT(gtkblist->window), "key_press_event", G_CALLBACK(gtk_blist_window_key_press_cb), gtkblist); gtk_widget_add_events(gtkblist->window, GDK_VISIBILITY_NOTIFY_MASK); /******************************* Menu bar *************************************/ accel_group = gtk_accel_group_new(); gtk_window_add_accel_group(GTK_WINDOW (gtkblist->window), accel_group); g_object_unref(accel_group); gtkblist->ift = gtk_item_factory_new(GTK_TYPE_MENU_BAR, "<PurpleMain>", accel_group); gtk_item_factory_set_translate_func(gtkblist->ift, (GtkTranslateFunc)item_factory_translate_func, NULL, NULL); gtk_item_factory_create_items(gtkblist->ift, sizeof(blist_menu) / sizeof(*blist_menu), blist_menu, NULL); pidgin_load_accels(); g_signal_connect(G_OBJECT(accel_group), "accel-changed", G_CALLBACK(pidgin_save_accels_cb), NULL); menu = gtk_item_factory_get_widget(gtkblist->ift, "<PurpleMain>"); gtkblist->menutray = pidgin_menu_tray_new(); gtk_menu_shell_append(GTK_MENU_SHELL(menu), gtkblist->menutray); gtk_widget_show(gtkblist->menutray); gtk_widget_show(menu); gtk_box_pack_start(GTK_BOX(gtkblist->main_vbox), menu, FALSE, FALSE, 0); accountmenu = gtk_item_factory_get_widget(gtkblist->ift, N_("/Accounts")); /****************************** Notebook *************************************/ gtkblist->notebook = gtk_notebook_new(); gtk_notebook_set_show_tabs(GTK_NOTEBOOK(gtkblist->notebook), FALSE); gtk_notebook_set_show_border(GTK_NOTEBOOK(gtkblist->notebook), FALSE); gtk_box_pack_start(GTK_BOX(gtkblist->main_vbox), gtkblist->notebook, TRUE, TRUE, 0); #if 0 gtk_notebook_append_page(GTK_NOTEBOOK(gtkblist->notebook), kiosk_page(), NULL); #endif /* Translators: Please maintain the use of -> and <- to refer to menu heirarchy */ tmp = g_strdup_printf(_("<span weight='bold' size='larger'>Welcome to %s!</span>\n\n" "You have no accounts enabled. Enable your IM accounts from the " "<b>Accounts</b> window at <b>Accounts->Manage Accounts</b>. Once you " "enable accounts, you'll be able to sign on, set your status, " "and talk to your friends."), PIDGIN_NAME); pretty = pidgin_make_pretty_arrows(tmp); g_free(tmp); label = gtk_label_new(NULL); gtk_widget_set_size_request(label, purple_prefs_get_int(PIDGIN_PREFS_ROOT "/blist/width") - 12, -1); gtk_label_set_line_wrap(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0.5, 0.2); gtk_label_set_markup(GTK_LABEL(label), pretty); g_free(pretty); gtk_notebook_append_page(GTK_NOTEBOOK(gtkblist->notebook),label, NULL); gtkblist->vbox = gtk_vbox_new(FALSE, 0); gtk_notebook_append_page(GTK_NOTEBOOK(gtkblist->notebook), gtkblist->vbox, NULL); gtk_widget_show_all(gtkblist->notebook); pidgin_blist_select_notebook_page(gtkblist); ebox = gtk_event_box_new(); gtk_box_pack_start(GTK_BOX(gtkblist->vbox), ebox, FALSE, FALSE, 0); gtkblist->headline_hbox = gtk_hbox_new(FALSE, 3); gtk_container_set_border_width(GTK_CONTAINER(gtkblist->headline_hbox), 6); gtk_container_add(GTK_CONTAINER(ebox), gtkblist->headline_hbox); gtkblist->headline_image = gtk_image_new_from_pixbuf(NULL); gtk_misc_set_alignment(GTK_MISC(gtkblist->headline_image), 0.0, 0); gtkblist->headline_label = gtk_label_new(NULL); gtk_widget_set_size_request(gtkblist->headline_label, purple_prefs_get_int(PIDGIN_PREFS_ROOT "/blist/width")-25,-1); gtk_label_set_line_wrap(GTK_LABEL(gtkblist->headline_label), TRUE); gtk_box_pack_start(GTK_BOX(gtkblist->headline_hbox), gtkblist->headline_image, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(gtkblist->headline_hbox), gtkblist->headline_label, TRUE, TRUE, 0); g_signal_connect(gtkblist->headline_label, /* connecting on headline_hbox doesn't work, because the signal is not emitted when theme is changed */ "style-set", G_CALLBACK(headline_style_set), NULL); g_signal_connect (gtkblist->headline_hbox, "expose_event", G_CALLBACK (paint_headline_hbox), NULL); gtk_widget_set_name(gtkblist->headline_hbox, "gtk-tooltips"); gtkblist->headline_close = gtk_widget_render_icon(ebox, GTK_STOCK_CLOSE, gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_MICROSCOPIC), NULL); gtkblist->hand_cursor = gdk_cursor_new (GDK_HAND2); gtkblist->arrow_cursor = gdk_cursor_new (GDK_LEFT_PTR); g_signal_connect(G_OBJECT(ebox), "enter-notify-event", G_CALLBACK(headline_box_enter_cb), gtkblist); g_signal_connect(G_OBJECT(ebox), "leave-notify-event", G_CALLBACK(headline_box_leave_cb), gtkblist); g_signal_connect(G_OBJECT(ebox), "button-press-event", G_CALLBACK(headline_box_press_cb), gtkblist); #if 0 /* I couldn't get this to work. The idea was to draw the focus-border only * when hovering over the close image. So for now, the focus-border is * always there. -- sad */ gtk_widget_set_events(ebox, gtk_widget_get_events(ebox) | GDK_POINTER_MOTION_HINT_MASK); g_signal_connect(G_OBJECT(ebox), "motion-notify-event", G_CALLBACK(headline_box_motion_cb), gtkblist); #endif /****************************** GtkTreeView **********************************/ sw = gtk_scrolled_window_new(NULL,NULL); gtk_widget_show(sw); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW(sw), GTK_SHADOW_NONE); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtkblist->treemodel = gtk_tree_store_new(BLIST_COLUMNS, GDK_TYPE_PIXBUF, /* Status icon */ G_TYPE_BOOLEAN, /* Status icon visible */ G_TYPE_STRING, /* Name */ G_TYPE_STRING, /* Idle */ G_TYPE_BOOLEAN, /* Idle visible */ GDK_TYPE_PIXBUF, /* Buddy icon */ G_TYPE_BOOLEAN, /* Buddy icon visible */ G_TYPE_POINTER, /* Node */ GDK_TYPE_COLOR, /* bgcolor */ G_TYPE_BOOLEAN, /* Group expander */ G_TYPE_BOOLEAN, /* Group expander visible */ G_TYPE_BOOLEAN, /* Contact expander */ G_TYPE_BOOLEAN, /* Contact expander visible */ GDK_TYPE_PIXBUF, /* Emblem */ G_TYPE_BOOLEAN, /* Emblem visible */ GDK_TYPE_PIXBUF, /* Protocol icon */ G_TYPE_BOOLEAN /* Protocol visible */ ); gtkblist->treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(gtkblist->treemodel)); gtk_widget_show(gtkblist->treeview); gtk_widget_set_name(gtkblist->treeview, "pidgin_blist_treeview"); g_signal_connect(gtkblist->treeview, "style-set", G_CALLBACK(treeview_style_set), list); /* Set up selection stuff */ selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(gtkblist->treeview)); g_signal_connect(G_OBJECT(selection), "changed", G_CALLBACK(pidgin_blist_selection_changed), NULL); /* Set up dnd */ gtk_tree_view_enable_model_drag_source(GTK_TREE_VIEW(gtkblist->treeview), GDK_BUTTON1_MASK, ste, 3, GDK_ACTION_COPY); gtk_tree_view_enable_model_drag_dest(GTK_TREE_VIEW(gtkblist->treeview), dte, 5, GDK_ACTION_COPY | GDK_ACTION_MOVE); g_signal_connect(G_OBJECT(gtkblist->treeview), "drag-data-received", G_CALLBACK(pidgin_blist_drag_data_rcv_cb), NULL); g_signal_connect(G_OBJECT(gtkblist->treeview), "drag-data-get", G_CALLBACK(pidgin_blist_drag_data_get_cb), NULL); #ifdef _WIN32 g_signal_connect(G_OBJECT(gtkblist->treeview), "drag-begin", G_CALLBACK(pidgin_blist_drag_begin), NULL); #endif g_signal_connect(G_OBJECT(gtkblist->treeview), "drag-motion", G_CALLBACK(pidgin_blist_drag_motion_cb), NULL); g_signal_connect(G_OBJECT(gtkblist->treeview), "motion-notify-event", G_CALLBACK(pidgin_blist_motion_cb), NULL); g_signal_connect(G_OBJECT(gtkblist->treeview), "leave-notify-event", G_CALLBACK(pidgin_blist_leave_cb), NULL); /* Tooltips */ pidgin_tooltip_setup_for_treeview(gtkblist->treeview, NULL, pidgin_blist_create_tooltip, pidgin_blist_paint_tip); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(gtkblist->treeview), FALSE); /* expander columns */ column = gtk_tree_view_column_new(); gtk_tree_view_append_column(GTK_TREE_VIEW(gtkblist->treeview), column); gtk_tree_view_column_set_visible(column, FALSE); gtk_tree_view_set_expander_column(GTK_TREE_VIEW(gtkblist->treeview), column); /* everything else column */ gtkblist->text_column = gtk_tree_view_column_new (); gtk_tree_view_append_column(GTK_TREE_VIEW(gtkblist->treeview), gtkblist->text_column); pidgin_blist_build_layout(list); g_signal_connect(G_OBJECT(gtkblist->treeview), "row-activated", G_CALLBACK(gtk_blist_row_activated_cb), NULL); g_signal_connect(G_OBJECT(gtkblist->treeview), "row-expanded", G_CALLBACK(gtk_blist_row_expanded_cb), NULL); g_signal_connect(G_OBJECT(gtkblist->treeview), "row-collapsed", G_CALLBACK(gtk_blist_row_collapsed_cb), NULL); g_signal_connect(G_OBJECT(gtkblist->treeview), "button-press-event", G_CALLBACK(gtk_blist_button_press_cb), NULL); g_signal_connect(G_OBJECT(gtkblist->treeview), "key-press-event", G_CALLBACK(gtk_blist_key_press_cb), NULL); g_signal_connect(G_OBJECT(gtkblist->treeview), "popup-menu", G_CALLBACK(pidgin_blist_popup_menu_cb), NULL); /* Enable CTRL+F searching */ gtk_tree_view_set_search_column(GTK_TREE_VIEW(gtkblist->treeview), NAME_COLUMN); gtk_tree_view_set_search_equal_func(GTK_TREE_VIEW(gtkblist->treeview), pidgin_tree_view_search_equal_func, NULL, NULL); gtk_box_pack_start(GTK_BOX(gtkblist->vbox), sw, TRUE, TRUE, 0); gtk_container_add(GTK_CONTAINER(sw), gtkblist->treeview); sep = gtk_hseparator_new(); gtk_box_pack_start(GTK_BOX(gtkblist->vbox), sep, FALSE, FALSE, 0); gtkblist->scrollbook = pidgin_scroll_book_new(); gtk_box_pack_start(GTK_BOX(gtkblist->vbox), gtkblist->scrollbook, FALSE, FALSE, 0); /* Create an vbox which holds the scrollbook which is actually used to * display connection errors. The vbox needs to still exist for * backwards compatibility. */ gtkblist->error_buttons = gtk_vbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(gtkblist->vbox), gtkblist->error_buttons, FALSE, FALSE, 0); gtk_container_set_border_width(GTK_CONTAINER(gtkblist->error_buttons), 0); priv->error_scrollbook = PIDGIN_SCROLL_BOOK(pidgin_scroll_book_new()); gtk_box_pack_start(GTK_BOX(gtkblist->error_buttons), GTK_WIDGET(priv->error_scrollbook), FALSE, FALSE, 0); /* Add the statusbox */ gtkblist->statusbox = pidgin_status_box_new(); gtk_box_pack_start(GTK_BOX(gtkblist->vbox), gtkblist->statusbox, FALSE, TRUE, 0); gtk_widget_set_name(gtkblist->statusbox, "pidgin_blist_statusbox"); gtk_container_set_border_width(GTK_CONTAINER(gtkblist->statusbox), 3); gtk_widget_show(gtkblist->statusbox); /* set the Show Offline Buddies option. must be done * after the treeview or faceprint gets mad. -Robot101 */ gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(gtk_item_factory_get_item (gtkblist->ift, N_("/Buddies/Show/Offline Buddies"))), purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/blist/show_offline_buddies")); gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(gtk_item_factory_get_item (gtkblist->ift, N_("/Buddies/Show/Empty Groups"))), purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/blist/show_empty_groups")); gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(gtk_item_factory_get_item (gtkblist->ift, N_("/Tools/Mute Sounds"))), purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/sound/mute")); gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(gtk_item_factory_get_item (gtkblist->ift, N_("/Buddies/Show/Buddy Details"))), purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/blist/show_buddy_icons")); gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(gtk_item_factory_get_item (gtkblist->ift, N_("/Buddies/Show/Idle Times"))), purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/blist/show_idle_time")); gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(gtk_item_factory_get_item (gtkblist->ift, N_("/Buddies/Show/Protocol Icons"))), purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/blist/show_protocol_icons")); if(!strcmp(purple_prefs_get_string(PIDGIN_PREFS_ROOT "/sound/method"), "none")) gtk_widget_set_sensitive(gtk_item_factory_get_widget(gtkblist->ift, N_("/Tools/Mute Sounds")), FALSE); /* Update some dynamic things */ update_menu_bar(gtkblist); pidgin_blist_update_plugin_actions(); pidgin_blist_update_sort_methods(); /* OK... let's show this bad boy. */ pidgin_blist_refresh(list); pidgin_blist_restore_position(); gtk_widget_show_all(GTK_WIDGET(gtkblist->vbox)); gtk_widget_realize(GTK_WIDGET(gtkblist->window)); purple_blist_set_visible(purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/blist/list_visible")); /* start the refresh timer */ gtkblist->refresh_timer = g_timeout_add(30000, (GSourceFunc)pidgin_blist_refresh_timer, list); handle = pidgin_blist_get_handle(); /* things that affect how buddies are displayed */ purple_prefs_connect_callback(handle, PIDGIN_PREFS_ROOT "/blist/show_buddy_icons", _prefs_change_redo_list, NULL); purple_prefs_connect_callback(handle, PIDGIN_PREFS_ROOT "/blist/show_idle_time", _prefs_change_redo_list, NULL); purple_prefs_connect_callback(handle, PIDGIN_PREFS_ROOT "/blist/show_empty_groups", _prefs_change_redo_list, NULL); purple_prefs_connect_callback(handle, PIDGIN_PREFS_ROOT "/blist/show_offline_buddies", _prefs_change_redo_list, NULL); purple_prefs_connect_callback(handle, PIDGIN_PREFS_ROOT "/blist/show_protocol_icons", _prefs_change_redo_list, NULL); /* sorting */ purple_prefs_connect_callback(handle, PIDGIN_PREFS_ROOT "/blist/sort_type", _prefs_change_sort_method, NULL); /* menus */ purple_prefs_connect_callback(handle, PIDGIN_PREFS_ROOT "/sound/mute", pidgin_blist_mute_pref_cb, NULL); purple_prefs_connect_callback(handle, PIDGIN_PREFS_ROOT "/sound/method", pidgin_blist_sound_method_pref_cb, NULL); /* Setup some purple signal handlers. */ handle = purple_accounts_get_handle(); purple_signal_connect(handle, "account-enabled", gtkblist, PURPLE_CALLBACK(account_modified), gtkblist); purple_signal_connect(handle, "account-disabled", gtkblist, PURPLE_CALLBACK(account_modified), gtkblist); purple_signal_connect(handle, "account-removed", gtkblist, PURPLE_CALLBACK(account_modified), gtkblist); purple_signal_connect(handle, "account-status-changed", gtkblist, PURPLE_CALLBACK(account_status_changed), gtkblist); purple_signal_connect(handle, "account-error-changed", gtkblist, PURPLE_CALLBACK(update_account_error_state), gtkblist); handle = pidgin_account_get_handle(); purple_signal_connect(handle, "account-modified", gtkblist, PURPLE_CALLBACK(account_modified), gtkblist); handle = purple_connections_get_handle(); purple_signal_connect(handle, "signed-on", gtkblist, PURPLE_CALLBACK(sign_on_off_cb), list); purple_signal_connect(handle, "signed-off", gtkblist, PURPLE_CALLBACK(sign_on_off_cb), list); handle = purple_plugins_get_handle(); purple_signal_connect(handle, "plugin-load", gtkblist, PURPLE_CALLBACK(plugin_changed_cb), NULL); purple_signal_connect(handle, "plugin-unload", gtkblist, PURPLE_CALLBACK(plugin_changed_cb), NULL); handle = purple_conversations_get_handle(); purple_signal_connect(handle, "conversation-updated", gtkblist, PURPLE_CALLBACK(conversation_updated_cb), gtkblist); purple_signal_connect(handle, "deleting-conversation", gtkblist, PURPLE_CALLBACK(conversation_deleting_cb), gtkblist); purple_signal_connect(handle, "conversation-created", gtkblist, PURPLE_CALLBACK(conversation_created_cb), gtkblist); gtk_widget_hide(gtkblist->headline_hbox); show_initial_account_errors(gtkblist); /* emit our created signal */ handle = pidgin_blist_get_handle(); purple_signal_emit(handle, "gtkblist-created", list); } static void redo_buddy_list(PurpleBuddyList *list, gboolean remove, gboolean rerender) { PurpleBlistNode *node; gtkblist = PIDGIN_BLIST(list); if(!gtkblist || !gtkblist->treeview) return; node = list->root; while (node) { /* This is only needed when we're reverting to a non-GTK+ sorted * status. We shouldn't need to remove otherwise. */ if (remove && !PURPLE_BLIST_NODE_IS_GROUP(node)) pidgin_blist_hide_node(list, node, FALSE); if (PURPLE_BLIST_NODE_IS_BUDDY(node)) pidgin_blist_update_buddy(list, node, rerender); else if (PURPLE_BLIST_NODE_IS_CHAT(node)) pidgin_blist_update(list, node); else if (PURPLE_BLIST_NODE_IS_GROUP(node)) pidgin_blist_update(list, node); node = purple_blist_node_next(node, FALSE); } } void pidgin_blist_refresh(PurpleBuddyList *list) { redo_buddy_list(list, FALSE, TRUE); } void pidgin_blist_update_refresh_timeout() { PurpleBuddyList *blist; PidginBuddyList *gtkblist; blist = purple_get_blist(); gtkblist = PIDGIN_BLIST(purple_get_blist()); gtkblist->refresh_timer = g_timeout_add(30000,(GSourceFunc)pidgin_blist_refresh_timer, blist); } static gboolean get_iter_from_node(PurpleBlistNode *node, GtkTreeIter *iter) { struct _pidgin_blist_node *gtknode = (struct _pidgin_blist_node *)node->ui_data; GtkTreePath *path; if (!gtknode) { return FALSE; } if (!gtkblist) { purple_debug_error("gtkblist", "get_iter_from_node was called, but we don't seem to have a blist\n"); return FALSE; } if (!gtknode->row) return FALSE; if ((path = gtk_tree_row_reference_get_path(gtknode->row)) == NULL) return FALSE; if (!gtk_tree_model_get_iter(GTK_TREE_MODEL(gtkblist->treemodel), iter, path)) { gtk_tree_path_free(path); return FALSE; } gtk_tree_path_free(path); return TRUE; } static void pidgin_blist_remove(PurpleBuddyList *list, PurpleBlistNode *node) { struct _pidgin_blist_node *gtknode = node->ui_data; purple_request_close_with_handle(node); pidgin_blist_hide_node(list, node, TRUE); if(node->parent) pidgin_blist_update(list, node->parent); /* There's something I don't understand here - Ethan */ /* Ethan said that back in 2003, but this g_free has been left commented * out ever since. I can't find any reason at all why this is bad and * valgrind found several reasons why it's good. If this causes problems * comment it out again. Stu */ /* Of course it still causes problems - this breaks dragging buddies into * contacts, the dragged buddy mysteriously 'disappears'. Stu. */ /* I think it's fixed now. Stu. */ if(gtknode) { if(gtknode->recent_signonoff_timer > 0) purple_timeout_remove(gtknode->recent_signonoff_timer); purple_signals_disconnect_by_handle(node->ui_data); g_free(node->ui_data); node->ui_data = NULL; } } static gboolean do_selection_changed(PurpleBlistNode *new_selection) { PurpleBlistNode *old_selection = NULL; /* test for gtkblist because crazy timeout means we can be called after the blist is gone */ if (gtkblist && new_selection != gtkblist->selected_node) { old_selection = gtkblist->selected_node; gtkblist->selected_node = new_selection; if(new_selection) pidgin_blist_update(NULL, new_selection); if(old_selection) pidgin_blist_update(NULL, old_selection); } return FALSE; } static void pidgin_blist_selection_changed(GtkTreeSelection *selection, gpointer data) { PurpleBlistNode *new_selection = NULL; GtkTreeIter iter; if(gtk_tree_selection_get_selected(selection, NULL, &iter)){ gtk_tree_model_get(GTK_TREE_MODEL(gtkblist->treemodel), &iter, NODE_COLUMN, &new_selection, -1); } /* we set this up as a timeout, otherwise the blist flickers ... * but we don't do it for groups, because it causes total bizarness - * the previously selected buddy node might rendered at half height. */ if ((new_selection != NULL) && PURPLE_BLIST_NODE_IS_GROUP(new_selection)) { do_selection_changed(new_selection); } else { g_timeout_add(0, (GSourceFunc)do_selection_changed, new_selection); } } static gboolean insert_node(PurpleBuddyList *list, PurpleBlistNode *node, GtkTreeIter *iter) { GtkTreeIter parent_iter, cur, *curptr = NULL; struct _pidgin_blist_node *gtknode = node->ui_data; GtkTreePath *newpath; if(!iter) return FALSE; if(node->parent && !get_iter_from_node(node->parent, &parent_iter)) return FALSE; if(get_iter_from_node(node, &cur)) curptr = &cur; if(PURPLE_BLIST_NODE_IS_CONTACT(node) || PURPLE_BLIST_NODE_IS_CHAT(node)) { current_sort_method->func(node, list, parent_iter, curptr, iter); } else { sort_method_none(node, list, parent_iter, curptr, iter); } if(gtknode != NULL) { gtk_tree_row_reference_free(gtknode->row); } else { pidgin_blist_new_node(node); gtknode = (struct _pidgin_blist_node *)node->ui_data; } newpath = gtk_tree_model_get_path(GTK_TREE_MODEL(gtkblist->treemodel), iter); gtknode->row = gtk_tree_row_reference_new(GTK_TREE_MODEL(gtkblist->treemodel), newpath); gtk_tree_path_free(newpath); if (!editing_blist) gtk_tree_store_set(gtkblist->treemodel, iter, NODE_COLUMN, node, -1); if(node->parent) { GtkTreePath *expand = NULL; struct _pidgin_blist_node *gtkparentnode = node->parent->ui_data; if(PURPLE_BLIST_NODE_IS_GROUP(node->parent)) { if(!purple_blist_node_get_bool(node->parent, "collapsed")) expand = gtk_tree_model_get_path(GTK_TREE_MODEL(gtkblist->treemodel), &parent_iter); } else if(PURPLE_BLIST_NODE_IS_CONTACT(node->parent) && gtkparentnode->contact_expanded) { expand = gtk_tree_model_get_path(GTK_TREE_MODEL(gtkblist->treemodel), &parent_iter); } if(expand) { gtk_tree_view_expand_row(GTK_TREE_VIEW(gtkblist->treeview), expand, FALSE); gtk_tree_path_free(expand); } } return TRUE; } static gboolean pidgin_blist_group_has_show_offline_buddy(PurpleGroup *group) { PurpleBlistNode *gnode, *cnode, *bnode; gnode = (PurpleBlistNode *)group; for(cnode = gnode->child; cnode; cnode = cnode->next) { if(PURPLE_BLIST_NODE_IS_CONTACT(cnode)) { for(bnode = cnode->child; bnode; bnode = bnode->next) { PurpleBuddy *buddy = (PurpleBuddy *)bnode; if (purple_account_is_connected(buddy->account) && purple_blist_node_get_bool(bnode, "show_offline")) return TRUE; } } } return FALSE; } /* This version of pidgin_blist_update_group can take the original buddy or a * group, but has much better algorithmic performance with a pre-known buddy. */ static void pidgin_blist_update_group(PurpleBuddyList *list, PurpleBlistNode *node) { gint count; PurpleGroup *group; PurpleBlistNode* gnode; gboolean show = FALSE, show_offline = FALSE; g_return_if_fail(node != NULL); if (editing_blist) return; if (PURPLE_BLIST_NODE_IS_GROUP(node)) gnode = node; else if (PURPLE_BLIST_NODE_IS_BUDDY(node)) gnode = node->parent->parent; else if (PURPLE_BLIST_NODE_IS_CONTACT(node) || PURPLE_BLIST_NODE_IS_CHAT(node)) gnode = node->parent; else return; group = (PurpleGroup*)gnode; show_offline = purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/blist/show_offline_buddies"); if(show_offline) count = purple_blist_get_group_size(group, FALSE); else count = purple_blist_get_group_online_count(group); if (count > 0 || purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/blist/show_empty_groups")) show = TRUE; else if (PURPLE_BLIST_NODE_IS_BUDDY(node)) { /* Or chat? */ if (buddy_is_displayable((PurpleBuddy*)node)) show = TRUE; } else if (!show_offline && PURPLE_BLIST_NODE_IS_GROUP(node)) { show = pidgin_blist_group_has_show_offline_buddy(group); } if (show) { gchar *title; gboolean biglist; GtkTreeIter iter; GtkTreePath *path; gboolean expanded; GdkColor *bgcolor = NULL; GdkPixbuf *avatar = NULL; PidginBlistTheme *theme = NULL; if(!insert_node(list, gnode, &iter)) return; if ((theme = pidgin_blist_get_theme()) == NULL) bgcolor = NULL; else if (purple_blist_node_get_bool(gnode, "collapsed") || count <= 0) bgcolor = pidgin_blist_theme_get_collapsed_background_color(theme); else bgcolor = pidgin_blist_theme_get_expanded_background_color(theme); path = gtk_tree_model_get_path(GTK_TREE_MODEL(gtkblist->treemodel), &iter); expanded = gtk_tree_view_row_expanded(GTK_TREE_VIEW(gtkblist->treeview), path); gtk_tree_path_free(path); title = pidgin_get_group_title(gnode, expanded); biglist = purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/blist/show_buddy_icons"); if (biglist) { avatar = pidgin_blist_get_buddy_icon(gnode, TRUE, TRUE); } gtk_tree_store_set(gtkblist->treemodel, &iter, STATUS_ICON_VISIBLE_COLUMN, FALSE, STATUS_ICON_COLUMN, NULL, NAME_COLUMN, title, NODE_COLUMN, gnode, BGCOLOR_COLUMN, bgcolor, GROUP_EXPANDER_COLUMN, TRUE, GROUP_EXPANDER_VISIBLE_COLUMN, TRUE, CONTACT_EXPANDER_VISIBLE_COLUMN, FALSE, BUDDY_ICON_COLUMN, avatar, BUDDY_ICON_VISIBLE_COLUMN, biglist, IDLE_VISIBLE_COLUMN, FALSE, EMBLEM_VISIBLE_COLUMN, FALSE, -1); g_free(title); } else { pidgin_blist_hide_node(list, gnode, TRUE); } } static char *pidgin_get_group_title(PurpleBlistNode *gnode, gboolean expanded) { PurpleGroup *group; gboolean selected; char group_count[12] = ""; char *mark, *esc; PurpleBlistNode *selected_node = NULL; GtkTreeIter iter; FontColorPair *pair; gchar *text_color, *text_font; PidginBlistTheme *theme; group = (PurpleGroup*)gnode; if (gtk_tree_selection_get_selected(gtk_tree_view_get_selection(GTK_TREE_VIEW(gtkblist->treeview)), NULL, &iter)) { gtk_tree_model_get(GTK_TREE_MODEL(gtkblist->treemodel), &iter, NODE_COLUMN, &selected_node, -1); } selected = (gnode == selected_node); if (!expanded) { g_snprintf(group_count, sizeof(group_count), " (%d/%d)", purple_blist_get_group_online_count(group), purple_blist_get_group_size(group, FALSE)); } theme = pidgin_blist_get_theme(); if (theme == NULL) pair = NULL; else if (expanded) pair = pidgin_blist_theme_get_expanded_text_info(theme); else pair = pidgin_blist_theme_get_collapsed_text_info(theme); text_color = (selected || pair == NULL || pair->color == NULL) ? NULL : pair->color; text_font = (pair == NULL || pair->font == NULL) ? "" : pair->font; esc = g_markup_escape_text(group->name, -1); if (text_color) { mark = g_strdup_printf("<span foreground='%s' font_desc='%s'><b>%s</b>%s</span>", text_color, text_font, esc ? esc : "", group_count); } else { mark = g_strdup_printf("<span font_desc='%s'><b>%s</b>%s</span>", text_font, esc ? esc : "", group_count); } g_free(esc); return mark; } static void buddy_node(PurpleBuddy *buddy, GtkTreeIter *iter, PurpleBlistNode *node) { PurplePresence *presence = purple_buddy_get_presence(buddy); GdkPixbuf *status, *avatar, *emblem, *prpl_icon; GdkColor *color = NULL; char *mark; char *idle = NULL; gboolean expanded = ((struct _pidgin_blist_node *)(node->parent->ui_data))->contact_expanded; gboolean selected = (gtkblist->selected_node == node); gboolean biglist = purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/blist/show_buddy_icons"); PidginBlistTheme *theme; if (editing_blist) return; status = pidgin_blist_get_status_icon((PurpleBlistNode*)buddy, biglist ? PIDGIN_STATUS_ICON_LARGE : PIDGIN_STATUS_ICON_SMALL); /* Speed it up if we don't want buddy icons. */ if(biglist) avatar = pidgin_blist_get_buddy_icon((PurpleBlistNode *)buddy, TRUE, TRUE); else avatar = NULL; if (!avatar) { g_object_ref(G_OBJECT(gtkblist->empty_avatar)); avatar = gtkblist->empty_avatar; } else if ((!PURPLE_BUDDY_IS_ONLINE(buddy) || purple_presence_is_idle(presence))) { do_alphashift(avatar, avatar, 77); } emblem = pidgin_blist_get_emblem((PurpleBlistNode*) buddy); mark = pidgin_blist_get_name_markup(buddy, selected, TRUE); theme = pidgin_blist_get_theme(); if (purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/blist/show_idle_time") && purple_presence_is_idle(presence) && !biglist) { time_t idle_secs = purple_presence_get_idle_time(presence); if (idle_secs > 0) { FontColorPair *pair = NULL; const gchar *textcolor; time_t t; int ihrs, imin; time(&t); ihrs = (t - idle_secs) / 3600; imin = ((t - idle_secs) / 60) % 60; if (!selected && theme != NULL && (pair = pidgin_blist_theme_get_idle_text_info(theme)) != NULL && pair->color != NULL) textcolor = pair->color; else textcolor = NULL; if (textcolor) { idle = g_strdup_printf("<span color='%s' font_desc='%s'>%d:%02d</span>", textcolor, (pair == NULL || pair->font == NULL) ? "" : pair->font, ihrs, imin); } else { idle = g_strdup_printf("<span font_desc='%s'>%d:%02d</span>", (pair == NULL || pair->font == NULL) ? "" : pair->font, ihrs, imin); } } } prpl_icon = pidgin_create_prpl_icon(buddy->account, PIDGIN_PRPL_ICON_SMALL); if (theme != NULL) color = pidgin_blist_theme_get_contact_color(theme); gtk_tree_store_set(gtkblist->treemodel, iter, STATUS_ICON_COLUMN, status, STATUS_ICON_VISIBLE_COLUMN, TRUE, NAME_COLUMN, mark, IDLE_COLUMN, idle, IDLE_VISIBLE_COLUMN, !biglist && idle, BUDDY_ICON_COLUMN, avatar, BUDDY_ICON_VISIBLE_COLUMN, biglist, EMBLEM_COLUMN, emblem, EMBLEM_VISIBLE_COLUMN, (emblem != NULL), PROTOCOL_ICON_COLUMN, prpl_icon, PROTOCOL_ICON_VISIBLE_COLUMN, purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/blist/show_protocol_icons"), BGCOLOR_COLUMN, color, CONTACT_EXPANDER_COLUMN, NULL, CONTACT_EXPANDER_VISIBLE_COLUMN, expanded, GROUP_EXPANDER_VISIBLE_COLUMN, FALSE, -1); g_free(mark); g_free(idle); if(emblem) g_object_unref(emblem); if(status) g_object_unref(status); if(avatar) g_object_unref(avatar); if(prpl_icon) g_object_unref(prpl_icon); } /* This is a variation on the original gtk_blist_update_contact. Here we can know in advance which buddy has changed so we can just update that */ static void pidgin_blist_update_contact(PurpleBuddyList *list, PurpleBlistNode *node) { PurpleBlistNode *cnode; PurpleContact *contact; PurpleBuddy *buddy; gboolean biglist = purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/blist/show_buddy_icons"); struct _pidgin_blist_node *gtknode; if (editing_blist) return; if (PURPLE_BLIST_NODE_IS_BUDDY(node)) cnode = node->parent; else cnode = node; g_return_if_fail(PURPLE_BLIST_NODE_IS_CONTACT(cnode)); /* First things first, update the group */ if (PURPLE_BLIST_NODE_IS_BUDDY(node)) pidgin_blist_update_group(list, node); else pidgin_blist_update_group(list, cnode->parent); contact = (PurpleContact*)cnode; buddy = purple_contact_get_priority_buddy(contact); if (buddy_is_displayable(buddy)) { GtkTreeIter iter; if(!insert_node(list, cnode, &iter)) return; gtknode = (struct _pidgin_blist_node *)cnode->ui_data; if(gtknode->contact_expanded) { GdkPixbuf *status; gchar *mark, *tmp; const gchar *fg_color, *font; GdkColor *color = NULL; PidginBlistTheme *theme = pidgin_blist_get_theme(); FontColorPair *pair; gboolean selected = (gtkblist->selected_node == cnode); mark = g_markup_escape_text(purple_contact_get_alias(contact), -1); theme = pidgin_blist_get_theme(); if (theme == NULL) pair = NULL; else { pair = pidgin_blist_theme_get_contact_text_info(theme); color = pidgin_blist_theme_get_contact_color(theme); } font = (pair == NULL || pair->font == NULL) ? "" : pair->font; fg_color = (selected || pair == NULL || pair->color == NULL) ? NULL : pair->color; if (fg_color) { tmp = g_strdup_printf("<span font_desc='%s' color='%s'>%s</span>", font, fg_color, mark); } else { tmp = g_strdup_printf("<span font_desc='%s'>%s</span>", font, mark); } g_free(mark); mark = tmp; status = pidgin_blist_get_status_icon(cnode, biglist? PIDGIN_STATUS_ICON_LARGE : PIDGIN_STATUS_ICON_SMALL); gtk_tree_store_set(gtkblist->treemodel, &iter, STATUS_ICON_COLUMN, status, STATUS_ICON_VISIBLE_COLUMN, TRUE, NAME_COLUMN, mark, IDLE_COLUMN, NULL, IDLE_VISIBLE_COLUMN, FALSE, BGCOLOR_COLUMN, color, BUDDY_ICON_COLUMN, NULL, CONTACT_EXPANDER_COLUMN, TRUE, CONTACT_EXPANDER_VISIBLE_COLUMN, TRUE, GROUP_EXPANDER_VISIBLE_COLUMN, FALSE, -1); g_free(mark); if(status) g_object_unref(status); } else { buddy_node(buddy, &iter, cnode); } } else { pidgin_blist_hide_node(list, cnode, TRUE); } } static void pidgin_blist_update_buddy(PurpleBuddyList *list, PurpleBlistNode *node, gboolean status_change) { PurpleBuddy *buddy; struct _pidgin_blist_node *gtkparentnode; g_return_if_fail(PURPLE_BLIST_NODE_IS_BUDDY(node)); if (node->parent == NULL) return; buddy = (PurpleBuddy*)node; /* First things first, update the contact */ pidgin_blist_update_contact(list, node); gtkparentnode = (struct _pidgin_blist_node *)node->parent->ui_data; if (gtkparentnode->contact_expanded && buddy_is_displayable(buddy)) { GtkTreeIter iter; if (!insert_node(list, node, &iter)) return; buddy_node(buddy, &iter, node); } else { pidgin_blist_hide_node(list, node, TRUE); } } static void pidgin_blist_update_chat(PurpleBuddyList *list, PurpleBlistNode *node) { PurpleChat *chat; g_return_if_fail(PURPLE_BLIST_NODE_IS_CHAT(node)); if (editing_blist) return; /* First things first, update the group */ pidgin_blist_update_group(list, node->parent); chat = (PurpleChat*)node; if(purple_account_is_connected(chat->account)) { GtkTreeIter iter; GdkPixbuf *status, *avatar, *emblem, *prpl_icon; const gchar *color, *font; gchar *mark, *tmp; gboolean showicons = purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/blist/show_buddy_icons"); gboolean biglist = purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/blist/show_buddy_icons"); PidginBlistNode *ui; PurpleConversation *conv; gboolean hidden = FALSE; GdkColor *bgcolor = NULL; FontColorPair *pair; PidginBlistTheme *theme; gboolean selected = (gtkblist->selected_node == node); gboolean nick_said = FALSE; if (!insert_node(list, node, &iter)) return; ui = node->ui_data; conv = ui->conv.conv; if (conv && pidgin_conv_is_hidden(PIDGIN_CONVERSATION(conv))) { hidden = (ui->conv.flags & PIDGIN_BLIST_NODE_HAS_PENDING_MESSAGE); nick_said = (ui->conv.flags & PIDGIN_BLIST_CHAT_HAS_PENDING_MESSAGE_WITH_NICK); } status = pidgin_blist_get_status_icon(node, biglist ? PIDGIN_STATUS_ICON_LARGE : PIDGIN_STATUS_ICON_SMALL); emblem = pidgin_blist_get_emblem(node); /* Speed it up if we don't want buddy icons. */ if(showicons) avatar = pidgin_blist_get_buddy_icon(node, TRUE, FALSE); else avatar = NULL; mark = g_markup_escape_text(purple_chat_get_name(chat), -1); theme = pidgin_blist_get_theme(); if (theme == NULL) pair = NULL; else if (nick_said) pair = pidgin_blist_theme_get_unread_message_nick_said_text_info(theme); else if (hidden) pair = pidgin_blist_theme_get_unread_message_text_info(theme); else pair = pidgin_blist_theme_get_online_text_info(theme); font = (pair == NULL || pair->font == NULL) ? "" : pair->font; if (selected || pair == NULL || pair->color == NULL) /* nick_said color is the same as gtkconv:tab-label-attention */ color = (nick_said ? "#006aff" : NULL); else color = pair->color; if (color) { tmp = g_strdup_printf("<span font_desc='%s' color='%s' weight='%s'>%s</span>", font, color, hidden ? "bold" : "normal", mark); } else { tmp = g_strdup_printf("<span font_desc='%s' weight='%s'>%s</span>", font, hidden ? "bold" : "normal", mark); } g_free(mark); mark = tmp; prpl_icon = pidgin_create_prpl_icon(chat->account, PIDGIN_PRPL_ICON_SMALL); if (theme != NULL) bgcolor = pidgin_blist_theme_get_contact_color(theme); gtk_tree_store_set(gtkblist->treemodel, &iter, STATUS_ICON_COLUMN, status, STATUS_ICON_VISIBLE_COLUMN, TRUE, BUDDY_ICON_COLUMN, avatar ? avatar : gtkblist->empty_avatar, BUDDY_ICON_VISIBLE_COLUMN, showicons, EMBLEM_COLUMN, emblem, EMBLEM_VISIBLE_COLUMN, emblem != NULL, PROTOCOL_ICON_COLUMN, prpl_icon, PROTOCOL_ICON_VISIBLE_COLUMN, purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/blist/show_protocol_icons"), NAME_COLUMN, mark, BGCOLOR_COLUMN, bgcolor, GROUP_EXPANDER_VISIBLE_COLUMN, FALSE, -1); g_free(mark); if(emblem) g_object_unref(emblem); if(status) g_object_unref(status); if(avatar) g_object_unref(avatar); if(prpl_icon) g_object_unref(prpl_icon); } else { pidgin_blist_hide_node(list, node, TRUE); } } static void pidgin_blist_update(PurpleBuddyList *list, PurpleBlistNode *node) { if (list) gtkblist = PIDGIN_BLIST(list); if(!gtkblist || !gtkblist->treeview || !node) return; if (node->ui_data == NULL) pidgin_blist_new_node(node); switch(node->type) { case PURPLE_BLIST_GROUP_NODE: pidgin_blist_update_group(list, node); break; case PURPLE_BLIST_CONTACT_NODE: pidgin_blist_update_contact(list, node); break; case PURPLE_BLIST_BUDDY_NODE: pidgin_blist_update_buddy(list, node, TRUE); break; case PURPLE_BLIST_CHAT_NODE: pidgin_blist_update_chat(list, node); break; case PURPLE_BLIST_OTHER_NODE: return; } #if !GTK_CHECK_VERSION(2,6,0) gtk_tree_view_columns_autosize(GTK_TREE_VIEW(gtkblist->treeview)); #endif } static void pidgin_blist_destroy(PurpleBuddyList *list) { PidginBuddyListPrivate *priv; if (!gtkblist) return; purple_signals_disconnect_by_handle(gtkblist); if (gtkblist->headline_close) gdk_pixbuf_unref(gtkblist->headline_close); gtk_widget_destroy(gtkblist->window); pidgin_blist_tooltip_destroy(); if (gtkblist->refresh_timer) g_source_remove(gtkblist->refresh_timer); if (gtkblist->timeout) g_source_remove(gtkblist->timeout); if (gtkblist->drag_timeout) g_source_remove(gtkblist->drag_timeout); g_hash_table_destroy(gtkblist->connection_errors); gtkblist->refresh_timer = 0; gtkblist->timeout = 0; gtkblist->drag_timeout = 0; gtkblist->window = gtkblist->vbox = gtkblist->treeview = NULL; g_object_unref(G_OBJECT(gtkblist->treemodel)); gtkblist->treemodel = NULL; g_object_unref(G_OBJECT(gtkblist->ift)); g_object_unref(G_OBJECT(gtkblist->empty_avatar)); gdk_cursor_unref(gtkblist->hand_cursor); gdk_cursor_unref(gtkblist->arrow_cursor); gtkblist->hand_cursor = NULL; gtkblist->arrow_cursor = NULL; priv = PIDGIN_BUDDY_LIST_GET_PRIVATE(gtkblist); g_free(priv); g_free(gtkblist); accountmenu = NULL; gtkblist = NULL; purple_prefs_disconnect_by_handle(pidgin_blist_get_handle()); } static void pidgin_blist_set_visible(PurpleBuddyList *list, gboolean show) { if (!(gtkblist && gtkblist->window)) return; if (show) { if(!PIDGIN_WINDOW_ICONIFIED(gtkblist->window) && !GTK_WIDGET_VISIBLE(gtkblist->window)) purple_signal_emit(pidgin_blist_get_handle(), "gtkblist-unhiding", gtkblist); pidgin_blist_restore_position(); gtk_window_present(GTK_WINDOW(gtkblist->window)); } else { if(visibility_manager_count) { purple_signal_emit(pidgin_blist_get_handle(), "gtkblist-hiding", gtkblist); gtk_widget_hide(gtkblist->window); } else { if (!GTK_WIDGET_VISIBLE(gtkblist->window)) gtk_widget_show(gtkblist->window); gtk_window_iconify(GTK_WINDOW(gtkblist->window)); } } } static GList * groups_tree(void) { static GList *list = NULL; char *tmp2; PurpleGroup *g; PurpleBlistNode *gnode; g_list_free(list); list = NULL; if (purple_get_blist()->root == NULL) { list = g_list_append(list, (gpointer)_("Buddies")); } else { for (gnode = purple_get_blist()->root; gnode != NULL; gnode = gnode->next) { if (PURPLE_BLIST_NODE_IS_GROUP(gnode)) { g = (PurpleGroup *)gnode; tmp2 = g->name; list = g_list_append(list, tmp2); } } } return list; } static void add_buddy_select_account_cb(GObject *w, PurpleAccount *account, PidginAddBuddyData *data) { /* Save our account */ data->account = account; } static void destroy_add_buddy_dialog_cb(GtkWidget *win, PidginAddBuddyData *data) { g_free(data); } static void add_buddy_cb(GtkWidget *w, int resp, PidginAddBuddyData *data) { const char *grp, *who, *whoalias; PurpleGroup *g; PurpleBuddy *b; PurpleConversation *c; PurpleBuddyIcon *icon; if (resp == GTK_RESPONSE_OK) { who = gtk_entry_get_text(GTK_ENTRY(data->entry)); grp = pidgin_text_combo_box_entry_get_text(data->combo); whoalias = gtk_entry_get_text(GTK_ENTRY(data->entry_for_alias)); if (*whoalias == '\0') whoalias = NULL; g = NULL; if ((grp != NULL) && (*grp != '\0')) { if ((g = purple_find_group(grp)) == NULL) { g = purple_group_new(grp); purple_blist_add_group(g, NULL); } b = purple_find_buddy_in_group(data->account, who, g); } else if ((b = purple_find_buddy(data->account, who)) != NULL) { g = purple_buddy_get_group(b); } if (b == NULL) { b = purple_buddy_new(data->account, who, whoalias); purple_blist_add_buddy(b, NULL, g, NULL); } purple_account_add_buddy(data->account, b); /* Offer to merge people with the same alias. */ if (whoalias != NULL && g != NULL) gtk_blist_auto_personize((PurpleBlistNode *)g, whoalias); /* * XXX * It really seems like it would be better if the call to * purple_account_add_buddy() and purple_conversation_update() were done in * blist.c, possibly in the purple_blist_add_buddy() function. Maybe * purple_account_add_buddy() should be renamed to * purple_blist_add_new_buddy() or something, and have it call * purple_blist_add_buddy() after it creates it. --Mark * * No that's not good. blist.c should only deal with adding nodes to the * local list. We need a new, non-gtk file that calls both * purple_account_add_buddy and purple_blist_add_buddy(). * Or something. --Mark */ c = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, who, data->account); if (c != NULL) { icon = purple_conv_im_get_icon(PURPLE_CONV_IM(c)); if (icon != NULL) purple_buddy_icon_update(icon); } } gtk_widget_destroy(data->window); } static void pidgin_blist_request_add_buddy(PurpleAccount *account, const char *username, const char *group, const char *alias) { GtkWidget *table; GtkWidget *label; GtkWidget *hbox; GtkWidget *vbox; GtkWidget *img; PidginBuddyList *gtkblist; PidginAddBuddyData *data = g_new0(PidginAddBuddyData, 1); data->account = (account != NULL ? account : purple_connection_get_account(purple_connections_get_all()->data)); img = gtk_image_new_from_stock(PIDGIN_STOCK_DIALOG_QUESTION, gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_HUGE)); gtkblist = PIDGIN_BLIST(purple_get_blist()); data->window = gtk_dialog_new_with_buttons(_("Add Buddy"), gtkblist ? GTK_WINDOW(gtkblist->window) : NULL, GTK_DIALOG_NO_SEPARATOR, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_ADD, GTK_RESPONSE_OK, NULL); if (gtkblist) gtk_window_set_transient_for(GTK_WINDOW(data->window), GTK_WINDOW(gtkblist->window)); gtk_dialog_set_default_response(GTK_DIALOG(data->window), GTK_RESPONSE_OK); gtk_container_set_border_width(GTK_CONTAINER(data->window), PIDGIN_HIG_BOX_SPACE); gtk_window_set_resizable(GTK_WINDOW(data->window), FALSE); gtk_box_set_spacing(GTK_BOX(GTK_DIALOG(data->window)->vbox), PIDGIN_HIG_BORDER); gtk_container_set_border_width(GTK_CONTAINER(GTK_DIALOG(data->window)->vbox), PIDGIN_HIG_BOX_SPACE); gtk_window_set_role(GTK_WINDOW(data->window), "add_buddy"); gtk_window_set_type_hint(GTK_WINDOW(data->window), GDK_WINDOW_TYPE_HINT_DIALOG); hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BORDER); gtk_container_add(GTK_CONTAINER(GTK_DIALOG(data->window)->vbox), hbox); gtk_box_pack_start(GTK_BOX(hbox), img, FALSE, FALSE, 0); gtk_misc_set_alignment(GTK_MISC(img), 0, 0); vbox = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(hbox), vbox); g_signal_connect(G_OBJECT(data->window), "destroy", G_CALLBACK(destroy_add_buddy_dialog_cb), data); label = gtk_label_new(_("Add a buddy.\n")); gtk_misc_set_alignment(GTK_MISC(label), 0, 0); gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0); table = gtk_table_new(4, 2, FALSE); gtk_table_set_row_spacings(GTK_TABLE(table), 5); gtk_table_set_col_spacings(GTK_TABLE(table), 5); gtk_container_set_border_width(GTK_CONTAINER(table), 0); gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, FALSE, 0); data->account_box = pidgin_account_option_menu_new(account, FALSE, G_CALLBACK(add_buddy_select_account_cb), NULL, data); gtk_table_attach_defaults(GTK_TABLE(table), data->account_box, 0, 2, 0, 1); label = gtk_label_new_with_mnemonic(_("Buddy's _username:")); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 1, 2); data->entry = gtk_entry_new(); gtk_table_attach_defaults(GTK_TABLE(table), data->entry, 1, 2, 1, 2); gtk_widget_grab_focus(data->entry); if (username != NULL) gtk_entry_set_text(GTK_ENTRY(data->entry), username); else gtk_dialog_set_response_sensitive(GTK_DIALOG(data->window), GTK_RESPONSE_OK, FALSE); gtk_entry_set_activates_default (GTK_ENTRY(data->entry), TRUE); gtk_label_set_mnemonic_widget(GTK_LABEL(label), data->entry); pidgin_set_accessible_label (data->entry, label); g_signal_connect(G_OBJECT(data->entry), "changed", G_CALLBACK(pidgin_set_sensitive_if_input), data->window); label = gtk_label_new_with_mnemonic(_("(Optional) A_lias:")); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 2, 3); data->entry_for_alias = gtk_entry_new(); gtk_table_attach_defaults(GTK_TABLE(table), data->entry_for_alias, 1, 2, 2, 3); if (alias != NULL) gtk_entry_set_text(GTK_ENTRY(data->entry_for_alias), alias); if (username != NULL) gtk_widget_grab_focus(GTK_WIDGET(data->entry_for_alias)); gtk_entry_set_activates_default (GTK_ENTRY(data->entry_for_alias), TRUE); gtk_label_set_mnemonic_widget(GTK_LABEL(label), data->entry_for_alias); pidgin_set_accessible_label (data->entry_for_alias, label); label = gtk_label_new_with_mnemonic(_("Add buddy to _group:")); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 3, 4); data->combo = pidgin_text_combo_box_entry_new(group, groups_tree()); gtk_table_attach_defaults(GTK_TABLE(table), data->combo, 1, 2, 3, 4); gtk_label_set_mnemonic_widget(GTK_LABEL(label), GTK_BIN(data->combo)->child); pidgin_set_accessible_label (data->combo, label); g_signal_connect(G_OBJECT(data->window), "response", G_CALLBACK(add_buddy_cb), data); gtk_widget_show_all(data->window); } static void add_chat_cb(GtkWidget *w, PidginAddChatData *data) { GHashTable *components; GList *tmp; PurpleChat *chat; PurpleGroup *group; const char *group_name; const char *value; components = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free); for (tmp = data->entries; tmp; tmp = tmp->next) { if (g_object_get_data(tmp->data, "is_spin")) { g_hash_table_replace(components, g_strdup(g_object_get_data(tmp->data, "identifier")), g_strdup_printf("%d", gtk_spin_button_get_value_as_int(tmp->data))); } else { value = gtk_entry_get_text(tmp->data); if (*value != '\0') g_hash_table_replace(components, g_strdup(g_object_get_data(tmp->data, "identifier")), g_strdup(value)); } } chat = purple_chat_new(data->account, gtk_entry_get_text(GTK_ENTRY(data->alias_entry)), components); group_name = pidgin_text_combo_box_entry_get_text(data->group_combo); group = NULL; if ((group_name != NULL) && (*group_name != '\0') && ((group = purple_find_group(group_name)) == NULL)) { group = purple_group_new(group_name); purple_blist_add_group(group, NULL); } if (chat != NULL) { purple_blist_add_chat(chat, group, NULL); } if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data->autojoin))) purple_blist_node_set_bool((PurpleBlistNode*)chat, "gtk-autojoin", TRUE); if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data->persistent))) purple_blist_node_set_bool((PurpleBlistNode*)chat, "gtk-persistent", TRUE); gtk_widget_destroy(data->window); g_free(data->default_chat_name); g_list_free(data->entries); g_free(data); } static void add_chat_resp_cb(GtkWidget *w, int resp, PidginAddChatData *data) { if (resp == GTK_RESPONSE_OK) { add_chat_cb(NULL, data); } else if (resp == 1) { pidgin_roomlist_dialog_show_with_account(data->account); } else { gtk_widget_destroy(data->window); g_free(data->default_chat_name); g_list_free(data->entries); g_free(data); } } /* * Check the values of all the text entry boxes. If any required input * strings are empty then don't allow the user to click on "OK." */ static void addchat_set_sensitive_if_input_cb(GtkWidget *entry, gpointer user_data) { PurplePluginProtocolInfo *prpl_info; PurpleConnection *gc; PidginAddChatData *data; GList *tmp; const char *text; gboolean required; gboolean sensitive = TRUE; data = user_data; for (tmp = data->entries; tmp != NULL; tmp = tmp->next) { if (!g_object_get_data(tmp->data, "is_spin")) { required = GPOINTER_TO_INT(g_object_get_data(tmp->data, "required")); text = gtk_entry_get_text(tmp->data); if (required && (*text == '\0')) sensitive = FALSE; } } gtk_dialog_set_response_sensitive(GTK_DIALOG(data->window), GTK_RESPONSE_OK, sensitive); gc = purple_account_get_connection(data->account); prpl_info = (gc != NULL) ? PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl) : NULL; sensitive = (prpl_info != NULL && prpl_info->roomlist_get_list != NULL); gtk_dialog_set_response_sensitive(GTK_DIALOG(data->window), 1, sensitive); } static void rebuild_addchat_entries(PidginAddChatData *data) { PurpleConnection *gc; GList *list = NULL, *tmp; GHashTable *defaults = NULL; struct proto_chat_entry *pce; gboolean focus = TRUE; g_return_if_fail(data->account != NULL); gc = purple_account_get_connection(data->account); gtk_container_foreach(GTK_CONTAINER(data->entries_box), (GtkCallback)gtk_widget_destroy, NULL); g_list_free(data->entries); data->entries = NULL; if (PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl)->chat_info != NULL) list = PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl)->chat_info(gc); if (PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl)->chat_info_defaults != NULL) defaults = PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl)->chat_info_defaults(gc, data->default_chat_name); for (tmp = list; tmp; tmp = tmp->next) { GtkWidget *input; pce = tmp->data; if (pce->is_int) { GtkObject *adjust; adjust = gtk_adjustment_new(pce->min, pce->min, pce->max, 1, 10, 10); input = gtk_spin_button_new(GTK_ADJUSTMENT(adjust), 1, 0); gtk_widget_set_size_request(input, 50, -1); pidgin_add_widget_to_vbox(GTK_BOX(data->entries_box), pce->label, data->sg, input, FALSE, NULL); } else { char *value; input = gtk_entry_new(); gtk_entry_set_activates_default(GTK_ENTRY(input), TRUE); value = g_hash_table_lookup(defaults, pce->identifier); if (value != NULL) gtk_entry_set_text(GTK_ENTRY(input), value); if (pce->secret) { gtk_entry_set_visibility(GTK_ENTRY(input), FALSE); #if !GTK_CHECK_VERSION(2,16,0) if (gtk_entry_get_invisible_char(GTK_ENTRY(input)) == '*') gtk_entry_set_invisible_char(GTK_ENTRY(input), PIDGIN_INVISIBLE_CHAR); #endif /* Less than GTK+ 2.16 */ } pidgin_add_widget_to_vbox(GTK_BOX(data->entries_box), pce->label, data->sg, input, TRUE, NULL); g_signal_connect(G_OBJECT(input), "changed", G_CALLBACK(addchat_set_sensitive_if_input_cb), data); } /* Do the following for any type of input widget */ if (focus) { gtk_widget_grab_focus(input); focus = FALSE; } g_object_set_data(G_OBJECT(input), "identifier", (gpointer)pce->identifier); g_object_set_data(G_OBJECT(input), "is_spin", GINT_TO_POINTER(pce->is_int)); g_object_set_data(G_OBJECT(input), "required", GINT_TO_POINTER(pce->required)); data->entries = g_list_append(data->entries, input); g_free(pce); } g_list_free(list); g_hash_table_destroy(defaults); /* Set whether the "OK" button should be clickable initially */ addchat_set_sensitive_if_input_cb(NULL, data); gtk_widget_show_all(data->entries_box); } static void addchat_select_account_cb(GObject *w, PurpleAccount *account, PidginAddChatData *data) { if (strcmp(purple_account_get_protocol_id(data->account), purple_account_get_protocol_id(account)) == 0) { data->account = account; } else { data->account = account; rebuild_addchat_entries(data); } } static void pidgin_blist_request_add_chat(PurpleAccount *account, PurpleGroup *group, const char *alias, const char *name) { PidginAddChatData *data; PidginBuddyList *gtkblist; GList *l; PurpleConnection *gc; GtkWidget *label; GtkWidget *hbox; GtkWidget *vbox; GtkWidget *img; if (account != NULL) { gc = purple_account_get_connection(account); if (PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl)->join_chat == NULL) { purple_notify_error(gc, NULL, _("This protocol does not support chat rooms."), NULL); return; } } else { /* Find an account with chat capabilities */ for (l = purple_connections_get_all(); l != NULL; l = l->next) { gc = (PurpleConnection *)l->data; if (PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl)->join_chat != NULL) { account = purple_connection_get_account(gc); break; } } if (account == NULL) { purple_notify_error(NULL, NULL, _("You are not currently signed on with any " "protocols that have the ability to chat."), NULL); return; } } data = g_new0(PidginAddChatData, 1); data->account = account; data->default_chat_name = g_strdup(name); img = gtk_image_new_from_stock(PIDGIN_STOCK_DIALOG_QUESTION, gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_HUGE)); gtkblist = PIDGIN_BLIST(purple_get_blist()); data->sg = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL); data->window = gtk_dialog_new_with_buttons(_("Add Chat"), gtkblist ? GTK_WINDOW(gtkblist->window) : NULL, GTK_DIALOG_NO_SEPARATOR, _("Room _List"), 1, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_ADD, GTK_RESPONSE_OK, NULL); if (gtkblist) gtk_window_set_transient_for(GTK_WINDOW(data->window), GTK_WINDOW(gtkblist->window)); gtk_dialog_set_default_response(GTK_DIALOG(data->window), GTK_RESPONSE_OK); gtk_container_set_border_width(GTK_CONTAINER(data->window), PIDGIN_HIG_BOX_SPACE); gtk_window_set_resizable(GTK_WINDOW(data->window), FALSE); gtk_box_set_spacing(GTK_BOX(GTK_DIALOG(data->window)->vbox), PIDGIN_HIG_BORDER); gtk_container_set_border_width(GTK_CONTAINER(GTK_DIALOG(data->window)->vbox), PIDGIN_HIG_BOX_SPACE); gtk_window_set_role(GTK_WINDOW(data->window), "add_chat"); gtk_window_set_type_hint(GTK_WINDOW(data->window), GDK_WINDOW_TYPE_HINT_DIALOG); hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BORDER); gtk_container_add(GTK_CONTAINER(GTK_DIALOG(data->window)->vbox), hbox); gtk_box_pack_start(GTK_BOX(hbox), img, FALSE, FALSE, 0); gtk_misc_set_alignment(GTK_MISC(img), 0, 0); vbox = gtk_vbox_new(FALSE, 5); gtk_container_add(GTK_CONTAINER(hbox), vbox); label = gtk_label_new( _("Please enter an alias, and the appropriate information " "about the chat you would like to add to your buddy list.\n")); gtk_widget_set_size_request(label, 400, -1); gtk_label_set_line_wrap(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0); gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0); data->account_menu = pidgin_account_option_menu_new(account, FALSE, G_CALLBACK(addchat_select_account_cb), chat_account_filter_func, data); pidgin_add_widget_to_vbox(GTK_BOX(vbox), _("_Account:"), data->sg, data->account_menu, TRUE, NULL); data->entries_box = gtk_vbox_new(FALSE, 5); gtk_container_set_border_width(GTK_CONTAINER(data->entries_box), 0); gtk_box_pack_start(GTK_BOX(vbox), data->entries_box, TRUE, TRUE, 0); rebuild_addchat_entries(data); data->alias_entry = gtk_entry_new(); if (alias != NULL) gtk_entry_set_text(GTK_ENTRY(data->alias_entry), alias); gtk_entry_set_activates_default(GTK_ENTRY(data->alias_entry), TRUE); pidgin_add_widget_to_vbox(GTK_BOX(vbox), _("A_lias:"), data->sg, data->alias_entry, TRUE, NULL); if (name != NULL) gtk_widget_grab_focus(data->alias_entry); data->group_combo = pidgin_text_combo_box_entry_new(group ? group->name : NULL, groups_tree()); pidgin_add_widget_to_vbox(GTK_BOX(vbox), _("_Group:"), data->sg, data->group_combo, TRUE, NULL); data->autojoin = gtk_check_button_new_with_mnemonic(_("Auto_join when account becomes online.")); data->persistent = gtk_check_button_new_with_mnemonic(_("_Remain in chat after window is closed.")); gtk_box_pack_start(GTK_BOX(vbox), data->autojoin, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), data->persistent, FALSE, FALSE, 0); g_signal_connect(G_OBJECT(data->window), "response", G_CALLBACK(add_chat_resp_cb), data); gtk_widget_show_all(data->window); } static void add_group_cb(PurpleConnection *gc, const char *group_name) { PurpleGroup *group; if ((group_name == NULL) || (*group_name == '\0')) return; group = purple_group_new(group_name); purple_blist_add_group(group, NULL); } static void pidgin_blist_request_add_group(void) { purple_request_input(NULL, _("Add Group"), NULL, _("Please enter the name of the group to be added."), NULL, FALSE, FALSE, NULL, _("Add"), G_CALLBACK(add_group_cb), _("Cancel"), NULL, NULL, NULL, NULL, NULL); } void pidgin_blist_toggle_visibility() { if (gtkblist && gtkblist->window) { if (GTK_WIDGET_VISIBLE(gtkblist->window)) { /* make the buddy list visible if it is iconified or if it is * obscured and not currently focused (the focus part ensures * that we do something reasonable if the buddy list is obscured * by a window set to always be on top), otherwise hide the * buddy list */ purple_blist_set_visible(PIDGIN_WINDOW_ICONIFIED(gtkblist->window) || ((gtk_blist_visibility != GDK_VISIBILITY_UNOBSCURED) && !gtk_blist_focused)); } else { purple_blist_set_visible(TRUE); } } } void pidgin_blist_visibility_manager_add() { visibility_manager_count++; purple_debug_info("gtkblist", "added visibility manager: %d\n", visibility_manager_count); } void pidgin_blist_visibility_manager_remove() { if (visibility_manager_count) visibility_manager_count--; if (!visibility_manager_count) purple_blist_set_visible(TRUE); purple_debug_info("gtkblist", "removed visibility manager: %d\n", visibility_manager_count); } void pidgin_blist_add_alert(GtkWidget *widget) { gtk_container_add(GTK_CONTAINER(gtkblist->scrollbook), widget); set_urgent(); } void pidgin_blist_set_headline(const char *text, GdkPixbuf *pixbuf, GCallback callback, gpointer user_data, GDestroyNotify destroy) { /* Destroy any existing headline first */ if (gtkblist->headline_destroy) gtkblist->headline_destroy(gtkblist->headline_data); gtk_label_set_markup(GTK_LABEL(gtkblist->headline_label), text); gtk_image_set_from_pixbuf(GTK_IMAGE(gtkblist->headline_image), pixbuf); gtkblist->headline_callback = callback; gtkblist->headline_data = user_data; gtkblist->headline_destroy = destroy; if (text != NULL || pixbuf != NULL) { set_urgent(); gtk_widget_show_all(gtkblist->headline_hbox); } else { gtk_widget_hide(gtkblist->headline_hbox); } } static void set_urgent(void) { if (!GTK_WIDGET_HAS_FOCUS(gtkblist->window)) pidgin_set_urgent(GTK_WINDOW(gtkblist->window), TRUE); } static PurpleBlistUiOps blist_ui_ops = { pidgin_blist_new_list, pidgin_blist_new_node, pidgin_blist_show, pidgin_blist_update, pidgin_blist_remove, pidgin_blist_destroy, pidgin_blist_set_visible, pidgin_blist_request_add_buddy, pidgin_blist_request_add_chat, pidgin_blist_request_add_group, NULL, NULL, NULL, NULL }; PurpleBlistUiOps * pidgin_blist_get_ui_ops(void) { return &blist_ui_ops; } PidginBuddyList *pidgin_blist_get_default_gtk_blist() { return gtkblist; } static void account_signon_cb(PurpleConnection *gc, gpointer z) { PurpleAccount *account = purple_connection_get_account(gc); PurpleBlistNode *gnode, *cnode; 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) { PurpleChat *chat; if(!PURPLE_BLIST_NODE_IS_CHAT(cnode)) continue; chat = (PurpleChat *)cnode; if(chat->account != account) continue; if(purple_blist_node_get_bool((PurpleBlistNode*)chat, "gtk-autojoin") || (purple_blist_node_get_string((PurpleBlistNode*)chat, "gtk-autojoin") != NULL)) serv_join_chat(gc, chat->components); } } } void * pidgin_blist_get_handle() { static int handle; return &handle; } static gboolean buddy_signonoff_timeout_cb(PurpleBuddy *buddy) { struct _pidgin_blist_node *gtknode = ((PurpleBlistNode*)buddy)->ui_data; gtknode->recent_signonoff = FALSE; gtknode->recent_signonoff_timer = 0; pidgin_blist_update(NULL, (PurpleBlistNode*)buddy); return FALSE; } static void buddy_signonoff_cb(PurpleBuddy *buddy) { struct _pidgin_blist_node *gtknode; if(!((PurpleBlistNode*)buddy)->ui_data) { pidgin_blist_new_node((PurpleBlistNode*)buddy); } gtknode = ((PurpleBlistNode*)buddy)->ui_data; gtknode->recent_signonoff = TRUE; if(gtknode->recent_signonoff_timer > 0) purple_timeout_remove(gtknode->recent_signonoff_timer); gtknode->recent_signonoff_timer = purple_timeout_add(10000, (GSourceFunc)buddy_signonoff_timeout_cb, buddy); } void pidgin_blist_set_theme(PidginBlistTheme *theme) { PidginBuddyListPrivate *priv = PIDGIN_BUDDY_LIST_GET_PRIVATE(gtkblist); PurpleBuddyList *list = purple_get_blist(); if (theme != NULL) purple_prefs_set_string(PIDGIN_PREFS_ROOT "/blist/theme", purple_theme_get_name(PURPLE_THEME(theme))); else purple_prefs_set_string(PIDGIN_PREFS_ROOT "/blist/theme", ""); priv->current_theme = theme; pidgin_blist_build_layout(list); pidgin_blist_refresh(list); } PidginBlistTheme * pidgin_blist_get_theme() { PidginBuddyListPrivate *priv = PIDGIN_BUDDY_LIST_GET_PRIVATE(gtkblist); return priv->current_theme; } void pidgin_blist_init(void) { void *gtk_blist_handle = pidgin_blist_get_handle(); cached_emblems = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL); purple_signal_connect(purple_connections_get_handle(), "signed-on", gtk_blist_handle, PURPLE_CALLBACK(account_signon_cb), NULL); /* Initialize prefs */ purple_prefs_add_none(PIDGIN_PREFS_ROOT "/blist"); purple_prefs_add_bool(PIDGIN_PREFS_ROOT "/blist/show_buddy_icons", TRUE); purple_prefs_add_bool(PIDGIN_PREFS_ROOT "/blist/show_empty_groups", FALSE); purple_prefs_add_bool(PIDGIN_PREFS_ROOT "/blist/show_idle_time", TRUE); purple_prefs_add_bool(PIDGIN_PREFS_ROOT "/blist/show_offline_buddies", FALSE); purple_prefs_add_bool(PIDGIN_PREFS_ROOT "/blist/show_protocol_icons", FALSE); purple_prefs_add_bool(PIDGIN_PREFS_ROOT "/blist/list_visible", FALSE); purple_prefs_add_bool(PIDGIN_PREFS_ROOT "/blist/list_maximized", FALSE); purple_prefs_add_string(PIDGIN_PREFS_ROOT "/blist/sort_type", "alphabetical"); purple_prefs_add_int(PIDGIN_PREFS_ROOT "/blist/x", 0); purple_prefs_add_int(PIDGIN_PREFS_ROOT "/blist/y", 0); purple_prefs_add_int(PIDGIN_PREFS_ROOT "/blist/width", 250); /* Golden ratio, baby */ purple_prefs_add_int(PIDGIN_PREFS_ROOT "/blist/height", 405); /* Golden ratio, baby */ #if !GTK_CHECK_VERSION(2,14,0) /* This pref is used in pidgintooltip.c. */ purple_prefs_add_int(PIDGIN_PREFS_ROOT "/blist/tooltip_delay", 500); #endif purple_prefs_add_string(PIDGIN_PREFS_ROOT "/blist/theme", ""); purple_theme_manager_register_type(g_object_new(PIDGIN_TYPE_BLIST_THEME_LOADER, "type", "blist", NULL)); /* Register our signals */ purple_signal_register(gtk_blist_handle, "gtkblist-hiding", purple_marshal_VOID__POINTER, NULL, 1, purple_value_new(PURPLE_TYPE_SUBTYPE, PURPLE_SUBTYPE_BLIST)); purple_signal_register(gtk_blist_handle, "gtkblist-unhiding", purple_marshal_VOID__POINTER, NULL, 1, purple_value_new(PURPLE_TYPE_SUBTYPE, PURPLE_SUBTYPE_BLIST)); purple_signal_register(gtk_blist_handle, "gtkblist-created", purple_marshal_VOID__POINTER, NULL, 1, purple_value_new(PURPLE_TYPE_SUBTYPE, PURPLE_SUBTYPE_BLIST)); purple_signal_register(gtk_blist_handle, "drawing-tooltip", purple_marshal_VOID__POINTER_POINTER_UINT, NULL, 3, purple_value_new(PURPLE_TYPE_SUBTYPE, PURPLE_SUBTYPE_BLIST_NODE), purple_value_new_outgoing(PURPLE_TYPE_BOXED, "GString *"), purple_value_new(PURPLE_TYPE_BOOLEAN)); purple_signal_connect(purple_blist_get_handle(), "buddy-signed-on", gtk_blist_handle, PURPLE_CALLBACK(buddy_signonoff_cb), NULL); purple_signal_connect(purple_blist_get_handle(), "buddy-signed-off", gtk_blist_handle, PURPLE_CALLBACK(buddy_signonoff_cb), NULL); purple_signal_connect(purple_blist_get_handle(), "buddy-privacy-changed", gtk_blist_handle, PURPLE_CALLBACK(pidgin_blist_update_privacy_cb), NULL); } void pidgin_blist_uninit(void) { g_hash_table_destroy(cached_emblems); purple_signals_unregister_by_instance(pidgin_blist_get_handle()); purple_signals_disconnect_by_handle(pidgin_blist_get_handle()); } /********************************************************************* * Buddy List sorting functions * *********************************************************************/ GList *pidgin_blist_get_sort_methods() { return pidgin_blist_sort_methods; } void pidgin_blist_sort_method_reg(const char *id, const char *name, pidgin_blist_sort_function func) { struct pidgin_blist_sort_method *method = g_new0(struct pidgin_blist_sort_method, 1); method->id = g_strdup(id); method->name = g_strdup(name); method->func = func; pidgin_blist_sort_methods = g_list_append(pidgin_blist_sort_methods, method); pidgin_blist_update_sort_methods(); } void pidgin_blist_sort_method_unreg(const char *id) { GList *l = pidgin_blist_sort_methods; while(l) { struct pidgin_blist_sort_method *method = l->data; if(!strcmp(method->id, id)) { pidgin_blist_sort_methods = g_list_delete_link(pidgin_blist_sort_methods, l); g_free(method->id); g_free(method->name); g_free(method); break; } l = l->next; } pidgin_blist_update_sort_methods(); } void pidgin_blist_sort_method_set(const char *id){ GList *l = pidgin_blist_sort_methods; if(!id) id = "none"; while (l && strcmp(((struct pidgin_blist_sort_method*)l->data)->id, id)) l = l->next; if (l) { current_sort_method = l->data; } else if (!current_sort_method) { pidgin_blist_sort_method_set("none"); return; } if (!strcmp(id, "none")) { redo_buddy_list(purple_get_blist(), TRUE, FALSE); } else { redo_buddy_list(purple_get_blist(), FALSE, FALSE); } } /****************************************** ** Sort Methods ******************************************/ static void sort_method_none(PurpleBlistNode *node, PurpleBuddyList *blist, GtkTreeIter parent_iter, GtkTreeIter *cur, GtkTreeIter *iter) { PurpleBlistNode *sibling = node->prev; GtkTreeIter sibling_iter; if (cur != NULL) { *iter = *cur; return; } while (sibling && !get_iter_from_node(sibling, &sibling_iter)) { sibling = sibling->prev; } gtk_tree_store_insert_after(gtkblist->treemodel, iter, node->parent ? &parent_iter : NULL, sibling ? &sibling_iter : NULL); } #if GTK_CHECK_VERSION(2,2,1) static void sort_method_alphabetical(PurpleBlistNode *node, PurpleBuddyList *blist, GtkTreeIter groupiter, GtkTreeIter *cur, GtkTreeIter *iter) { GtkTreeIter more_z; const char *my_name; if(PURPLE_BLIST_NODE_IS_CONTACT(node)) { my_name = purple_contact_get_alias((PurpleContact*)node); } else if(PURPLE_BLIST_NODE_IS_CHAT(node)) { my_name = purple_chat_get_name((PurpleChat*)node); } else { sort_method_none(node, blist, groupiter, cur, iter); return; } if (!gtk_tree_model_iter_children(GTK_TREE_MODEL(gtkblist->treemodel), &more_z, &groupiter)) { gtk_tree_store_insert(gtkblist->treemodel, iter, &groupiter, 0); return; } do { GValue val; PurpleBlistNode *n; const char *this_name; int cmp; val.g_type = 0; gtk_tree_model_get_value (GTK_TREE_MODEL(gtkblist->treemodel), &more_z, NODE_COLUMN, &val); n = g_value_get_pointer(&val); if(PURPLE_BLIST_NODE_IS_CONTACT(n)) { this_name = purple_contact_get_alias((PurpleContact*)n); } else if(PURPLE_BLIST_NODE_IS_CHAT(n)) { this_name = purple_chat_get_name((PurpleChat*)n); } else { this_name = NULL; } cmp = purple_utf8_strcasecmp(my_name, this_name); if(this_name && (cmp < 0 || (cmp == 0 && node < n))) { if(cur) { gtk_tree_store_move_before(gtkblist->treemodel, cur, &more_z); *iter = *cur; return; } else { gtk_tree_store_insert_before(gtkblist->treemodel, iter, &groupiter, &more_z); return; } } g_value_unset(&val); } while (gtk_tree_model_iter_next (GTK_TREE_MODEL(gtkblist->treemodel), &more_z)); if(cur) { gtk_tree_store_move_before(gtkblist->treemodel, cur, NULL); *iter = *cur; return; } else { gtk_tree_store_append(gtkblist->treemodel, iter, &groupiter); return; } } static void sort_method_status(PurpleBlistNode *node, PurpleBuddyList *blist, GtkTreeIter groupiter, GtkTreeIter *cur, GtkTreeIter *iter) { GtkTreeIter more_z; PurpleBuddy *my_buddy, *this_buddy; if(PURPLE_BLIST_NODE_IS_CONTACT(node)) { my_buddy = purple_contact_get_priority_buddy((PurpleContact*)node); } else if(PURPLE_BLIST_NODE_IS_CHAT(node)) { if (cur != NULL) { *iter = *cur; return; } gtk_tree_store_append(gtkblist->treemodel, iter, &groupiter); return; } else { sort_method_none(node, blist, groupiter, cur, iter); return; } if (!gtk_tree_model_iter_children(GTK_TREE_MODEL(gtkblist->treemodel), &more_z, &groupiter)) { gtk_tree_store_insert(gtkblist->treemodel, iter, &groupiter, 0); return; } do { GValue val; PurpleBlistNode *n; gint name_cmp; gint presence_cmp; val.g_type = 0; gtk_tree_model_get_value (GTK_TREE_MODEL(gtkblist->treemodel), &more_z, NODE_COLUMN, &val); n = g_value_get_pointer(&val); if(PURPLE_BLIST_NODE_IS_CONTACT(n)) { this_buddy = purple_contact_get_priority_buddy((PurpleContact*)n); } else { this_buddy = NULL; } name_cmp = purple_utf8_strcasecmp( purple_contact_get_alias(purple_buddy_get_contact(my_buddy)), (this_buddy ? purple_contact_get_alias(purple_buddy_get_contact(this_buddy)) : NULL)); presence_cmp = purple_presence_compare( purple_buddy_get_presence(my_buddy), this_buddy ? purple_buddy_get_presence(this_buddy) : NULL); if (this_buddy == NULL || (presence_cmp < 0 || (presence_cmp == 0 && (name_cmp < 0 || (name_cmp == 0 && node < n))))) { if (cur != NULL) { gtk_tree_store_move_before(gtkblist->treemodel, cur, &more_z); *iter = *cur; return; } else { gtk_tree_store_insert_before(gtkblist->treemodel, iter, &groupiter, &more_z); return; } } g_value_unset(&val); } while (gtk_tree_model_iter_next(GTK_TREE_MODEL(gtkblist->treemodel), &more_z)); if (cur) { gtk_tree_store_move_before(gtkblist->treemodel, cur, NULL); *iter = *cur; return; } else { gtk_tree_store_append(gtkblist->treemodel, iter, &groupiter); return; } } static void sort_method_log_activity(PurpleBlistNode *node, PurpleBuddyList *blist, GtkTreeIter groupiter, GtkTreeIter *cur, GtkTreeIter *iter) { GtkTreeIter more_z; int activity_score = 0, this_log_activity_score = 0; const char *buddy_name, *this_buddy_name; if(cur && (gtk_tree_model_iter_n_children(GTK_TREE_MODEL(gtkblist->treemodel), &groupiter) == 1)) { *iter = *cur; return; } if(PURPLE_BLIST_NODE_IS_CONTACT(node)) { PurpleBlistNode *n; PurpleBuddy *buddy; for (n = node->child; n; n = n->next) { buddy = (PurpleBuddy*)n; activity_score += purple_log_get_activity_score(PURPLE_LOG_IM, buddy->name, buddy->account); } buddy_name = purple_contact_get_alias((PurpleContact*)node); } else if(PURPLE_BLIST_NODE_IS_CHAT(node)) { /* we don't have a reliable way of getting the log filename * from the chat info in the blist, yet */ if (cur != NULL) { *iter = *cur; return; } gtk_tree_store_append(gtkblist->treemodel, iter, &groupiter); return; } else { sort_method_none(node, blist, groupiter, cur, iter); return; } if (!gtk_tree_model_iter_children(GTK_TREE_MODEL(gtkblist->treemodel), &more_z, &groupiter)) { gtk_tree_store_insert(gtkblist->treemodel, iter, &groupiter, 0); return; } do { GValue val; PurpleBlistNode *n; PurpleBlistNode *n2; PurpleBuddy *buddy; int cmp; val.g_type = 0; gtk_tree_model_get_value (GTK_TREE_MODEL(gtkblist->treemodel), &more_z, NODE_COLUMN, &val); n = g_value_get_pointer(&val); this_log_activity_score = 0; if(PURPLE_BLIST_NODE_IS_CONTACT(n)) { for (n2 = n->child; n2; n2 = n2->next) { buddy = (PurpleBuddy*)n2; this_log_activity_score += purple_log_get_activity_score(PURPLE_LOG_IM, buddy->name, buddy->account); } this_buddy_name = purple_contact_get_alias((PurpleContact*)n); } else { this_buddy_name = NULL; } cmp = purple_utf8_strcasecmp(buddy_name, this_buddy_name); if (!PURPLE_BLIST_NODE_IS_CONTACT(n) || activity_score > this_log_activity_score || ((activity_score == this_log_activity_score) && (cmp < 0 || (cmp == 0 && node < n)))) { if (cur != NULL) { gtk_tree_store_move_before(gtkblist->treemodel, cur, &more_z); *iter = *cur; return; } else { gtk_tree_store_insert_before(gtkblist->treemodel, iter, &groupiter, &more_z); return; } } g_value_unset(&val); } while (gtk_tree_model_iter_next (GTK_TREE_MODEL(gtkblist->treemodel), &more_z)); if (cur != NULL) { gtk_tree_store_move_before(gtkblist->treemodel, cur, NULL); *iter = *cur; return; } else { gtk_tree_store_append(gtkblist->treemodel, iter, &groupiter); return; } } #endif static void plugin_act(GtkObject *obj, PurplePluginAction *pam) { if (pam && pam->callback) pam->callback(pam); } static void build_plugin_actions(GtkWidget *menu, PurplePlugin *plugin, gpointer context) { GtkWidget *menuitem; PurplePluginAction *action = NULL; GList *actions, *l; actions = PURPLE_PLUGIN_ACTIONS(plugin, context); for (l = actions; l != NULL; l = l->next) { if (l->data) { action = (PurplePluginAction *) l->data; action->plugin = plugin; action->context = context; menuitem = gtk_menu_item_new_with_label(action->label); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem); g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(plugin_act), action); g_object_set_data_full(G_OBJECT(menuitem), "plugin_action", action, (GDestroyNotify)purple_plugin_action_free); gtk_widget_show(menuitem); } else pidgin_separator(menu); } g_list_free(actions); } static void modify_account_cb(GtkWidget *widget, gpointer data) { pidgin_account_dialog_show(PIDGIN_MODIFY_ACCOUNT_DIALOG, data); } static void enable_account_cb(GtkCheckMenuItem *widget, gpointer data) { PurpleAccount *account = data; const PurpleSavedStatus *saved_status; saved_status = purple_savedstatus_get_current(); purple_savedstatus_activate_for_account(saved_status, account); purple_account_set_enabled(account, PIDGIN_UI, TRUE); } static void disable_account_cb(GtkCheckMenuItem *widget, gpointer data) { PurpleAccount *account = data; purple_account_set_enabled(account, PIDGIN_UI, FALSE); } void pidgin_blist_update_accounts_menu(void) { GtkWidget *menuitem = NULL, *submenu = NULL; GtkAccelGroup *accel_group = NULL; GList *l = NULL, *accounts = NULL; gboolean disabled_accounts = FALSE; gboolean enabled_accounts = FALSE; if (accountmenu == NULL) return; /* Clear the old Accounts menu */ for (l = gtk_container_get_children(GTK_CONTAINER(accountmenu)); l; l = g_list_delete_link(l, l)) { menuitem = l->data; if (menuitem != gtk_item_factory_get_widget(gtkblist->ift, N_("/Accounts/Manage Accounts"))) gtk_widget_destroy(menuitem); } for (accounts = purple_accounts_get_all(); accounts; accounts = accounts->next) { char *buf = NULL; GtkWidget *image = NULL; PurpleAccount *account = NULL; GdkPixbuf *pixbuf = NULL; account = accounts->data; if(!purple_account_get_enabled(account, PIDGIN_UI)) { if (!disabled_accounts) { menuitem = gtk_menu_item_new_with_label(_("Enable Account")); gtk_menu_shell_append(GTK_MENU_SHELL(accountmenu), menuitem); submenu = gtk_menu_new(); gtk_menu_set_accel_group(GTK_MENU(submenu), accel_group); gtk_menu_set_accel_path(GTK_MENU(submenu), N_("<PurpleMain>/Accounts/Enable Account")); gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), submenu); disabled_accounts = TRUE; } buf = g_strconcat(purple_account_get_username(account), " (", purple_account_get_protocol_name(account), ")", NULL); menuitem = gtk_image_menu_item_new_with_label(buf); g_free(buf); pixbuf = pidgin_create_prpl_icon(account, PIDGIN_PRPL_ICON_SMALL); if (pixbuf != NULL) { if (!purple_account_is_connected(account)) gdk_pixbuf_saturate_and_pixelate(pixbuf, pixbuf, 0.0, FALSE); image = gtk_image_new_from_pixbuf(pixbuf); g_object_unref(G_OBJECT(pixbuf)); gtk_widget_show(image); gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menuitem), image); } g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(enable_account_cb), account); gtk_menu_shell_append(GTK_MENU_SHELL(submenu), menuitem); } else { enabled_accounts = TRUE; } } if (!enabled_accounts) return; pidgin_separator(accountmenu); accel_group = gtk_menu_get_accel_group(GTK_MENU(accountmenu)); for (accounts = purple_accounts_get_all(); accounts; accounts = accounts->next) { char *buf = NULL; char *accel_path_buf = NULL; GtkWidget *image = NULL; PurpleConnection *gc = NULL; PurpleAccount *account = NULL; GdkPixbuf *pixbuf = NULL; PurplePlugin *plugin = NULL; account = accounts->data; if (!purple_account_get_enabled(account, PIDGIN_UI)) continue; buf = g_strconcat(purple_account_get_username(account), " (", purple_account_get_protocol_name(account), ")", NULL); menuitem = gtk_image_menu_item_new_with_label(buf); accel_path_buf = g_strconcat(N_("<PurpleMain>/Accounts/"), buf, NULL); g_free(buf); pixbuf = pidgin_create_prpl_icon(account, PIDGIN_PRPL_ICON_SMALL); if (pixbuf != NULL) { if (!purple_account_is_connected(account)) gdk_pixbuf_saturate_and_pixelate(pixbuf, pixbuf, 0.0, FALSE); image = gtk_image_new_from_pixbuf(pixbuf); g_object_unref(G_OBJECT(pixbuf)); gtk_widget_show(image); gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menuitem), image); } gtk_menu_shell_append(GTK_MENU_SHELL(accountmenu), menuitem); submenu = gtk_menu_new(); gtk_menu_set_accel_group(GTK_MENU(submenu), accel_group); gtk_menu_set_accel_path(GTK_MENU(submenu), accel_path_buf); g_free(accel_path_buf); gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), submenu); menuitem = gtk_menu_item_new_with_mnemonic(_("_Edit Account")); g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(modify_account_cb), account); gtk_menu_shell_append(GTK_MENU_SHELL(submenu), menuitem); pidgin_separator(submenu); gc = purple_account_get_connection(account); plugin = gc && PURPLE_CONNECTION_IS_CONNECTED(gc) ? gc->prpl : NULL; if (plugin && PURPLE_PLUGIN_HAS_ACTIONS(plugin)) { build_plugin_actions(submenu, plugin, gc); } else { menuitem = gtk_menu_item_new_with_label(_("No actions available")); gtk_menu_shell_append(GTK_MENU_SHELL(submenu), menuitem); gtk_widget_set_sensitive(menuitem, FALSE); } pidgin_separator(submenu); menuitem = gtk_menu_item_new_with_mnemonic(_("_Disable")); g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(disable_account_cb), account); gtk_menu_shell_append(GTK_MENU_SHELL(submenu), menuitem); } gtk_widget_show_all(accountmenu); } static GList *plugin_submenus = NULL; void pidgin_blist_update_plugin_actions(void) { GtkWidget *menuitem, *submenu; PurplePlugin *plugin = NULL; GList *l; GtkAccelGroup *accel_group; GtkWidget *pluginmenu = gtk_item_factory_get_widget(gtkblist->ift, N_("/Tools")); g_return_if_fail(pluginmenu != NULL); /* Remove old plugin action submenus from the Tools menu */ for (l = plugin_submenus; l; l = l->next) gtk_widget_destroy(GTK_WIDGET(l->data)); g_list_free(plugin_submenus); plugin_submenus = NULL; accel_group = gtk_menu_get_accel_group(GTK_MENU(pluginmenu)); /* Add a submenu for each plugin with custom actions */ for (l = purple_plugins_get_loaded(); l; l = l->next) { char *path; plugin = (PurplePlugin *) l->data; if (PURPLE_IS_PROTOCOL_PLUGIN(plugin)) continue; if (!PURPLE_PLUGIN_HAS_ACTIONS(plugin)) continue; menuitem = gtk_image_menu_item_new_with_label(_(plugin->info->name)); gtk_menu_shell_append(GTK_MENU_SHELL(pluginmenu), menuitem); plugin_submenus = g_list_append(plugin_submenus, menuitem); submenu = gtk_menu_new(); gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), submenu); gtk_menu_set_accel_group(GTK_MENU(submenu), accel_group); path = g_strdup_printf("%s/Tools/%s", gtkblist->ift->path, plugin->info->name); gtk_menu_set_accel_path(GTK_MENU(submenu), path); g_free(path); build_plugin_actions(submenu, plugin, NULL); } gtk_widget_show_all(pluginmenu); } static void sortmethod_act(GtkCheckMenuItem *checkmenuitem, char *id) { if (gtk_check_menu_item_get_active(checkmenuitem)) { pidgin_set_cursor(gtkblist->window, GDK_WATCH); /* This is redundant. I think. */ /* pidgin_blist_sort_method_set(id); */ purple_prefs_set_string(PIDGIN_PREFS_ROOT "/blist/sort_type", id); pidgin_clear_cursor(gtkblist->window); } } void pidgin_blist_update_sort_methods(void) { GtkWidget *menuitem = NULL, *activeitem = NULL; PidginBlistSortMethod *method = NULL; GList *l; GSList *sl = NULL; GtkWidget *sortmenu; const char *m = purple_prefs_get_string(PIDGIN_PREFS_ROOT "/blist/sort_type"); if ((gtkblist == NULL) || (gtkblist->ift == NULL)) return; sortmenu = gtk_item_factory_get_widget(gtkblist->ift, N_("/Buddies/Sort Buddies")); if (sortmenu == NULL) return; /* Clear the old menu */ for (l = gtk_container_get_children(GTK_CONTAINER(sortmenu)); l; l = g_list_delete_link(l, l)) { menuitem = l->data; gtk_widget_destroy(GTK_WIDGET(menuitem)); } for (l = pidgin_blist_sort_methods; l; l = l->next) { method = (PidginBlistSortMethod *) l->data; menuitem = gtk_radio_menu_item_new_with_label(sl, _(method->name)); if (!strcmp(m, method->id)) activeitem = menuitem; sl = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(menuitem)); gtk_menu_shell_append(GTK_MENU_SHELL(sortmenu), menuitem); g_signal_connect(G_OBJECT(menuitem), "toggled", G_CALLBACK(sortmethod_act), method->id); gtk_widget_show(menuitem); } if (activeitem) gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(activeitem), TRUE); }