Mercurial > pidgin.yaz
diff pidgin/gtkpounce.c @ 15374:5fe8042783c1
Rename gtk/ and libgaim/ to pidgin/ and libpurple/
author | Sean Egan <seanegan@gmail.com> |
---|---|
date | Sat, 20 Jan 2007 02:32:10 +0000 |
parents | |
children | 29e443e0613f |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/pidgin/gtkpounce.c Sat Jan 20 02:32:10 2007 +0000 @@ -0,0 +1,1666 @@ +/** + * @file gtkpounce.c GTK+ Buddy Pounce API + * @ingroup gtkui + * + * gaim + * + * Gaim 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ +#include "internal.h" +#include "gtkgaim.h" + +#include "account.h" +#include "conversation.h" +#include "debug.h" +#include "notify.h" +#include "prpl.h" +#include "request.h" +#include "server.h" +#include "sound.h" +#include "util.h" + +#include "gtkblist.h" +#include "gtkdialogs.h" +#include "gtkpounce.h" +#include "gaimstock.h" +#include "gtkutils.h" + +/** + * These are used for the GtkTreeView when you're scrolling through + * all your saved pounces. + */ +enum +{ + /* Hidden column containing the GaimPounce */ + POUNCES_MANAGER_COLUMN_POUNCE, + POUNCES_MANAGER_COLUMN_ICON, + POUNCES_MANAGER_COLUMN_TARGET, + POUNCES_MANAGER_COLUMN_ACCOUNT, + POUNCES_MANAGER_COLUMN_RECURRING, + POUNCES_MANAGER_NUM_COLUMNS +}; + +typedef struct +{ + /* Pounce data */ + GaimPounce *pounce; + GaimAccount *account; + + /* The window */ + GtkWidget *window; + + /* Pounce on Whom */ + GtkWidget *account_menu; + GtkWidget *buddy_entry; + + /* Pounce options */ + GtkWidget *on_away; + + /* Pounce When Buddy... */ + GtkWidget *signon; + GtkWidget *signoff; + GtkWidget *away; + GtkWidget *away_return; + GtkWidget *idle; + GtkWidget *idle_return; + GtkWidget *typing; + GtkWidget *typed; + GtkWidget *stop_typing; + GtkWidget *message_recv; + + /* Action */ + GtkWidget *open_win; + GtkWidget *popup; + GtkWidget *popup_entry; + GtkWidget *send_msg; + GtkWidget *send_msg_entry; + GtkWidget *exec_cmd; + GtkWidget *exec_cmd_entry; + GtkWidget *exec_cmd_browse; + GtkWidget *play_sound; + GtkWidget *play_sound_entry; + GtkWidget *play_sound_browse; + GtkWidget *play_sound_test; + + GtkWidget *save_pounce; + + /* Buttons */ + GtkWidget *save_button; + +} GaimGtkPounceDialog; + +typedef struct +{ + GtkWidget *window; + GtkListStore *model; + GtkWidget *treeview; + GtkWidget *modify_button; + GtkWidget *delete_button; +} PouncesManager; + +static PouncesManager *pounces_manager = NULL; + +/************************************************************************** + * Callbacks + **************************************************************************/ +static gint +delete_win_cb(GtkWidget *w, GdkEventAny *e, GaimGtkPounceDialog *dialog) +{ + gtk_widget_destroy(dialog->window); + g_free(dialog); + + return TRUE; +} + +static void +cancel_cb(GtkWidget *w, GaimGtkPounceDialog *dialog) +{ + delete_win_cb(NULL, NULL, dialog); +} + +static void +pounce_update_entry_fields(void *user_data, const char *filename) +{ + GtkWidget *entry = (GtkWidget *)user_data; + + gtk_entry_set_text(GTK_ENTRY(entry), filename); +} + +static void +filesel(GtkWidget *widget, gpointer data) +{ + GtkWidget *entry; + const gchar *name; + + entry = (GtkWidget *)data; + name = gtk_entry_get_text(GTK_ENTRY(entry)); + + gaim_request_file(entry, _("Select a file"), name, FALSE, + G_CALLBACK(pounce_update_entry_fields), NULL, entry); + g_signal_connect_swapped(G_OBJECT(entry), "destroy", + G_CALLBACK(gaim_request_close_with_handle), entry); +} + +static void +pounce_test_sound(GtkWidget *w, GtkWidget *entry) +{ + const char *filename; + + filename = gtk_entry_get_text(GTK_ENTRY(entry)); + + if (filename != NULL && *filename != '\0') + gaim_sound_play_file(filename, NULL); + else + gaim_sound_play_event(GAIM_SOUND_POUNCE_DEFAULT, NULL); +} + +static void +add_pounce_to_treeview(GtkListStore *model, GaimPounce *pounce) +{ + GtkTreeIter iter; + GaimAccount *account; + GaimPounceEvent events; + gboolean recurring; + const char *pouncer; + const char *pouncee; + GdkPixbuf *pixbuf; + + account = gaim_pounce_get_pouncer(pounce); + + events = gaim_pounce_get_events(pounce); + + pixbuf = gaim_gtk_create_prpl_icon(account, 0.5); + + pouncer = gaim_account_get_username(account); + pouncee = gaim_pounce_get_pouncee(pounce); + recurring = gaim_pounce_get_save(pounce); + + gtk_list_store_append(model, &iter); + gtk_list_store_set(model, &iter, + POUNCES_MANAGER_COLUMN_POUNCE, pounce, + POUNCES_MANAGER_COLUMN_ICON, pixbuf, + POUNCES_MANAGER_COLUMN_TARGET, pouncee, + POUNCES_MANAGER_COLUMN_ACCOUNT, pouncer, + POUNCES_MANAGER_COLUMN_RECURRING, recurring, + -1); + + if (pixbuf != NULL) + g_object_unref(pixbuf); +} + +static void +populate_pounces_list(PouncesManager *dialog) +{ + const GList *pounces; + + gtk_list_store_clear(dialog->model); + + for (pounces = gaim_pounces_get_all(); pounces != NULL; + pounces = g_list_next(pounces)) + { + add_pounce_to_treeview(dialog->model, pounces->data); + } +} + +static void +update_pounces(void) +{ + /* Rebuild the pounces list if the pounces manager is open */ + if (pounces_manager != NULL) + { + populate_pounces_list(pounces_manager); + } +} + +static void +signed_on_off_cb(GaimConnection *gc, gpointer user_data) +{ + update_pounces(); +} + +static void +save_pounce_cb(GtkWidget *w, GaimGtkPounceDialog *dialog) +{ + const char *name; + const char *message, *command, *sound, *reason; + GaimPounceEvent events = GAIM_POUNCE_NONE; + GaimPounceOption options = GAIM_POUNCE_OPTION_NONE; + + name = gtk_entry_get_text(GTK_ENTRY(dialog->buddy_entry)); + + if (*name == '\0') + { + gaim_notify_error(NULL, NULL, + _("Please enter a buddy to pounce."), NULL); + return; + } + + /* Options */ + if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->on_away))) + options |= GAIM_POUNCE_OPTION_AWAY; + + /* Events */ + if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->signon))) + events |= GAIM_POUNCE_SIGNON; + + if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->signoff))) + events |= GAIM_POUNCE_SIGNOFF; + + if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->away))) + events |= GAIM_POUNCE_AWAY; + + if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->away_return))) + events |= GAIM_POUNCE_AWAY_RETURN; + + if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->idle))) + events |= GAIM_POUNCE_IDLE; + + if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->idle_return))) + events |= GAIM_POUNCE_IDLE_RETURN; + + if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->typing))) + events |= GAIM_POUNCE_TYPING; + + if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->typed))) + events |= GAIM_POUNCE_TYPED; + + if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->stop_typing))) + events |= GAIM_POUNCE_TYPING_STOPPED; + + if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->message_recv))) + events |= GAIM_POUNCE_MESSAGE_RECEIVED; + + /* Data fields */ + message = gtk_entry_get_text(GTK_ENTRY(dialog->send_msg_entry)); + command = gtk_entry_get_text(GTK_ENTRY(dialog->exec_cmd_entry)); + sound = gtk_entry_get_text(GTK_ENTRY(dialog->play_sound_entry)); + reason = gtk_entry_get_text(GTK_ENTRY(dialog->popup_entry)); + + if (*reason == '\0') reason = NULL; + if (*message == '\0') message = NULL; + if (*command == '\0') command = NULL; + if (*sound == '\0') sound = NULL; + + if (dialog->pounce == NULL) + { + dialog->pounce = gaim_pounce_new(GAIM_GTK_UI, dialog->account, + name, events, options); + } + else { + gaim_pounce_set_events(dialog->pounce, events); + gaim_pounce_set_options(dialog->pounce, options); + gaim_pounce_set_pouncer(dialog->pounce, dialog->account); + gaim_pounce_set_pouncee(dialog->pounce, name); + } + + /* Actions */ + gaim_pounce_action_set_enabled(dialog->pounce, "open-window", + gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->open_win))); + gaim_pounce_action_set_enabled(dialog->pounce, "popup-notify", + gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->popup))); + gaim_pounce_action_set_enabled(dialog->pounce, "send-message", + gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->send_msg))); + gaim_pounce_action_set_enabled(dialog->pounce, "execute-command", + gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->exec_cmd))); + gaim_pounce_action_set_enabled(dialog->pounce, "play-sound", + gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->play_sound))); + + gaim_pounce_action_set_attribute(dialog->pounce, "send-message", + "message", message); + gaim_pounce_action_set_attribute(dialog->pounce, "execute-command", + "command", command); + gaim_pounce_action_set_attribute(dialog->pounce, "play-sound", + "filename", sound); + gaim_pounce_action_set_attribute(dialog->pounce, "popup-notify", + "reason", reason); + + /* Set the defaults for next time. */ + gaim_prefs_set_bool("/gaim/gtk/pounces/default_actions/open-window", + gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->open_win))); + gaim_prefs_set_bool("/gaim/gtk/pounces/default_actions/popup-notify", + gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->popup))); + gaim_prefs_set_bool("/gaim/gtk/pounces/default_actions/send-message", + gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->send_msg))); + gaim_prefs_set_bool("/gaim/gtk/pounces/default_actions/execute-command", + gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->exec_cmd))); + gaim_prefs_set_bool("/gaim/gtk/pounces/default_actions/play-sound", + gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->play_sound))); + + gaim_pounce_set_save(dialog->pounce, + gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dialog->save_pounce))); + + update_pounces(); + + delete_win_cb(NULL, NULL, dialog); +} + +static void +pounce_choose_cb(GtkWidget *item, GaimAccount *account, + GaimGtkPounceDialog *dialog) +{ + dialog->account = account; +} + +static void +buddy_changed_cb(GtkEntry *entry, GaimGtkPounceDialog *dialog) +{ + if (dialog->save_button == NULL) + return; + + gtk_widget_set_sensitive(dialog->save_button, + *gtk_entry_get_text(entry) != '\0'); +} + +static void +message_recv_toggle(GtkButton *message_recv, GtkWidget *send_msg) +{ + gboolean active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(message_recv)); + + gtk_widget_set_sensitive(send_msg, !active); + if (active) + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(send_msg), FALSE); +} + +static void +pounce_dnd_recv(GtkWidget *widget, GdkDragContext *dc, gint x, gint y, + GtkSelectionData *sd, guint info, guint t, gpointer data) +{ + GaimGtkPounceDialog *dialog; + + if (sd->target == gdk_atom_intern("GAIM_BLIST_NODE", FALSE)) + { + GaimBlistNode *node = NULL; + GaimBuddy *buddy; + + memcpy(&node, sd->data, sizeof(node)); + + if (GAIM_BLIST_NODE_IS_CONTACT(node)) + buddy = gaim_contact_get_priority_buddy((GaimContact *)node); + else if (GAIM_BLIST_NODE_IS_BUDDY(node)) + buddy = (GaimBuddy *)node; + else + return; + + dialog = (GaimGtkPounceDialog *)data; + + gtk_entry_set_text(GTK_ENTRY(dialog->buddy_entry), buddy->name); + dialog->account = buddy->account; + gaim_gtk_account_option_menu_set_selected(dialog->account_menu, buddy->account); + + gtk_drag_finish(dc, TRUE, (dc->action == GDK_ACTION_MOVE), t); + } + else if (sd->target == gdk_atom_intern("application/x-im-contact", FALSE)) + { + char *protocol = NULL; + char *username = NULL; + GaimAccount *account; + + if (gaim_gtk_parse_x_im_contact((const char *)sd->data, FALSE, &account, + &protocol, &username, NULL)) + { + if (account == NULL) + { + gaim_notify_error(NULL, NULL, + _("You are not currently signed on with an account that " + "can add that buddy."), NULL); + } + else + { + dialog = (GaimGtkPounceDialog *)data; + + gtk_entry_set_text(GTK_ENTRY(dialog->buddy_entry), username); + dialog->account = account; + gaim_gtk_account_option_menu_set_selected(dialog->account_menu, account); + } + } + + g_free(username); + g_free(protocol); + + gtk_drag_finish(dc, TRUE, (dc->action == GDK_ACTION_MOVE), t); + } +} + +static const GtkTargetEntry dnd_targets[] = +{ + {"GAIM_BLIST_NODE", GTK_TARGET_SAME_APP, 0}, + {"application/x-im-contact", 0, 1} +}; + +void +gaim_gtk_pounce_editor_show(GaimAccount *account, const char *name, + GaimPounce *cur_pounce) +{ + GaimGtkPounceDialog *dialog; + GtkWidget *window; + GtkWidget *label; + GtkWidget *bbox; + GtkWidget *vbox1, *vbox2; + GtkWidget *hbox; + GtkWidget *button; + GtkWidget *frame; + GtkWidget *table; + GtkSizeGroup *sg; + GPtrArray *sound_widgets; + GPtrArray *exec_widgets; + + g_return_if_fail((cur_pounce != NULL) || + (account != NULL) || + (gaim_accounts_get_all() != NULL)); + + dialog = g_new0(GaimGtkPounceDialog, 1); + + if (cur_pounce != NULL) + { + dialog->pounce = cur_pounce; + dialog->account = gaim_pounce_get_pouncer(cur_pounce); + } + else if (account != NULL) + { + dialog->pounce = NULL; + dialog->account = account; + } + else + { + GList *connections = gaim_connections_get_all(); + GaimConnection *gc; + + if (connections != NULL) + { + gc = (GaimConnection *)connections->data; + dialog->account = gaim_connection_get_account(gc); + } + else + dialog->account = gaim_accounts_get_all()->data; + + dialog->pounce = NULL; + } + + sg = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL); + + /* Create the window. */ + dialog->window = window = gtk_window_new(GTK_WINDOW_TOPLEVEL); + gtk_window_set_type_hint(GTK_WINDOW(window), GDK_WINDOW_TYPE_HINT_DIALOG); + gtk_window_set_role(GTK_WINDOW(window), "buddy_pounce"); + gtk_window_set_resizable(GTK_WINDOW(window), FALSE); + gtk_window_set_title(GTK_WINDOW(window), + (cur_pounce == NULL + ? _("New Buddy Pounce") : _("Edit Buddy Pounce"))); + + gtk_container_set_border_width(GTK_CONTAINER(window), GAIM_HIG_BORDER); + + g_signal_connect(G_OBJECT(window), "delete_event", + G_CALLBACK(delete_win_cb), dialog); + + /* Create the parent vbox for everything. */ + vbox1 = gtk_vbox_new(FALSE, GAIM_HIG_BORDER); + gtk_container_add(GTK_CONTAINER(window), vbox1); + gtk_widget_show(vbox1); + + /* Create the vbox that will contain all the prefs stuff. */ + vbox2 = gtk_vbox_new(FALSE, GAIM_HIG_BOX_SPACE); + gtk_box_pack_start(GTK_BOX(vbox1), vbox2, TRUE, TRUE, 0); + + /* Create the "Pounce on Whom" frame. */ + frame = gaim_gtk_make_frame(vbox2, _("Pounce on Whom")); + + /* Account: */ + hbox = gtk_hbox_new(FALSE, GAIM_HIG_BOX_SPACE); + gtk_box_pack_start(GTK_BOX(frame), hbox, FALSE, FALSE, 0); + gtk_widget_show(hbox); + + label = gtk_label_new_with_mnemonic(_("_Account:")); + gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); + gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); + gtk_widget_show(label); + gtk_size_group_add_widget(sg, label); + + dialog->account_menu = + gaim_gtk_account_option_menu_new(dialog->account, TRUE, + G_CALLBACK(pounce_choose_cb), + NULL, dialog); + + gtk_box_pack_start(GTK_BOX(hbox), dialog->account_menu, FALSE, FALSE, 0); + gtk_widget_show(dialog->account_menu); + gaim_set_accessible_label (dialog->account_menu, label); + + /* Buddy: */ + hbox = gtk_hbox_new(FALSE, GAIM_HIG_BOX_SPACE); + gtk_box_pack_start(GTK_BOX(frame), hbox, FALSE, FALSE, 0); + gtk_widget_show(hbox); + + label = gtk_label_new_with_mnemonic(_("_Buddy name:")); + gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); + gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); + gtk_widget_show(label); + gtk_size_group_add_widget(sg, label); + + dialog->buddy_entry = gtk_entry_new(); + + gaim_gtk_setup_screenname_autocomplete(dialog->buddy_entry, dialog->account_menu, FALSE); + + gtk_box_pack_start(GTK_BOX(hbox), dialog->buddy_entry, TRUE, TRUE, 0); + gtk_widget_show(dialog->buddy_entry); + + g_signal_connect(G_OBJECT(dialog->buddy_entry), "changed", + G_CALLBACK(buddy_changed_cb), dialog); + gaim_set_accessible_label (dialog->buddy_entry, label); + + if (cur_pounce != NULL) { + gtk_entry_set_text(GTK_ENTRY(dialog->buddy_entry), + gaim_pounce_get_pouncee(cur_pounce)); + } + else if (name != NULL) { + gtk_entry_set_text(GTK_ENTRY(dialog->buddy_entry), name); + } + + /* Create the "Pounce When Buddy..." frame. */ + frame = gaim_gtk_make_frame(vbox2, _("Pounce When Buddy...")); + + table = gtk_table_new(5, 2, FALSE); + gtk_container_add(GTK_CONTAINER(frame), table); + gtk_table_set_col_spacings(GTK_TABLE(table), GAIM_HIG_BORDER); + gtk_widget_show(table); + + dialog->signon = + gtk_check_button_new_with_mnemonic(_("Si_gns on")); + dialog->signoff = + gtk_check_button_new_with_mnemonic(_("Signs o_ff")); + dialog->away = + gtk_check_button_new_with_mnemonic(_("Goes a_way")); + dialog->away_return = + gtk_check_button_new_with_mnemonic(_("Ret_urns from away")); + dialog->idle = + gtk_check_button_new_with_mnemonic(_("Becomes _idle")); + dialog->idle_return = + gtk_check_button_new_with_mnemonic(_("Is no longer i_dle")); + dialog->typing = + gtk_check_button_new_with_mnemonic(_("Starts _typing")); + dialog->typed = + gtk_check_button_new_with_mnemonic(_("P_auses while typing")); + dialog->stop_typing = + gtk_check_button_new_with_mnemonic(_("Stops t_yping")); + dialog->message_recv = + gtk_check_button_new_with_mnemonic(_("Sends a _message")); + + gtk_table_attach(GTK_TABLE(table), dialog->message_recv, 0, 1, 0, 1, + GTK_FILL, 0, 0, 0); + gtk_table_attach(GTK_TABLE(table), dialog->signon, 0, 1, 1, 2, + GTK_FILL, 0, 0, 0); + gtk_table_attach(GTK_TABLE(table), dialog->signoff, 0, 1, 2, 3, + GTK_FILL, 0, 0, 0); + gtk_table_attach(GTK_TABLE(table), dialog->away, 0, 1, 3, 4, + GTK_FILL, 0, 0, 0); + gtk_table_attach(GTK_TABLE(table), dialog->away_return, 0, 1, 4, 5, + GTK_FILL, 0, 0, 0); + gtk_table_attach(GTK_TABLE(table), dialog->idle, 1, 2, 0, 1, + GTK_FILL, 0, 0, 0); + gtk_table_attach(GTK_TABLE(table), dialog->idle_return, 1, 2, 1, 2, + GTK_FILL, 0, 0, 0); + gtk_table_attach(GTK_TABLE(table), dialog->typing, 1, 2, 2, 3, + GTK_FILL, 0, 0, 0); + gtk_table_attach(GTK_TABLE(table), dialog->typed, 1, 2, 3, 4, + GTK_FILL, 0, 0, 0); + gtk_table_attach(GTK_TABLE(table), dialog->stop_typing, 1, 2, 4, 5, + GTK_FILL, 0, 0, 0); + + gtk_widget_show(dialog->signon); + gtk_widget_show(dialog->signoff); + gtk_widget_show(dialog->away); + gtk_widget_show(dialog->away_return); + gtk_widget_show(dialog->idle); + gtk_widget_show(dialog->idle_return); + gtk_widget_show(dialog->typing); + gtk_widget_show(dialog->typed); + gtk_widget_show(dialog->stop_typing); + gtk_widget_show(dialog->message_recv); + + /* Create the "Action" frame. */ + frame = gaim_gtk_make_frame(vbox2, _("Action")); + + table = gtk_table_new(3, 5, FALSE); + gtk_container_add(GTK_CONTAINER(frame), table); + gtk_table_set_col_spacings(GTK_TABLE(table), GAIM_HIG_BORDER); + gtk_widget_show(table); + + dialog->open_win + = gtk_check_button_new_with_mnemonic(_("Ope_n an IM window")); + dialog->popup + = gtk_check_button_new_with_mnemonic(_("_Pop up a notification")); + dialog->send_msg + = gtk_check_button_new_with_mnemonic(_("Send a _message")); + dialog->exec_cmd + = gtk_check_button_new_with_mnemonic(_("E_xecute a command")); + dialog->play_sound + = gtk_check_button_new_with_mnemonic(_("P_lay a sound")); + + dialog->send_msg_entry = gtk_entry_new(); + dialog->exec_cmd_entry = gtk_entry_new(); + dialog->popup_entry = gtk_entry_new(); + dialog->exec_cmd_browse = gtk_button_new_with_mnemonic(_("Brows_e...")); + dialog->play_sound_entry = gtk_entry_new(); + dialog->play_sound_browse = gtk_button_new_with_mnemonic(_("Br_owse...")); + dialog->play_sound_test = gtk_button_new_with_mnemonic(_("Pre_view")); + + gtk_widget_set_sensitive(dialog->send_msg_entry, FALSE); + gtk_widget_set_sensitive(dialog->exec_cmd_entry, FALSE); + gtk_widget_set_sensitive(dialog->popup_entry, FALSE); + gtk_widget_set_sensitive(dialog->exec_cmd_browse, FALSE); + gtk_widget_set_sensitive(dialog->play_sound_entry, FALSE); + gtk_widget_set_sensitive(dialog->play_sound_browse, FALSE); + gtk_widget_set_sensitive(dialog->play_sound_test, FALSE); + + sg = gtk_size_group_new(GTK_SIZE_GROUP_VERTICAL); + gtk_size_group_add_widget(sg, dialog->open_win); + gtk_size_group_add_widget(sg, dialog->popup); + gtk_size_group_add_widget(sg, dialog->popup_entry); + gtk_size_group_add_widget(sg, dialog->send_msg); + gtk_size_group_add_widget(sg, dialog->send_msg_entry); + gtk_size_group_add_widget(sg, dialog->exec_cmd); + gtk_size_group_add_widget(sg, dialog->exec_cmd_entry); + gtk_size_group_add_widget(sg, dialog->exec_cmd_browse); + gtk_size_group_add_widget(sg, dialog->play_sound); + gtk_size_group_add_widget(sg, dialog->play_sound_entry); + gtk_size_group_add_widget(sg, dialog->play_sound_browse); + gtk_size_group_add_widget(sg, dialog->play_sound_test); + + gtk_table_attach(GTK_TABLE(table), dialog->open_win, 0, 1, 0, 1, + GTK_FILL, 0, 0, 0); + gtk_table_attach(GTK_TABLE(table), dialog->popup, 0, 1, 1, 2, + GTK_FILL, 0, 0, 0); + gtk_table_attach(GTK_TABLE(table), dialog->popup_entry, 1, 4, 1, 2, + GTK_FILL, 0, 0, 0); + gtk_table_attach(GTK_TABLE(table), dialog->send_msg, 0, 1, 2, 3, + GTK_FILL, 0, 0, 0); + gtk_table_attach(GTK_TABLE(table), dialog->send_msg_entry, 1, 4, 2, 3, + GTK_FILL, 0, 0, 0); + gtk_table_attach(GTK_TABLE(table), dialog->exec_cmd, 0, 1, 3, 4, + GTK_FILL, 0, 0, 0); + gtk_table_attach(GTK_TABLE(table), dialog->exec_cmd_entry, 1, 2, 3, 4, + GTK_FILL, 0, 0, 0); + gtk_table_attach(GTK_TABLE(table), dialog->exec_cmd_browse, 2, 3, 3, 4, + GTK_FILL | GTK_EXPAND, 0, 0, 0); + gtk_table_attach(GTK_TABLE(table), dialog->play_sound, 0, 1, 4, 5, + GTK_FILL, 0, 0, 0); + gtk_table_attach(GTK_TABLE(table), dialog->play_sound_entry, 1, 2, 4, 5, + GTK_FILL, 0, 0, 0); + gtk_table_attach(GTK_TABLE(table), dialog->play_sound_browse, 2, 3, 4, 5, + GTK_FILL | GTK_EXPAND, 0, 0, 0); + gtk_table_attach(GTK_TABLE(table), dialog->play_sound_test, 3, 4, 4, 5, + GTK_FILL | GTK_EXPAND, 0, 0, 0); + + gtk_table_set_row_spacings(GTK_TABLE(table), GAIM_HIG_BOX_SPACE / 2); + + gtk_widget_show(dialog->open_win); + gtk_widget_show(dialog->popup); + gtk_widget_show(dialog->popup_entry); + gtk_widget_show(dialog->send_msg); + gtk_widget_show(dialog->send_msg_entry); + gtk_widget_show(dialog->exec_cmd); + gtk_widget_show(dialog->exec_cmd_entry); + gtk_widget_show(dialog->exec_cmd_browse); + gtk_widget_show(dialog->play_sound); + gtk_widget_show(dialog->play_sound_entry); + gtk_widget_show(dialog->play_sound_browse); + gtk_widget_show(dialog->play_sound_test); + + g_signal_connect(G_OBJECT(dialog->message_recv), "clicked", + G_CALLBACK(message_recv_toggle), + dialog->send_msg); + + g_signal_connect(G_OBJECT(dialog->send_msg), "clicked", + G_CALLBACK(gaim_gtk_toggle_sensitive), + dialog->send_msg_entry); + + g_signal_connect(G_OBJECT(dialog->popup), "clicked", + G_CALLBACK(gaim_gtk_toggle_sensitive), + dialog->popup_entry); + + exec_widgets = g_ptr_array_new(); + g_ptr_array_add(exec_widgets,dialog->exec_cmd_entry); + g_ptr_array_add(exec_widgets,dialog->exec_cmd_browse); + + g_signal_connect(G_OBJECT(dialog->exec_cmd), "clicked", + G_CALLBACK(gaim_gtk_toggle_sensitive_array), + exec_widgets); + g_signal_connect(G_OBJECT(dialog->exec_cmd_browse), "clicked", + G_CALLBACK(filesel), + dialog->exec_cmd_entry); + g_object_set_data_full(G_OBJECT(dialog->window), "exec-widgets", + exec_widgets, (GDestroyNotify)g_ptr_array_free); + + sound_widgets = g_ptr_array_new(); + g_ptr_array_add(sound_widgets,dialog->play_sound_entry); + g_ptr_array_add(sound_widgets,dialog->play_sound_browse); + g_ptr_array_add(sound_widgets,dialog->play_sound_test); + + g_signal_connect(G_OBJECT(dialog->play_sound), "clicked", + G_CALLBACK(gaim_gtk_toggle_sensitive_array), + sound_widgets); + g_signal_connect(G_OBJECT(dialog->play_sound_browse), "clicked", + G_CALLBACK(filesel), + dialog->play_sound_entry); + g_signal_connect(G_OBJECT(dialog->play_sound_test), "clicked", + G_CALLBACK(pounce_test_sound), + dialog->play_sound_entry); + g_object_set_data_full(G_OBJECT(dialog->window), "sound-widgets", + sound_widgets, (GDestroyNotify)g_ptr_array_free); + + g_signal_connect(G_OBJECT(dialog->send_msg_entry), "activate", + G_CALLBACK(save_pounce_cb), dialog); + g_signal_connect(G_OBJECT(dialog->popup_entry), "activate", + G_CALLBACK(save_pounce_cb), dialog); + g_signal_connect(G_OBJECT(dialog->exec_cmd_entry), "activate", + G_CALLBACK(save_pounce_cb), dialog); + g_signal_connect(G_OBJECT(dialog->play_sound_entry), "activate", + G_CALLBACK(save_pounce_cb), dialog); + + /* Create the "Options" frame. */ + frame = gaim_gtk_make_frame(vbox2, _("Options")); + + table = gtk_table_new(2, 1, FALSE); + gtk_container_add(GTK_CONTAINER(frame), table); + gtk_table_set_col_spacings(GTK_TABLE(table), GAIM_HIG_BORDER); + gtk_widget_show(table); + + dialog->on_away = + gtk_check_button_new_with_mnemonic(_("P_ounce only when my status is not available")); + gtk_table_attach(GTK_TABLE(table), dialog->on_away, 0, 1, 0, 1, + GTK_FILL, 0, 0, 0); + + dialog->save_pounce = gtk_check_button_new_with_mnemonic( + _("_Recurring")); + gtk_table_attach(GTK_TABLE(table), dialog->save_pounce, 0, 1, 1, 2, + GTK_FILL, 0, 0, 0); + + gtk_widget_show(dialog->on_away); + gtk_widget_show(dialog->save_pounce); + + /* Now the button box! */ + bbox = gtk_hbutton_box_new(); + gtk_box_set_spacing(GTK_BOX(bbox), GAIM_HIG_BOX_SPACE); + gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END); + gtk_box_pack_end(GTK_BOX(vbox1), bbox, FALSE, FALSE, 0); + gtk_widget_show(bbox); + + /* Cancel button */ + button = gtk_button_new_from_stock(GTK_STOCK_CANCEL); + gtk_box_pack_start(GTK_BOX(bbox), button, FALSE, FALSE, 0); + gtk_widget_show(button); + + g_signal_connect(G_OBJECT(button), "clicked", + G_CALLBACK(cancel_cb), dialog); + + /* Save button */ + dialog->save_button = button = gtk_button_new_from_stock(GTK_STOCK_SAVE); + gtk_box_pack_start(GTK_BOX(bbox), button, FALSE, FALSE, 0); + gtk_widget_show(button); + + g_signal_connect(G_OBJECT(button), "clicked", + G_CALLBACK(save_pounce_cb), dialog); + + if (*gtk_entry_get_text(GTK_ENTRY(dialog->buddy_entry)) == '\0') + gtk_widget_set_sensitive(button, FALSE); + + /* Setup drag-and-drop */ + gtk_drag_dest_set(window, + GTK_DEST_DEFAULT_MOTION | + GTK_DEST_DEFAULT_DROP, + dnd_targets, + sizeof(dnd_targets) / sizeof(GtkTargetEntry), + GDK_ACTION_COPY); + gtk_drag_dest_set(dialog->buddy_entry, + GTK_DEST_DEFAULT_MOTION | + GTK_DEST_DEFAULT_DROP, + dnd_targets, + sizeof(dnd_targets) / sizeof(GtkTargetEntry), + GDK_ACTION_COPY); + + g_signal_connect(G_OBJECT(window), "drag_data_received", + G_CALLBACK(pounce_dnd_recv), dialog); + g_signal_connect(G_OBJECT(dialog->buddy_entry), "drag_data_received", + G_CALLBACK(pounce_dnd_recv), dialog); + + /* Set the values of stuff. */ + if (cur_pounce != NULL) + { + GaimPounceEvent events = gaim_pounce_get_events(cur_pounce); + GaimPounceOption options = gaim_pounce_get_options(cur_pounce); + const char *value; + + /* Options */ + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->on_away), + (options & GAIM_POUNCE_OPTION_AWAY)); + + /* Events */ + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->signon), + (events & GAIM_POUNCE_SIGNON)); + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->signoff), + (events & GAIM_POUNCE_SIGNOFF)); + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->away), + (events & GAIM_POUNCE_AWAY)); + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->away_return), + (events & GAIM_POUNCE_AWAY_RETURN)); + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->idle), + (events & GAIM_POUNCE_IDLE)); + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->idle_return), + (events & GAIM_POUNCE_IDLE_RETURN)); + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->typing), + (events & GAIM_POUNCE_TYPING)); + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->typed), + (events & GAIM_POUNCE_TYPED)); + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->stop_typing), + (events & GAIM_POUNCE_TYPING_STOPPED)); + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->message_recv), + (events & GAIM_POUNCE_MESSAGE_RECEIVED)); + + /* Actions */ + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->open_win), + gaim_pounce_action_is_enabled(cur_pounce, "open-window")); + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->popup), + gaim_pounce_action_is_enabled(cur_pounce, "popup-notify")); + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->send_msg), + gaim_pounce_action_is_enabled(cur_pounce, "send-message")); + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->exec_cmd), + gaim_pounce_action_is_enabled(cur_pounce, "execute-command")); + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->play_sound), + gaim_pounce_action_is_enabled(cur_pounce, "play-sound")); + + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->save_pounce), + gaim_pounce_get_save(cur_pounce)); + + if ((value = gaim_pounce_action_get_attribute(cur_pounce, + "send-message", + "message")) != NULL) + { + gtk_entry_set_text(GTK_ENTRY(dialog->send_msg_entry), value); + } + + if ((value = gaim_pounce_action_get_attribute(cur_pounce, + "popup-notify", + "reason")) != NULL) + { + gtk_entry_set_text(GTK_ENTRY(dialog->popup_entry), value); + } + + if ((value = gaim_pounce_action_get_attribute(cur_pounce, + "execute-command", + "command")) != NULL) + { + gtk_entry_set_text(GTK_ENTRY(dialog->exec_cmd_entry), value); + } + + if ((value = gaim_pounce_action_get_attribute(cur_pounce, + "play-sound", + "filename")) != NULL) + { + gtk_entry_set_text(GTK_ENTRY(dialog->play_sound_entry), value); + } + } + else + { + GaimBuddy *buddy = NULL; + + if (name != NULL) + buddy = gaim_find_buddy(account, name); + + /* Set some defaults */ + if (buddy == NULL) + { + gtk_toggle_button_set_active( + GTK_TOGGLE_BUTTON(dialog->signon), TRUE); + } + else + { + if (!GAIM_BUDDY_IS_ONLINE(buddy)) + { + gtk_toggle_button_set_active( + GTK_TOGGLE_BUTTON(dialog->signon), TRUE); + } + else + { + gboolean default_set = FALSE; + GaimPresence *presence = gaim_buddy_get_presence(buddy); + + if (gaim_presence_is_idle(presence)) + { + gtk_toggle_button_set_active( + GTK_TOGGLE_BUTTON(dialog->idle_return), TRUE); + + default_set = TRUE; + } + + if (!gaim_presence_is_available(presence)) + { + gtk_toggle_button_set_active( + GTK_TOGGLE_BUTTON(dialog->away_return), TRUE); + + default_set = TRUE; + } + + if (!default_set) + { + gtk_toggle_button_set_active( + GTK_TOGGLE_BUTTON(dialog->signon), TRUE); + } + } + } + + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->open_win), + gaim_prefs_get_bool("/gaim/gtk/pounces/default_actions/open-window")); + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->popup), + gaim_prefs_get_bool("/gaim/gtk/pounces/default_actions/popup-notify")); + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->send_msg), + gaim_prefs_get_bool("/gaim/gtk/pounces/default_actions/send-message")); + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->exec_cmd), + gaim_prefs_get_bool("/gaim/gtk/pounces/default_actions/execute-command")); + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dialog->play_sound), + gaim_prefs_get_bool("/gaim/gtk/pounces/default_actions/play-sound")); + } + + gtk_widget_show_all(vbox2); + gtk_widget_show(window); +} + +static gboolean +pounces_manager_configure_cb(GtkWidget *widget, GdkEventConfigure *event, PouncesManager *dialog) +{ + if (GTK_WIDGET_VISIBLE(widget)) { + gaim_prefs_set_int("/gaim/gtk/pounces/dialog/width", event->width); + gaim_prefs_set_int("/gaim/gtk/pounces/dialog/height", event->height); + } + + return FALSE; +} + +static gboolean +pounces_manager_find_pounce(GtkTreeIter *iter, GaimPounce *pounce) +{ + GtkTreeModel *model = GTK_TREE_MODEL(pounces_manager->model); + GaimPounce *p; + + if (!gtk_tree_model_get_iter_first(model, iter)) + return FALSE; + + gtk_tree_model_get(model, iter, POUNCES_MANAGER_COLUMN_POUNCE, &p, -1); + if (pounce == p) + return TRUE; + + while (gtk_tree_model_iter_next(model, iter)) + { + gtk_tree_model_get(model, iter, POUNCES_MANAGER_COLUMN_POUNCE, &p, -1); + if (pounce == p) + return TRUE; + } + + return FALSE; +} + +static gboolean +pounces_manager_destroy_cb(GtkWidget *widget, GdkEvent *event, gpointer user_data) +{ + PouncesManager *dialog = user_data; + + dialog->window = NULL; + gaim_gtk_pounces_manager_hide(); + + return FALSE; +} + +#if !GTK_CHECK_VERSION(2,2,0) +static void +count_selected_helper(GtkTreeModel *model, GtkTreePath *path, + GtkTreeIter *iter, gpointer user_data) +{ + (*(gint *)user_data)++; +} +#endif + +static void +pounces_manager_connection_cb(GaimConnection *gc, GtkWidget *add_button) +{ + gtk_widget_set_sensitive(add_button, (gaim_connections_get_all() != NULL)); +} + +static void +pounces_manager_add_cb(GtkButton *button, gpointer user_data) +{ + gaim_gtk_pounce_editor_show(NULL, NULL, NULL); +} + +static void +pounces_manager_modify_foreach(GtkTreeModel *model, GtkTreePath *path, + GtkTreeIter *iter, gpointer user_data) +{ + GaimPounce *pounce; + + gtk_tree_model_get(model, iter, POUNCES_MANAGER_COLUMN_POUNCE, &pounce, -1); + gaim_gtk_pounce_editor_show(NULL, NULL, pounce); +} + +static void +pounces_manager_modify_cb(GtkButton *button, gpointer user_data) +{ + PouncesManager *dialog = user_data; + GtkTreeSelection *selection; + + selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(dialog->treeview)); + + gtk_tree_selection_selected_foreach(selection, pounces_manager_modify_foreach, user_data); +} + +static void +pounces_manager_delete_confirm_cb(GaimPounce *pounce) +{ + GtkTreeIter iter; + + if (pounces_manager && pounces_manager_find_pounce(&iter, pounce)) + gtk_list_store_remove(pounces_manager->model, &iter); + + gaim_request_close_with_handle(pounce); + gaim_pounce_destroy(pounce); +} + +static void +pounces_manager_delete_foreach(GtkTreeModel *model, GtkTreePath *path, + GtkTreeIter *iter, gpointer user_data) +{ + GaimPounce *pounce; + GaimAccount *account; + const char *pouncer, *pouncee; + char *buf; + + gtk_tree_model_get(model, iter, POUNCES_MANAGER_COLUMN_POUNCE, &pounce, -1); + account = gaim_pounce_get_pouncer(pounce); + pouncer = gaim_account_get_username(account); + pouncee = gaim_pounce_get_pouncee(pounce); + + buf = g_strdup_printf(_("Are you sure you want to delete the pounce on %s for %s?"), pouncee, pouncer); + gaim_request_action(pounce, NULL, buf, NULL, 0, pounce, 2, + _("Delete"), pounces_manager_delete_confirm_cb, + _("Cancel"), NULL); + g_free(buf); +} + +static void +pounces_manager_delete_cb(GtkButton *button, gpointer user_data) +{ + PouncesManager *dialog = user_data; + GtkTreeSelection *selection; + + selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(dialog->treeview)); + + gtk_tree_selection_selected_foreach(selection, pounces_manager_delete_foreach, user_data); +} + +static void +pounces_manager_close_cb(GtkButton *button, gpointer user_data) +{ + gaim_gtk_pounces_manager_hide(); +} + +static void +pounce_selected_cb(GtkTreeSelection *sel, gpointer user_data) +{ + PouncesManager *dialog = user_data; + int num_selected = 0; + +#if GTK_CHECK_VERSION(2,2,0) + num_selected = gtk_tree_selection_count_selected_rows(sel); +#else + gtk_tree_selection_selected_foreach(sel, count_selected_helper, &num_selected); +#endif + + gtk_widget_set_sensitive(dialog->modify_button, (num_selected > 0)); + gtk_widget_set_sensitive(dialog->delete_button, (num_selected > 0)); +} + +static gboolean +pounce_double_click_cb(GtkTreeView *treeview, GdkEventButton *event, gpointer user_data) +{ + PouncesManager *dialog = user_data; + GtkTreePath *path; + GtkTreeIter iter; + GaimPounce *pounce; + + /* Figure out which node was clicked */ + if (!gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(dialog->treeview), event->x, event->y, &path, NULL, NULL, NULL)) + return FALSE; + gtk_tree_model_get_iter(GTK_TREE_MODEL(dialog->model), &iter, path); + gtk_tree_path_free(path); + gtk_tree_model_get(GTK_TREE_MODEL(dialog->model), &iter, POUNCES_MANAGER_COLUMN_POUNCE, &pounce, -1); + + if ((pounce != NULL) && (event->button == 1) && + (event->type == GDK_2BUTTON_PRESS)) + { + gaim_gtk_pounce_editor_show(NULL, NULL, pounce); + return TRUE; + } + + return FALSE; +} + +static void +pounces_manager_recurring_cb(GtkCellRendererToggle *renderer, gchar *path_str, + gpointer user_data) +{ + PouncesManager *dialog = user_data; + GaimPounce *pounce; + gboolean recurring; + GtkTreeModel *model = GTK_TREE_MODEL(dialog->model); + GtkTreeIter iter; + + gtk_tree_model_get_iter_from_string(model, &iter, path_str); + gtk_tree_model_get(model, &iter, + POUNCES_MANAGER_COLUMN_POUNCE, &pounce, + POUNCES_MANAGER_COLUMN_RECURRING, &recurring, + -1); + + gaim_pounce_set_save(pounce, !recurring); + + update_pounces(); +} + +static gboolean +search_func(GtkTreeModel *model, gint column, const gchar *key, GtkTreeIter *iter, gpointer search_data) +{ + gboolean result; + char *haystack; + + gtk_tree_model_get(model, iter, column, &haystack, -1); + + result = (gaim_strcasestr(haystack, key) == NULL); + + g_free(haystack); + + return result; +} + +static GtkWidget * +create_pounces_list(PouncesManager *dialog) +{ + GtkWidget *sw; + GtkWidget *treeview; + GtkTreeSelection *sel; + GtkTreeViewColumn *column; + GtkCellRenderer *renderer; + + /* Create the scrolled window */ + sw = gtk_scrolled_window_new(0, 0); + gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), + GTK_POLICY_AUTOMATIC, + GTK_POLICY_AUTOMATIC); + gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw), + GTK_SHADOW_IN); + gtk_widget_show(sw); + + /* Create the list model */ + dialog->model = gtk_list_store_new(POUNCES_MANAGER_NUM_COLUMNS, + G_TYPE_POINTER, + GDK_TYPE_PIXBUF, + G_TYPE_STRING, + G_TYPE_STRING, + G_TYPE_BOOLEAN + ); + + /* Create the treeview */ + treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(dialog->model)); + dialog->treeview = treeview; + gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(treeview), TRUE); + + sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview)); + gtk_tree_selection_set_mode(sel, GTK_SELECTION_MULTIPLE); + g_signal_connect(G_OBJECT(sel), "changed", + G_CALLBACK(pounce_selected_cb), dialog); + + /* Handle double-clicking */ + g_signal_connect(G_OBJECT(treeview), "button_press_event", + G_CALLBACK(pounce_double_click_cb), dialog); + + + gtk_container_add(GTK_CONTAINER(sw), treeview); + gtk_widget_show(treeview); + + /* Pouncee Column */ + column = gtk_tree_view_column_new(); + gtk_tree_view_column_set_title(column, _("Pounce Target")); + gtk_tree_view_column_set_resizable(column, TRUE); + gtk_tree_view_column_set_min_width(column, 200); + gtk_tree_view_column_set_sort_column_id(column, + POUNCES_MANAGER_COLUMN_TARGET); + gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column); + + /* Icon */ + renderer = gtk_cell_renderer_pixbuf_new(); + gtk_tree_view_column_pack_start(column, renderer, FALSE); + gtk_tree_view_column_add_attribute(column, renderer, "pixbuf", + POUNCES_MANAGER_COLUMN_ICON); + + /* Pouncee */ + renderer = gtk_cell_renderer_text_new(); + gtk_tree_view_column_pack_start(column, renderer, TRUE); + gtk_tree_view_column_add_attribute(column, renderer, "text", + POUNCES_MANAGER_COLUMN_TARGET); + + + /* Account Column */ + column = gtk_tree_view_column_new(); + gtk_tree_view_column_set_title(column, _("Account")); + gtk_tree_view_column_set_resizable(column, TRUE); + gtk_tree_view_column_set_min_width(column, 200); + gtk_tree_view_column_set_sort_column_id(column, + POUNCES_MANAGER_COLUMN_ACCOUNT); + gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column); + renderer = gtk_cell_renderer_text_new(); + gtk_tree_view_column_pack_start(column, renderer, TRUE); + gtk_tree_view_column_add_attribute(column, renderer, "text", + POUNCES_MANAGER_COLUMN_ACCOUNT); + + /* Recurring Column */ + renderer = gtk_cell_renderer_toggle_new(); + column = gtk_tree_view_column_new_with_attributes(_("Recurring"), renderer, + "active", POUNCES_MANAGER_COLUMN_RECURRING, NULL); + gtk_tree_view_column_set_sort_column_id(column, + POUNCES_MANAGER_COLUMN_RECURRING); + gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column); + g_signal_connect(G_OBJECT(renderer), "toggled", + G_CALLBACK(pounces_manager_recurring_cb), dialog); + + /* Enable CTRL+F searching */ + gtk_tree_view_set_search_column(GTK_TREE_VIEW(treeview), POUNCES_MANAGER_COLUMN_TARGET); + gtk_tree_view_set_search_equal_func(GTK_TREE_VIEW(treeview), search_func, NULL, NULL); + + /* Sort the pouncee column by default */ + gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(dialog->model), + POUNCES_MANAGER_COLUMN_TARGET, + GTK_SORT_ASCENDING); + + /* Populate list */ + populate_pounces_list(dialog); + + return sw; +} + +void +gaim_gtk_pounces_manager_show(void) +{ + PouncesManager *dialog; + GtkWidget *bbox; + GtkWidget *button; + GtkWidget *list; + GtkWidget *vbox; + GtkWidget *win; + int width, height; + + if (pounces_manager != NULL) { + gtk_window_present(GTK_WINDOW(pounces_manager->window)); + return; + } + + pounces_manager = dialog = g_new0(PouncesManager, 1); + + width = gaim_prefs_get_int("/gaim/gtk/pounces/dialog/width"); + height = gaim_prefs_get_int("/gaim/gtk/pounces/dialog/height"); + + dialog->window = win = gtk_window_new(GTK_WINDOW_TOPLEVEL); + gtk_window_set_default_size(GTK_WINDOW(win), width, height); + gtk_window_set_role(GTK_WINDOW(win), "pounces"); + gtk_window_set_title(GTK_WINDOW(win), _("Buddy Pounces")); + gtk_container_set_border_width(GTK_CONTAINER(win), GAIM_HIG_BORDER); + + g_signal_connect(G_OBJECT(win), "delete_event", + G_CALLBACK(pounces_manager_destroy_cb), dialog); + g_signal_connect(G_OBJECT(win), "configure_event", + G_CALLBACK(pounces_manager_configure_cb), dialog); + + /* Setup the vbox */ + vbox = gtk_vbox_new(FALSE, GAIM_HIG_BORDER); + gtk_container_add(GTK_CONTAINER(win), vbox); + gtk_widget_show(vbox); + + /* List of saved buddy pounces */ + list = create_pounces_list(dialog); + gtk_box_pack_start(GTK_BOX(vbox), list, TRUE, TRUE, 0); + + /* Button box. */ + bbox = gtk_hbutton_box_new(); + gtk_box_set_spacing(GTK_BOX(bbox), GAIM_HIG_BOX_SPACE); + gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END); + gtk_box_pack_end(GTK_BOX(vbox), bbox, FALSE, TRUE, 0); + gtk_widget_show(bbox); + + /* Add button */ + button = gtk_button_new_from_stock(GTK_STOCK_ADD); + gtk_box_pack_start(GTK_BOX(bbox), button, FALSE, FALSE, 0); + gtk_widget_set_sensitive(button, (gaim_accounts_get_all() != NULL)); + gaim_signal_connect(gaim_connections_get_handle(), "signed-on", + pounces_manager, GAIM_CALLBACK(pounces_manager_connection_cb), button); + gaim_signal_connect(gaim_connections_get_handle(), "signed-off", + pounces_manager, GAIM_CALLBACK(pounces_manager_connection_cb), button); + gtk_widget_show(button); + + g_signal_connect(G_OBJECT(button), "clicked", + G_CALLBACK(pounces_manager_add_cb), dialog); + + /* Modify button */ + button = gtk_button_new_from_stock(GAIM_STOCK_MODIFY); + dialog->modify_button = button; + gtk_box_pack_start(GTK_BOX(bbox), button, FALSE, FALSE, 0); + gtk_widget_set_sensitive(button, FALSE); + gtk_widget_show(button); + + g_signal_connect(G_OBJECT(button), "clicked", + G_CALLBACK(pounces_manager_modify_cb), dialog); + + /* Delete button */ + button = gtk_button_new_from_stock(GTK_STOCK_DELETE); + dialog->delete_button = button; + gtk_box_pack_start(GTK_BOX(bbox), button, FALSE, FALSE, 0); + gtk_widget_set_sensitive(button, FALSE); + gtk_widget_show(button); + + g_signal_connect(G_OBJECT(button), "clicked", + G_CALLBACK(pounces_manager_delete_cb), dialog); + + /* Close button */ + button = gtk_button_new_from_stock(GTK_STOCK_CLOSE); + gtk_box_pack_start(GTK_BOX(bbox), button, FALSE, FALSE, 0); + gtk_widget_show(button); + + g_signal_connect(G_OBJECT(button), "clicked", + G_CALLBACK(pounces_manager_close_cb), dialog); + + gtk_widget_show(win); +} + +void +gaim_gtk_pounces_manager_hide(void) +{ + if (pounces_manager == NULL) + return; + + if (pounces_manager->window != NULL) + gtk_widget_destroy(pounces_manager->window); + + gaim_signals_disconnect_by_handle(pounces_manager); + + g_free(pounces_manager); + pounces_manager = NULL; +} + +static void +pounce_cb(GaimPounce *pounce, GaimPounceEvent events, void *data) +{ + GaimConversation *conv; + GaimAccount *account; + GaimBuddy *buddy; + const char *pouncee; + const char *alias; + + pouncee = gaim_pounce_get_pouncee(pounce); + account = gaim_pounce_get_pouncer(pounce); + + buddy = gaim_find_buddy(account, pouncee); + if (buddy != NULL) + { + alias = gaim_buddy_get_alias(buddy); + if (alias == NULL) + alias = pouncee; + } + else + alias = pouncee; + + if (gaim_pounce_action_is_enabled(pounce, "open-window")) + { + conv = gaim_find_conversation_with_account(GAIM_CONV_TYPE_IM, pouncee, account); + + if (conv == NULL) + conv = gaim_conversation_new(GAIM_CONV_TYPE_IM, account, pouncee); + } + + if (gaim_pounce_action_is_enabled(pounce, "popup-notify")) + { + char *tmp; + const char *name_shown; + const char *reason; + reason = gaim_pounce_action_get_attribute(pounce, "popup-notify", + "reason"); + + /* + * Here we place the protocol name in the pounce dialog to lessen + * confusion about what protocol a pounce is for. + */ + tmp = g_strdup_printf( + (events & GAIM_POUNCE_TYPING) ? + _("%s has started typing to you (%s)") : + (events & GAIM_POUNCE_TYPED) ? + _("%s has paused while typing to you (%s)") : + (events & GAIM_POUNCE_SIGNON) ? + _("%s has signed on (%s)") : + (events & GAIM_POUNCE_IDLE_RETURN) ? + _("%s has returned from being idle (%s)") : + (events & GAIM_POUNCE_AWAY_RETURN) ? + _("%s has returned from being away (%s)") : + (events & GAIM_POUNCE_TYPING_STOPPED) ? + _("%s has stopped typing to you (%s)") : + (events & GAIM_POUNCE_SIGNOFF) ? + _("%s has signed off (%s)") : + (events & GAIM_POUNCE_IDLE) ? + _("%s has become idle (%s)") : + (events & GAIM_POUNCE_AWAY) ? + _("%s has gone away. (%s)") : + (events & GAIM_POUNCE_MESSAGE_RECEIVED) ? + _("%s has sent you a message. (%s)") : + _("Unknown pounce event. Please report this!"), + alias, gaim_account_get_protocol_name(account)); + + /* + * Ok here is where I change the second argument, title, from + * NULL to the account alias if we have it or the account + * name if that's all we have + */ + if ((name_shown = gaim_account_get_alias(account)) == NULL) + name_shown = gaim_account_get_username(account); + + if (reason == NULL) + { + gaim_notify_info(NULL, name_shown, tmp, gaim_date_format_full(NULL)); + } + else + { + char *tmp2 = g_strdup_printf("%s\n\n%s", reason, gaim_date_format_full(NULL)); + gaim_notify_info(NULL, name_shown, tmp, tmp2); + g_free(tmp2); + } + g_free(tmp); + } + + if (gaim_pounce_action_is_enabled(pounce, "send-message")) + { + const char *message; + + message = gaim_pounce_action_get_attribute(pounce, "send-message", + "message"); + + if (message != NULL) + { + conv = gaim_find_conversation_with_account(GAIM_CONV_TYPE_IM, pouncee, account); + + if (conv == NULL) + conv = gaim_conversation_new(GAIM_CONV_TYPE_IM, account, pouncee); + + gaim_conversation_write(conv, NULL, message, + GAIM_MESSAGE_SEND, time(NULL)); + + serv_send_im(account->gc, (char *)pouncee, (char *)message, 0); + } + } + + if (gaim_pounce_action_is_enabled(pounce, "execute-command")) + { + const char *command; + + command = gaim_pounce_action_get_attribute(pounce, + "execute-command", "command"); + + if (command != NULL) + { +#ifndef _WIN32 + char *localecmd = g_locale_from_utf8(command, -1, NULL, + NULL, NULL); + + if (localecmd != NULL) + { + int pid = fork(); + + if (pid == 0) { + char *args[4]; + + args[0] = "sh"; + args[1] = "-c"; + args[2] = (char *)localecmd; + args[3] = NULL; + + execvp(args[0], args); + + _exit(0); + } + g_free(localecmd); + } +#else /* !_WIN32 */ + PROCESS_INFORMATION pi; + BOOL retval; + gchar *message = NULL; + + memset(&pi, 0, sizeof(pi)); + + if (G_WIN32_HAVE_WIDECHAR_API ()) { + STARTUPINFOW si; + wchar_t *wc_cmd = g_utf8_to_utf16(command, + -1, NULL, NULL, NULL); + + memset(&si, 0 , sizeof(si)); + si.cb = sizeof(si); + + retval = CreateProcessW(NULL, wc_cmd, NULL, + NULL, 0, 0, NULL, NULL, + &si, &pi); + g_free(wc_cmd); + } else { + STARTUPINFOA si; + char *l_cmd = g_locale_from_utf8(command, + -1, NULL, NULL, NULL); + + memset(&si, 0 , sizeof(si)); + si.cb = sizeof(si); + + retval = CreateProcessA(NULL, l_cmd, NULL, + NULL, 0, 0, NULL, NULL, + &si, &pi); + g_free(l_cmd); + } + + if (retval) { + CloseHandle(pi.hProcess); + CloseHandle(pi.hThread); + } else { + message = g_win32_error_message(GetLastError()); + } + + gaim_debug_info("pounce", + "Pounce execute command called for: " + "%s\n%s%s%s", + command, + retval ? "" : "Error: ", + retval ? "" : message, + retval ? "" : "\n"); + g_free(message); +#endif /* !_WIN32 */ + } + } + + if (gaim_pounce_action_is_enabled(pounce, "play-sound")) + { + const char *sound; + + sound = gaim_pounce_action_get_attribute(pounce, + "play-sound", "filename"); + + if (sound != NULL) + gaim_sound_play_file(sound, account); + else + gaim_sound_play_event(GAIM_SOUND_POUNCE_DEFAULT, account); + } +} + +static void +free_pounce(GaimPounce *pounce) +{ + update_pounces(); +} + +static void +new_pounce(GaimPounce *pounce) +{ + gaim_pounce_action_register(pounce, "open-window"); + gaim_pounce_action_register(pounce, "popup-notify"); + gaim_pounce_action_register(pounce, "send-message"); + gaim_pounce_action_register(pounce, "execute-command"); + gaim_pounce_action_register(pounce, "play-sound"); + + update_pounces(); +} + +void * +gaim_gtk_pounces_get_handle() { + static int handle; + + return &handle; +} + +void +gaim_gtk_pounces_init(void) +{ + gaim_pounces_register_handler(GAIM_GTK_UI, pounce_cb, new_pounce, + free_pounce); + + gaim_prefs_add_none("/gaim/gtk/pounces"); + gaim_prefs_add_none("/gaim/gtk/pounces/default_actions"); + gaim_prefs_add_bool("/gaim/gtk/pounces/default_actions/open-window", + FALSE); + gaim_prefs_add_bool("/gaim/gtk/pounces/default_actions/popup-notify", + TRUE); + gaim_prefs_add_bool("/gaim/gtk/pounces/default_actions/send-message", + FALSE); + gaim_prefs_add_bool("/gaim/gtk/pounces/default_actions/execute-command", + FALSE); + gaim_prefs_add_bool("/gaim/gtk/pounces/default_actions/play-sound", + FALSE); + gaim_prefs_add_none("/gaim/gtk/pounces/dialog"); + gaim_prefs_add_int("/gaim/gtk/pounces/dialog/width", 520); + gaim_prefs_add_int("/gaim/gtk/pounces/dialog/height", 321); + + gaim_signal_connect(gaim_connections_get_handle(), "signed-on", + gaim_gtk_pounces_get_handle(), + GAIM_CALLBACK(signed_on_off_cb), NULL); + gaim_signal_connect(gaim_connections_get_handle(), "signed-off", + gaim_gtk_pounces_get_handle(), + GAIM_CALLBACK(signed_on_off_cb), NULL); +}