?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Adapt migration for files
[pidgin-git.git] / finch / gntconv.c
blobe2d2740b3c5623b9d756e667f7f32ab5bdef4e57
1 /* finch
2 *
3 * Finch is the legal property of its developers, whose names are too numerous
4 * to list here. Please refer to the COPYRIGHT file distributed with this
5 * source distribution.
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
20 */
21
22 #include <internal.h>
23 #include "finch.h"
24
25 #include <cmds.h>
26 #include <core.h>
27 #include <idle.h>
28 #include <prefs.h>
29 #include <util.h>
30
31 #include "gntaccount.h"
32 #include "gntblist.h"
33 #include "gntconv.h"
34 #include "gntdebug.h"
35 #include "gntlog.h"
36 #include "gntplugin.h"
37 #include "gntpounce.h"
38 #include "gntprefs.h"
39 #include "gntrequest.h"
40 #include "gntsound.h"
41 #include "gntstatus.h"
42
43 #include "gnt.h"
44 #include "gntbox.h"
45 #include "gntentry.h"
46 #include "gntlabel.h"
47 #include "gntmenu.h"
48 #include "gntmenuitem.h"
49 #include "gntmenuitemcheck.h"
50 #include "gntmenuutil.h"
51 #include "gntstyle.h"
52 #include "gnttextview.h"
53 #include "gnttree.h"
54 #include "gntutils.h"
55 #include "gntwindow.h"
56
57 #define PREF_ROOT "/finch/conversations"
58 #define PREF_CHAT PREF_ROOT "/chats"
59 #define PREF_USERLIST PREF_CHAT "/userlist"
60
61 #include "config.h"
62
63 static void generate_send_to_menu(FinchConv *ggc);
64 static void generate_e2ee_menu(FinchConv *ggc);
65
66 static int color_message_receive;
67 static int color_message_send;
68 static int color_message_highlight;
69 static int color_message_action;
70 static int color_timestamp;
71
72 static PurpleBuddy *
73 find_buddy_for_conversation(PurpleConversation *conv)
74 {
75 return purple_blist_find_buddy(purple_conversation_get_account(conv),
76 purple_conversation_get_name(conv));
77 }
78
79 static PurpleChat *
80 find_chat_for_conversation(PurpleConversation *conv)
81 {
82 return purple_blist_find_chat(purple_conversation_get_account(conv),
83 purple_conversation_get_name(conv));
84 }
85
86 static PurpleBlistNode *
87 get_conversation_blist_node(PurpleConversation *conv)
88 {
89 PurpleBlistNode *node = NULL;
90
91 if (PURPLE_IS_IM_CONVERSATION(conv)) {
92 node = (PurpleBlistNode*)find_buddy_for_conversation(conv);
93 node = node ? purple_blist_node_get_parent(node) : NULL;
94 } else if (PURPLE_IS_CHAT_CONVERSATION(conv)) {
95 node = (PurpleBlistNode*)find_chat_for_conversation(conv);
96 }
97
98 return node;
99 }
100
101 static void
102 send_typing_notification(GntWidget *w, FinchConv *ggconv)
103 {
104 const char *text = gnt_entry_get_text(GNT_ENTRY(ggconv->entry));
105 gboolean empty = (!text || !*text || (*text == '/'));
106 if (purple_prefs_get_bool("/finch/conversations/notify_typing")) {
107 PurpleConversation *conv = ggconv->active_conv;
108 PurpleIMConversation *im = PURPLE_IM_CONVERSATION(conv);
109 if (!empty) {
110 gboolean send = (purple_im_conversation_get_send_typed_timeout(im) == 0);
111
112 purple_im_conversation_stop_send_typed_timeout(im);
113 purple_im_conversation_start_send_typed_timeout(im);
114 if (send || (purple_im_conversation_get_type_again(im) != 0 &&
115 time(NULL) > purple_im_conversation_get_type_again(im))) {
116 unsigned int timeout;
117 timeout = purple_serv_send_typing(purple_conversation_get_connection(conv),
118 purple_conversation_get_name(conv),
119 PURPLE_IM_TYPING);
120 purple_im_conversation_set_type_again(im, timeout);
121 }
122 } else {
123 purple_im_conversation_stop_send_typed_timeout(im);
124
125 purple_serv_send_typing(purple_conversation_get_connection(conv),
126 purple_conversation_get_name(conv),
127 PURPLE_IM_NOT_TYPING);
128 }
129 }
130 }
131
132 static void
133 entry_key_pressed(GntWidget *w, FinchConv *ggconv)
134 {
135 const char *text = gnt_entry_get_text(GNT_ENTRY(ggconv->entry));
136 if (*text == '/' && *(text + 1) != '/')
137 {
138 PurpleConversation *conv = ggconv->active_conv;
139 PurpleCmdStatus status;
140 const char *cmdline = text + 1;
141 char *error = NULL, *escape;
142
143 escape = g_markup_escape_text(cmdline, -1);
144 status = purple_cmd_do_command(conv, cmdline, escape, &error);
145 g_free(escape);
146
147 switch (status)
148 {
149 case PURPLE_CMD_STATUS_OK:
150 break;
151 case PURPLE_CMD_STATUS_NOT_FOUND:
152 purple_conversation_write_system_message(conv,
153 _("No such command."), PURPLE_MESSAGE_NO_LOG);
154 break;
155 case PURPLE_CMD_STATUS_WRONG_ARGS:
156 purple_conversation_write_system_message(conv,
157 _("Syntax Error: You typed the wrong "
158 "number of arguments to that command."),
159 PURPLE_MESSAGE_NO_LOG);
160 break;
161 case PURPLE_CMD_STATUS_FAILED:
162 purple_conversation_write_system_message(conv,
163 error ? error : _("Your command failed for an unknown reason."),
164 PURPLE_MESSAGE_NO_LOG);
165 break;
166 case PURPLE_CMD_STATUS_WRONG_TYPE:
167 if(PURPLE_IS_IM_CONVERSATION(conv))
168 purple_conversation_write_system_message(conv,
169 _("That command only works in chats, not IMs."),
170 PURPLE_MESSAGE_NO_LOG);
171 else
172 purple_conversation_write_system_message(conv,
173 _("That command only works in IMs, not chats."),
174 PURPLE_MESSAGE_NO_LOG);
175 break;
176 case PURPLE_CMD_STATUS_WRONG_PROTOCOL:
177 purple_conversation_write_system_message(conv,
178 _("That command doesn't work on this protocol."),
179 PURPLE_MESSAGE_NO_LOG);
180 break;
181 }
182 g_free(error);
183 }
184 else if (!purple_account_is_connected(purple_conversation_get_account(ggconv->active_conv)))
185 {
186 purple_conversation_write_system_message(ggconv->active_conv,
187 _("Message was not sent, because you are not signed on."),
188 PURPLE_MESSAGE_ERROR | PURPLE_MESSAGE_NO_LOG);
189 }
190 else
191 {
192 char *escape = purple_markup_escape_text((*text == '/' ? text + 1 : text), -1);
193 purple_conversation_send(ggconv->active_conv, escape);
194 g_free(escape);
195 purple_idle_touch();
196 }
197 gnt_entry_add_to_history(GNT_ENTRY(ggconv->entry), text);
198 gnt_entry_clear(GNT_ENTRY(ggconv->entry));
199 }
200
201 static void
202 closing_window(GntWidget *window, FinchConv *ggconv)
203 {
204 GList *list = ggconv->list;
205 ggconv->window = NULL;
206 while (list) {
207 PurpleConversation *conv = list->data;
208 list = list->next;
209 g_object_unref(conv);
210 }
211 }
212
213 static void
214 size_changed_cb(GntWidget *widget, int width, int height)
215 {
216 int w, h;
217 gnt_widget_get_size(widget, &w, &h);
218 purple_prefs_set_int(PREF_ROOT "/size/width", w);
219 purple_prefs_set_int(PREF_ROOT "/size/height", h);
220 }
221
222 static void
223 save_position_cb(GntWidget *w, int x, int y)
224 {
225 purple_prefs_set_int(PREF_ROOT "/position/x", x);
226 purple_prefs_set_int(PREF_ROOT "/position/y", y);
227 }
228
229 static PurpleIMConversation *
230 find_im_with_contact(PurpleAccount *account, const char *name)
231 {
232 PurpleBlistNode *node;
233 PurpleBuddy *buddy = purple_blist_find_buddy(account, name);
234 PurpleIMConversation *im = NULL;
235
236 if (!buddy)
237 return NULL;
238
239 for (node = purple_blist_node_get_first_child(purple_blist_node_get_parent((PurpleBlistNode*)buddy));
240 node; node = purple_blist_node_get_sibling_next(node)) {
241 if (node == (PurpleBlistNode*)buddy)
242 continue;
243 if ((im = purple_conversations_find_im_with_account(
244 purple_buddy_get_name((PurpleBuddy*)node), purple_buddy_get_account((PurpleBuddy*)node))) != NULL)
245 break;
246 }
247 return im;
248 }
249
250 static char *
251 get_conversation_title(PurpleConversation *conv, PurpleAccount *account)
252 {
253 PurpleE2eeState *e2ee;
254
255 e2ee = purple_conversation_get_e2ee_state(conv);
256
257 return g_strdup_printf(_("%s (%s -- %s)%s%s%s%s"),
258 purple_conversation_get_title(conv),
259 purple_account_get_username(account),
260 purple_account_get_protocol_name(account),
261 e2ee ? " | " : "",
262 e2ee ? purple_e2ee_provider_get_name(purple_e2ee_state_get_provider(e2ee)) : "",
263 e2ee ? ": " : "",
264 e2ee ? purple_e2ee_state_get_name(e2ee) : "");
265 }
266
267 static void
268 update_buddy_typing(PurpleAccount *account, const char *who, gpointer null)
269 {
270 FinchConv *ggc;
271 PurpleIMConversation *im;
272 PurpleConversation *conv;
273 char *title, *str;
274
275 im = purple_conversations_find_im_with_account(who, account);
276
277 if (!im)
278 return;
279
280 conv = PURPLE_CONVERSATION(im);
281 ggc = FINCH_CONV(conv);
282
283 if (purple_im_conversation_get_typing_state(im) == PURPLE_IM_TYPING) {
284 int scroll;
285 str = get_conversation_title(conv, account);
286 title = g_strdup_printf(_("%s [%s]"), str,
287 gnt_ascii_only() ? "T" : "\342\243\277");
288 g_free(str);
289
290 scroll = gnt_text_view_get_lines_below(GNT_TEXT_VIEW(ggc->tv));
291 str = g_strdup_printf(_("\n%s is typing..."), purple_conversation_get_title(conv));
292 /* Updating is a little buggy. So just remove and add a new one */
293 gnt_text_view_tag_change(GNT_TEXT_VIEW(ggc->tv), "typing", NULL, TRUE);
294 gnt_text_view_append_text_with_tag(GNT_TEXT_VIEW(ggc->tv),
295 str, GNT_TEXT_FLAG_DIM, "typing");
296 g_free(str);
297 if (scroll <= 1)
298 gnt_text_view_scroll(GNT_TEXT_VIEW(ggc->tv), 0);
299 } else {
300 title = get_conversation_title(conv, account);
301 gnt_text_view_tag_change(GNT_TEXT_VIEW(ggc->tv), "typing", " ", TRUE);
302 }
303 gnt_screen_rename_widget(ggc->window, title);
304 g_free(title);
305 }
306
307 static void
308 chat_left_cb(PurpleConversation *conv, gpointer null)
309 {
310 purple_conversation_write_system_message(conv,
311 _("You have left this chat."), 0);
312 }
313
314 static void
315 buddy_signed_on_off(PurpleBuddy *buddy, gpointer null)
316 {
317 PurpleIMConversation *im = find_im_with_contact(purple_buddy_get_account(buddy), purple_buddy_get_name(buddy));
318 if (im == NULL)
319 return;
320 generate_send_to_menu(FINCH_CONV(PURPLE_CONVERSATION(im)));
321 }
322
323 static void
324 account_signed_on_off(PurpleConnection *gc, gpointer null)
325 {
326 GList *list = purple_conversations_get_ims();
327 while (list) {
328 PurpleConversation *conv = list->data;
329 PurpleIMConversation *cc = find_im_with_contact(
330 purple_conversation_get_account(conv), purple_conversation_get_name(conv));
331 if (cc)
332 generate_send_to_menu(FINCH_CONV(PURPLE_CONVERSATION(cc)));
333 list = list->next;
334 }
335
336 if (PURPLE_CONNECTION_IS_CONNECTED(gc)) {
337 /* We just signed on. Let's see if there's any chat that we have open,
338 * and hadn't left before the disconnect. */
339 list = purple_conversations_get_chats();
340 while (list) {
341 PurpleConversation *conv = list->data;
342 PurpleChat *chat;
343 GHashTable *comps = NULL;
344
345 list = list->next;
346 if (purple_conversation_get_account(conv) != purple_connection_get_account(gc) ||
347 !g_object_get_data(G_OBJECT(conv), "want-to-rejoin"))
348 continue;
349
350 chat = find_chat_for_conversation(conv);
351 if (chat == NULL) {
352 PurpleProtocol *protocol = purple_connection_get_protocol(gc);
353 comps = purple_protocol_chat_iface_info_defaults(protocol, gc,
354 purple_conversation_get_name(conv));
355 } else {
356 comps = purple_chat_get_components(chat);
357 }
358 purple_serv_join_chat(gc, comps);
359 if (chat == NULL && comps != NULL)
360 g_hash_table_destroy(comps);
361 }
362 }
363 }
364
365 static void
366 account_signing_off(PurpleConnection *gc)
367 {
368 GList *list = purple_conversations_get_chats();
369 PurpleAccount *account = purple_connection_get_account(gc);
370
371 /* We are about to sign off. See which chats we are currently in, and mark
372 * them for rejoin on reconnect. */
373 while (list) {
374 PurpleConversation *conv = list->data;
375 if (!purple_chat_conversation_has_left(PURPLE_CHAT_CONVERSATION(conv)) &&
376 purple_conversation_get_account(conv) == account) {
377 g_object_set_data(G_OBJECT(conv), "want-to-rejoin", GINT_TO_POINTER(TRUE));
378 purple_conversation_write_system_message(conv,
379 _("The account has disconnected and you are no "
380 "longer in this chat. You will be automatically rejoined in the chat when "
381 "the account reconnects."),
382 PURPLE_MESSAGE_NO_LOG);
383 }
384 list = list->next;
385 }
386 }
387
388 static gpointer
389 finch_conv_get_handle(void)
390 {
391 static int handle;
392 return &handle;
393 }
394
395 static void
396 cleared_message_history_cb(PurpleConversation *conv, gpointer data)
397 {
398 FinchConv *ggc = FINCH_CONV(conv);
399 if (ggc)
400 gnt_text_view_clear(GNT_TEXT_VIEW(ggc->tv));
401 }
402
403 static void
404 gg_extended_menu(FinchConv *ggc)
405 {
406 GntMenu *sub;
407 GList *list;
408 gboolean is_empty = TRUE;
409
410 g_return_if_fail(ggc != NULL);
411
412 sub = GNT_MENU(gnt_menu_new(GNT_MENU_POPUP));
413 gnt_menuitem_set_submenu(ggc->plugins, sub);
414
415 for (list = purple_conversation_get_extended_menu(ggc->active_conv);
416 list; list = g_list_delete_link(list, list))
417 {
418 finch_append_menu_action(sub, list->data, ggc->active_conv);
419 is_empty = FALSE;
420 }
421 gnt_menuitem_set_visible(ggc->plugins, !is_empty);
422 }
423
424 static void
425 conv_updated(PurpleConversation *conv, PurpleConversationUpdateType type)
426 {
427 if (purple_conversation_get_ui_data(conv) == NULL)
428 return;
429
430 if (type == PURPLE_CONVERSATION_UPDATE_FEATURES) {
431 gg_extended_menu(purple_conversation_get_ui_data(conv));
432 return;
433 }
434 if (type == PURPLE_CONVERSATION_UPDATE_E2EE) {
435 FinchConv *ggconv = FINCH_CONV(conv);
436 gchar *title;
437
438 title = get_conversation_title(conv,
439 purple_conversation_get_account(conv));
440 gnt_screen_rename_widget(ggconv->window, title);
441 g_free(title);
442
443 generate_e2ee_menu(ggconv);
444
445 return;
446 }
447 }
448
449 static void
450 clear_scrollback_cb(GntMenuItem *item, gpointer ggconv)
451 {
452 FinchConv *ggc = ggconv;
453 purple_conversation_clear_message_history(ggc->active_conv);
454 }
455
456 static void
457 send_file_cb(GntMenuItem *item, gpointer ggconv)
458 {
459 FinchConv *ggc = ggconv;
460 purple_serv_send_file(purple_conversation_get_connection(ggc->active_conv),
461 purple_conversation_get_name(ggc->active_conv), NULL);
462 }
463
464 static void
465 add_pounce_cb(GntMenuItem *item, gpointer ggconv)
466 {
467 FinchConv *ggc = ggconv;
468 finch_pounce_editor_show(
469 purple_conversation_get_account(ggc->active_conv),
470 purple_conversation_get_name(ggc->active_conv), NULL);
471 }
472
473 static void
474 get_info_cb(GntMenuItem *item, gpointer ggconv)
475 {
476 FinchConv *ggc = ggconv;
477 finch_retrieve_user_info(purple_conversation_get_connection(ggc->active_conv),
478 purple_conversation_get_name(ggc->active_conv));
479 }
480
481 static void
482 toggle_timestamps_cb(GntMenuItem *item, gpointer ggconv)
483 {
484 purple_prefs_set_bool(PREF_ROOT "/timestamps",
485 !purple_prefs_get_bool(PREF_ROOT "/timestamps"));
486 }
487
488 static void
489 toggle_logging_cb(GntMenuItem *item, gpointer ggconv)
490 {
491 FinchConv *fc = ggconv;
492 PurpleConversation *conv = fc->active_conv;
493 gboolean logging = gnt_menuitem_check_get_checked(GNT_MENU_ITEM_CHECK(item));
494 GList *iter;
495
496 if (logging == purple_conversation_is_logging(conv))
497 return;
498
499 /* Xerox */
500 if (logging) {
501 /* Enable logging first so the message below can be logged. */
502 purple_conversation_set_logging(conv, TRUE);
503
504 purple_conversation_write_system_message(conv,
505 _("Logging started. Future messages in this "
506 "conversation will be logged."), 0);
507 } else {
508 purple_conversation_write_system_message(conv,
509 _("Logging stopped. Future messages in this "
510 "conversation will not be logged."), 0);
511
512 /* Disable the logging second, so that the above message can be logged. */
513 purple_conversation_set_logging(conv, FALSE);
514 }
515
516 /* Each conversation with the same person will have the same logging setting */
517 for (iter = fc->list; iter; iter = iter->next) {
518 if (iter->data == conv)
519 continue;
520 purple_conversation_set_logging(iter->data, logging);
521 }
522 }
523
524 static void
525 toggle_sound_cb(GntMenuItem *item, gpointer ggconv)
526 {
527 FinchConv *fc = ggconv;
528 PurpleBlistNode *node = get_conversation_blist_node(fc->active_conv);
529 fc->flags ^= FINCH_CONV_NO_SOUND;
530 if (node)
531 purple_blist_node_set_bool(node, "gnt-mute-sound", !!(fc->flags & FINCH_CONV_NO_SOUND));
532 }
533
534 static void
535 send_to_cb(GntMenuItem *m, gpointer n)
536 {
537 PurpleAccount *account = g_object_get_data(G_OBJECT(m), "purple_account");
538 gchar *buddy = g_object_get_data(G_OBJECT(m), "purple_buddy_name");
539 PurpleIMConversation *im = purple_im_conversation_new(account, buddy);
540 finch_conversation_set_active(PURPLE_CONVERSATION(im));
541 }
542
543 static void
544 view_log_cb(GntMenuItem *n, gpointer ggc)
545 {
546 FinchConv *fc;
547 PurpleConversation *conv;
548 PurpleLogType type;
549 const char *name;
550 PurpleAccount *account;
551 GSList *buddies;
552 GSList *cur;
553
554 fc = ggc;
555 conv = fc->active_conv;
556
557 if (PURPLE_IS_IM_CONVERSATION(conv))
558 type = PURPLE_LOG_IM;
559 else if (PURPLE_IS_CHAT_CONVERSATION(conv))
560 type = PURPLE_LOG_CHAT;
561 else
562 return;
563
564 name = purple_conversation_get_name(conv);
565 account = purple_conversation_get_account(conv);
566
567 buddies = purple_blist_find_buddies(account, name);
568 for (cur = buddies; cur != NULL; cur = cur->next) {
569 PurpleBlistNode *node = cur->data;
570 if ((node != NULL) &&
571 (purple_blist_node_get_sibling_prev(node) || purple_blist_node_get_sibling_next(node))) {
572 finch_log_show_contact((PurpleContact *)purple_blist_node_get_parent(node));
573 g_slist_free(buddies);
574 return;
575 }
576 }
577 g_slist_free(buddies);
578
579 finch_log_show(type, name, account);
580 }
581
582 static void
583 generate_send_to_menu(FinchConv *ggc)
584 {
585 GntWidget *sub, *menu = ggc->menu;
586 GntMenuItem *item;
587 GSList *buds;
588 GList *list = NULL;
589
590 buds = purple_blist_find_buddies(purple_conversation_get_account(ggc->active_conv),
591 purple_conversation_get_name(ggc->active_conv));
592 if (!buds)
593 return;
594
595 if ((item = ggc->u.im->sendto) == NULL) {
596 item = gnt_menuitem_new(_("Send To"));
597 gnt_menu_add_item(GNT_MENU(menu), item);
598 ggc->u.im->sendto = item;
599 }
600 sub = gnt_menu_new(GNT_MENU_POPUP);
601 gnt_menuitem_set_submenu(item, GNT_MENU(sub));
602
603 for (; buds; buds = g_slist_delete_link(buds, buds)) {
604 PurpleBlistNode *node = PURPLE_BLIST_NODE(purple_buddy_get_contact(PURPLE_BUDDY(buds->data)));
605 for (node = purple_blist_node_get_first_child(node); node != NULL;
606 node = purple_blist_node_get_sibling_next(node)) {
607 PurpleBuddy *buddy = (PurpleBuddy *)node;
608 PurpleAccount *account = purple_buddy_get_account(buddy);
609 if (purple_account_is_connected(account)) {
610 /* Use the PurplePresence to get unique buddies. */
611 PurplePresence *presence = purple_buddy_get_presence(buddy);
612 if (!g_list_find(list, presence))
613 list = g_list_prepend(list, presence);
614 }
615 }
616 }
617 for (list = g_list_reverse(list); list != NULL; list = g_list_delete_link(list, list)) {
618 PurplePresence *pre = list->data;
619 PurpleBuddy *buddy = purple_buddy_presence_get_buddy(PURPLE_BUDDY_PRESENCE(pre));
620 PurpleAccount *account = purple_buddy_get_account(buddy);
621 gchar *name = g_strdup(purple_buddy_get_name(buddy));
622 gchar *text = g_strdup_printf("%s (%s)", purple_buddy_get_name(buddy), purple_account_get_username(account));
623 item = gnt_menuitem_new(text);
624 g_free(text);
625 gnt_menu_add_item(GNT_MENU(sub), item);
626 gnt_menuitem_set_callback(item, send_to_cb, NULL);
627 g_object_set_data(G_OBJECT(item), "purple_account", account);
628 g_object_set_data_full(G_OBJECT(item), "purple_buddy_name", name, g_free);
629 }
630 }
631
632 static void
633 generate_e2ee_menu(FinchConv *ggc)
634 {
635 GntMenu *sub;
636 GntWidget *menu = ggc->menu;
637 PurpleConversation *conv = ggc->active_conv;
638 GntMenuItem *item;
639 PurpleE2eeProvider *eprov;
640 GList *menu_actions, *it;
641
642 eprov = purple_e2ee_provider_get_main();
643
644 item = ggc->u.im->e2ee_menu;
645 if (item == NULL) {
646 item = gnt_menuitem_new(NULL);
647 gnt_menu_add_item(GNT_MENU(menu), item);
648 ggc->u.im->e2ee_menu = item;
649 }
650 sub = GNT_MENU(gnt_menu_new(GNT_MENU_POPUP));
651 gnt_menuitem_set_submenu(item, GNT_MENU(sub));
652
653 gnt_menuitem_set_visible(item, (eprov != NULL));
654 if (eprov == NULL)
655 return;
656 gnt_menuitem_set_text(item, purple_e2ee_provider_get_name(eprov));
657
658 menu_actions = purple_e2ee_provider_get_conv_menu_actions(eprov, conv);
659 for (it = menu_actions; it; it = g_list_next(it)) {
660 PurpleMenuAction *action = it->data;
661
662 finch_append_menu_action(sub, action, conv);
663 }
664 g_list_free(menu_actions);
665 }
666
667 static void
668 invite_cb(GntMenuItem *item, gpointer ggconv)
669 {
670 FinchConv *fc = ggconv;
671 PurpleChatConversation *chat = PURPLE_CHAT_CONVERSATION(fc->active_conv);
672 purple_chat_conversation_invite_user(chat, NULL, NULL, TRUE);
673 }
674
675 static void
676 plugin_changed_cb(PurplePlugin *p, gpointer data)
677 {
678 gg_extended_menu(data);
679 }
680
681 static void
682 gg_create_menu(FinchConv *ggc)
683 {
684 GntWidget *menu, *sub;
685 GntMenuItem *item;
686
687 ggc->menu = menu = gnt_menu_new(GNT_MENU_TOPLEVEL);
688 gnt_window_set_menu(GNT_WINDOW(ggc->window), GNT_MENU(menu));
689
690 item = gnt_menuitem_new(_("Conversation"));
691 gnt_menu_add_item(GNT_MENU(menu), item);
692
693 sub = gnt_menu_new(GNT_MENU_POPUP);
694 gnt_menuitem_set_submenu(item, GNT_MENU(sub));
695
696 item = gnt_menuitem_new(_("Clear Scrollback"));
697 gnt_menu_add_item(GNT_MENU(sub), item);
698 gnt_menuitem_set_callback(item, clear_scrollback_cb, ggc);
699
700 item = gnt_menuitem_check_new(_("Show Timestamps"));
701 gnt_menuitem_check_set_checked(GNT_MENU_ITEM_CHECK(item),
702 purple_prefs_get_bool(PREF_ROOT "/timestamps"));
703 gnt_menu_add_item(GNT_MENU(sub), item);
704 gnt_menuitem_set_callback(item, toggle_timestamps_cb, ggc);
705
706 if (PURPLE_IS_IM_CONVERSATION(ggc->active_conv)) {
707 PurpleAccount *account = purple_conversation_get_account(ggc->active_conv);
708 PurpleConnection *gc = purple_account_get_connection(account);
709 PurpleProtocol *protocol =
710 gc ? purple_connection_get_protocol(gc) : NULL;
711
712 if (protocol && PURPLE_PROTOCOL_IMPLEMENTS(protocol, SERVER_IFACE, get_info)) {
713 item = gnt_menuitem_new(_("Get Info"));
714 gnt_menu_add_item(GNT_MENU(sub), item);
715 gnt_menuitem_set_callback(item, get_info_cb, ggc);
716 }
717
718 item = gnt_menuitem_new(_("Add Buddy Pounce..."));
719 gnt_menu_add_item(GNT_MENU(sub), item);
720 gnt_menuitem_set_callback(item, add_pounce_cb, ggc);
721
722 if (protocol && PURPLE_PROTOCOL_IMPLEMENTS(protocol, XFER_IFACE, send) &&
723 (!PURPLE_PROTOCOL_IMPLEMENTS(protocol, XFER_IFACE, can_receive) ||
724 purple_protocol_xfer_iface_can_receive(protocol, gc,
725 purple_conversation_get_name(ggc->active_conv)))) {
726 item = gnt_menuitem_new(_("Send File"));
727 gnt_menu_add_item(GNT_MENU(sub), item);
728 gnt_menuitem_set_callback(item, send_file_cb, ggc);
729 }
730
731 generate_send_to_menu(ggc);
732 } else if (PURPLE_IS_CHAT_CONVERSATION(ggc->active_conv)) {
733 item = gnt_menuitem_new(_("Invite..."));
734 gnt_menu_add_item(GNT_MENU(sub), item);
735 gnt_menuitem_set_callback(item, invite_cb, ggc);
736 }
737
738 generate_e2ee_menu(ggc);
739
740 item = gnt_menuitem_new(_("View Log..."));
741 gnt_menu_add_item(GNT_MENU(sub), item);
742 gnt_menuitem_set_callback(item, view_log_cb, ggc);
743
744 item = gnt_menuitem_check_new(_("Enable Logging"));
745 gnt_menuitem_check_set_checked(GNT_MENU_ITEM_CHECK(item),
746 purple_conversation_is_logging(ggc->active_conv));
747 gnt_menu_add_item(GNT_MENU(sub), item);
748 gnt_menuitem_set_callback(item, toggle_logging_cb, ggc);
749
750 item = gnt_menuitem_check_new(_("Enable Sounds"));
751 gnt_menuitem_check_set_checked(GNT_MENU_ITEM_CHECK(item),
752 !(ggc->flags & FINCH_CONV_NO_SOUND));
753 gnt_menu_add_item(GNT_MENU(sub), item);
754 gnt_menuitem_set_callback(item, toggle_sound_cb, ggc);
755
756 item = gnt_menuitem_new(_("Plugins"));
757 gnt_menu_add_item(GNT_MENU(menu), item);
758 ggc->plugins = item;
759
760 gg_extended_menu(ggc);
761 }
762
763 static void
764 create_conv_from_userlist(GntWidget *widget, FinchConv *fc)
765 {
766 PurpleAccount *account = purple_conversation_get_account(fc->active_conv);
767 PurpleConnection *gc = purple_account_get_connection(account);
768 PurpleProtocol *protocol = NULL;
769 char *name, *realname = NULL;
770
771 if (!gc) {
772 purple_conversation_write_system_message(fc->active_conv,
773 _("You are not connected."), 0);
774 return;
775 }
776
777 name = gnt_tree_get_selection_data(GNT_TREE(widget));
778
779 protocol = purple_connection_get_protocol(gc);
780 if (protocol)
781 realname = purple_protocol_chat_iface_get_user_real_name(protocol, gc,
782 purple_chat_conversation_get_id(
783 PURPLE_CHAT_CONVERSATION(fc->active_conv)), name);
784
785 purple_im_conversation_new(account, realname ? realname : name);
786 g_free(realname);
787 }
788
789 static void
790 gained_focus_cb(GntWindow *window, FinchConv *fc)
791 {
792 GList *iter;
793 for (iter = fc->list; iter; iter = iter->next) {
794 g_object_set_data(G_OBJECT(iter->data), "unseen-count", 0);
795 purple_conversation_update(iter->data, PURPLE_CONVERSATION_UPDATE_UNSEEN);
796 }
797 }
798
799 static void
800 completion_cb(GntEntry *entry, const char *start, const char *end)
801 {
802 if (start == entry->start && *start != '/')
803 gnt_widget_key_pressed(GNT_WIDGET(entry), ": ");
804 }
805
806 static void
807 gg_setup_commands(FinchConv *fconv, gboolean remove_first)
808 {
809 GList *commands;
810 char command[256] = "/";
811
812 if (remove_first) {
813 commands = purple_cmd_list(NULL);
814 for (; commands; commands = g_list_delete_link(commands, commands)) {
815 g_strlcpy(command + 1, commands->data, sizeof(command) - 1);
816 gnt_entry_remove_suggest(GNT_ENTRY(fconv->entry), command);
817 }
818 }
819
820 commands = purple_cmd_list(fconv->active_conv);
821 for (; commands; commands = g_list_delete_link(commands, commands)) {
822 g_strlcpy(command + 1, commands->data, sizeof(command) - 1);
823 gnt_entry_add_suggest(GNT_ENTRY(fconv->entry), command);
824 }
825 }
826
827 static void
828 cmd_added_cb(const char *cmd, PurpleCmdPriority prior, PurpleCmdFlag flags,
829 FinchConv *fconv)
830 {
831 gg_setup_commands(fconv, TRUE);
832 }
833
834 static void
835 cmd_removed_cb(const char *cmd, FinchConv *fconv)
836 {
837 char command[256] = "/";
838 g_strlcpy(command + 1, cmd, sizeof(command) - 1);
839 gnt_entry_remove_suggest(GNT_ENTRY(fconv->entry), command);
840 gg_setup_commands(fconv, TRUE);
841 }
842
843 static void
844 finch_create_conversation(PurpleConversation *conv)
845 {
846 FinchConv *ggc = FINCH_CONV(conv);
847 char *title;
848 PurpleConversation *cc;
849 PurpleAccount *account;
850 PurpleBlistNode *convnode = NULL;
851
852 if (ggc) {
853 gnt_window_present(ggc->window);
854 return;
855 }
856
857 account = purple_conversation_get_account(conv);
858 cc = PURPLE_CONVERSATION(find_im_with_contact(account, purple_conversation_get_name(conv)));
859 if (cc && FINCH_CONV(cc))
860 ggc = FINCH_CONV(cc);
861 else
862 ggc = g_new0(FinchConv, 1);
863
864 /* Each conversation with the same person will have the same logging setting */
865 if (ggc->list) {
866 purple_conversation_set_logging(conv,
867 purple_conversation_is_logging(ggc->list->data));
868 }
869
870 ggc->list = g_list_prepend(ggc->list, conv);
871 ggc->active_conv = conv;
872 purple_conversation_set_ui_data(conv, ggc);
873
874 if (cc && FINCH_CONV(cc) && cc != conv) {
875 finch_conversation_set_active(conv);
876 return;
877 }
878
879 title = get_conversation_title(conv, account);
880
881 ggc->window = gnt_vwindow_new(FALSE);
882 gnt_box_set_title(GNT_BOX(ggc->window), title);
883 gnt_box_set_toplevel(GNT_BOX(ggc->window), TRUE);
884 gnt_box_set_pad(GNT_BOX(ggc->window), 0);
885
886 if (PURPLE_IS_IM_CONVERSATION(conv))
887 gnt_widget_set_name(ggc->window, "conversation-window-im");
888 else if (PURPLE_IS_CHAT_CONVERSATION(conv))
889 gnt_widget_set_name(ggc->window, "conversation-window-chat");
890 else
891 gnt_widget_set_name(ggc->window, "conversation-window-other");
892
893 ggc->tv = gnt_text_view_new();
894 gnt_widget_set_name(ggc->tv, "conversation-window-textview");
895 gnt_widget_set_size(ggc->tv, purple_prefs_get_int(PREF_ROOT "/size/width"),
896 purple_prefs_get_int(PREF_ROOT "/size/height"));
897
898 if (PURPLE_IS_CHAT_CONVERSATION(conv)) {
899 GntWidget *hbox, *tree;
900 FinchConvChat *fc = ggc->u.chat = g_new0(FinchConvChat, 1);
901 hbox = gnt_hbox_new(FALSE);
902 gnt_box_set_pad(GNT_BOX(hbox), 0);
903 tree = fc->userlist = gnt_tree_new_with_columns(2);
904 gnt_tree_set_col_width(GNT_TREE(tree), 0, 1); /* The flag column */
905 gnt_tree_set_compare_func(GNT_TREE(tree), (GCompareFunc)g_utf8_collate);
906 gnt_tree_set_hash_fns(GNT_TREE(tree), g_str_hash, g_str_equal, g_free);
907 gnt_tree_set_search_column(GNT_TREE(tree), 1);
908 GNT_WIDGET_SET_FLAGS(tree, GNT_WIDGET_NO_BORDER);
909 gnt_box_add_widget(GNT_BOX(hbox), ggc->tv);
910 gnt_box_add_widget(GNT_BOX(hbox), tree);
911 gnt_box_add_widget(GNT_BOX(ggc->window), hbox);
912 g_signal_connect(G_OBJECT(tree), "activate", G_CALLBACK(create_conv_from_userlist), ggc);
913 gnt_widget_set_visible(tree, purple_prefs_get_bool(PREF_USERLIST));
914 } else {
915 ggc->u.im = g_new0(FinchConvIm, 1);
916 gnt_box_add_widget(GNT_BOX(ggc->window), ggc->tv);
917 }
918
919 ggc->info = gnt_vbox_new(FALSE);
920 gnt_box_add_widget(GNT_BOX(ggc->window), ggc->info);
921
922 ggc->entry = gnt_entry_new(NULL);
923 gnt_box_add_widget(GNT_BOX(ggc->window), ggc->entry);
924 gnt_widget_set_name(ggc->entry, "conversation-window-entry");
925 gnt_entry_set_history_length(GNT_ENTRY(ggc->entry), -1);
926 gnt_entry_set_word_suggest(GNT_ENTRY(ggc->entry), TRUE);
927 gnt_entry_set_always_suggest(GNT_ENTRY(ggc->entry), FALSE);
928
929 gnt_text_view_attach_scroll_widget(GNT_TEXT_VIEW(ggc->tv), ggc->entry);
930 gnt_text_view_attach_pager_widget(GNT_TEXT_VIEW(ggc->tv), ggc->entry);
931
932 g_signal_connect_after(G_OBJECT(ggc->entry), "activate", G_CALLBACK(entry_key_pressed), ggc);
933 g_signal_connect(G_OBJECT(ggc->entry), "completion", G_CALLBACK(completion_cb), NULL);
934 g_signal_connect(G_OBJECT(ggc->window), "destroy", G_CALLBACK(closing_window), ggc);
935
936 gnt_widget_set_position(ggc->window, purple_prefs_get_int(PREF_ROOT "/position/x"),
937 purple_prefs_get_int(PREF_ROOT "/position/y"));
938 gnt_widget_show(ggc->window);
939
940 g_signal_connect(G_OBJECT(ggc->tv), "size_changed", G_CALLBACK(size_changed_cb), NULL);
941 g_signal_connect(G_OBJECT(ggc->window), "position_set", G_CALLBACK(save_position_cb), NULL);
942
943 if (PURPLE_IS_IM_CONVERSATION(conv))
944 g_signal_connect(G_OBJECT(ggc->entry), "text_changed", G_CALLBACK(send_typing_notification), ggc);
945
946 convnode = get_conversation_blist_node(conv);
947 if ((convnode && purple_blist_node_get_bool(convnode, "gnt-mute-sound")) ||
948 !finch_sound_is_enabled())
949 ggc->flags |= FINCH_CONV_NO_SOUND;
950
951 gg_create_menu(ggc);
952 gg_setup_commands(ggc, FALSE);
953
954 purple_signal_connect(purple_cmds_get_handle(), "cmd-added", ggc,
955 G_CALLBACK(cmd_added_cb), ggc);
956 purple_signal_connect(purple_cmds_get_handle(), "cmd-removed", ggc,
957 G_CALLBACK(cmd_removed_cb), ggc);
958
959 purple_signal_connect(purple_plugins_get_handle(), "plugin-load", ggc,
960 PURPLE_CALLBACK(plugin_changed_cb), ggc);
961 purple_signal_connect(purple_plugins_get_handle(), "plugin-unload", ggc,
962 PURPLE_CALLBACK(plugin_changed_cb), ggc);
963
964 g_free(title);
965 gnt_box_give_focus_to_child(GNT_BOX(ggc->window), ggc->entry);
966 g_signal_connect(G_OBJECT(ggc->window), "gained-focus", G_CALLBACK(gained_focus_cb), ggc);
967 }
968
969 static void
970 finch_destroy_conversation(PurpleConversation *conv)
971 {
972 /* do stuff here */
973 FinchConv *ggc = FINCH_CONV(conv);
974 ggc->list = g_list_remove(ggc->list, conv);
975 if (ggc->list && conv == ggc->active_conv)
976 finch_conversation_set_active(ggc->list->data);
977
978 if (ggc->list == NULL) {
979 g_free(ggc->u.chat);
980 purple_signals_disconnect_by_handle(ggc);
981 if (ggc->window)
982 gnt_widget_destroy(ggc->window);
983 g_free(ggc);
984 }
985 }
986
987 static void
988 finch_write_conv(PurpleConversation *conv, PurpleMessage *msg)
989 {
990 FinchConv *ggconv = FINCH_CONV(conv);
991 char *strip, *newline;
992 GntTextFormatFlags fl = 0;
993 int pos;
994 PurpleMessageFlags flags = purple_message_get_flags(msg);
995
996 g_return_if_fail(ggconv != NULL);
997
998 if ((flags & PURPLE_MESSAGE_SYSTEM) && !(flags & PURPLE_MESSAGE_NOTIFY)) {
999 flags &= ~(PURPLE_MESSAGE_SEND | PURPLE_MESSAGE_RECV);
1000 }
1001
1002 if (ggconv->active_conv != conv) {
1003 if (flags & (PURPLE_MESSAGE_SEND | PURPLE_MESSAGE_RECV))
1004 finch_conversation_set_active(conv);
1005 else
1006 return;
1007 }
1008
1009 pos = gnt_text_view_get_lines_below(GNT_TEXT_VIEW(ggconv->tv));
1010
1011 gnt_text_view_tag_change(GNT_TEXT_VIEW(ggconv->tv), "typing", NULL, TRUE);
1012 gnt_text_view_append_text_with_flags(GNT_TEXT_VIEW(ggconv->tv), "\n", GNT_TEXT_FLAG_NORMAL);
1013
1014 /* Unnecessary to print the timestamp for delayed message */
1015 if (purple_prefs_get_bool("/finch/conversations/timestamps")) {
1016 time_t mtime = purple_message_get_time(msg);
1017 if (!mtime)
1018 time(&mtime);
1019 gnt_text_view_append_text_with_flags(GNT_TEXT_VIEW(ggconv->tv),
1020 purple_utf8_strftime("(%H:%M:%S)", localtime(&mtime)), gnt_color_pair(color_timestamp));
1021 }
1022
1023 gnt_text_view_append_text_with_flags(GNT_TEXT_VIEW(ggconv->tv), " ", GNT_TEXT_FLAG_NORMAL);
1024
1025 if (flags & PURPLE_MESSAGE_AUTO_RESP)
1026 gnt_text_view_append_text_with_flags(GNT_TEXT_VIEW(ggconv->tv),
1027 _("<AUTO-REPLY> "), GNT_TEXT_FLAG_BOLD);
1028
1029 if (purple_message_get_author(msg) && (flags & (PURPLE_MESSAGE_SEND | PURPLE_MESSAGE_RECV)) &&
1030 !(flags & PURPLE_MESSAGE_NOTIFY))
1031 {
1032 char * name = NULL;
1033 GntTextFormatFlags msgflags = GNT_TEXT_FLAG_NORMAL;
1034 gboolean me = FALSE;
1035 gchar *msg_text = g_strdup(purple_message_get_contents(msg));
1036
1037 if (purple_message_meify(msg_text, -1)) {
1038 name = g_strdup_printf("*** %s", purple_message_get_author_alias(msg));
1039 if (!(flags & PURPLE_MESSAGE_SEND) &&
1040 (flags & PURPLE_MESSAGE_NICK))
1041 msgflags = gnt_color_pair(color_message_highlight);
1042 else
1043 msgflags = gnt_color_pair(color_message_action);
1044 me = TRUE;
1045 } else {
1046 name = g_strdup_printf("%s", purple_message_get_author_alias(msg));
1047 if (flags & PURPLE_MESSAGE_SEND)
1048 msgflags = gnt_color_pair(color_message_send);
1049 else if (flags & PURPLE_MESSAGE_NICK)
1050 msgflags = gnt_color_pair(color_message_highlight);
1051 else
1052 msgflags = gnt_color_pair(color_message_receive);
1053 }
1054 purple_message_set_contents(msg, msg_text); /* might be "meified" */
1055 gnt_text_view_append_text_with_flags(GNT_TEXT_VIEW(ggconv->tv),
1056 name, msgflags);
1057 gnt_text_view_append_text_with_flags(GNT_TEXT_VIEW(ggconv->tv), me ? " " : ": ", GNT_TEXT_FLAG_NORMAL);
1058 g_free(name);
1059 } else
1060 fl = GNT_TEXT_FLAG_DIM;
1061
1062 if (flags & PURPLE_MESSAGE_ERROR)
1063 fl |= GNT_TEXT_FLAG_BOLD;
1064
1065 /* XXX: Remove this workaround when textview can parse messages. */
1066 newline = purple_strdup_withhtml(purple_message_get_contents(msg));
1067 strip = purple_markup_strip_html(newline);
1068 gnt_text_view_append_text_with_flags(GNT_TEXT_VIEW(ggconv->tv),
1069 strip, fl);
1070
1071 g_free(newline);
1072 g_free(strip);
1073
1074 if (PURPLE_IS_IM_CONVERSATION(conv) && purple_im_conversation_get_typing_state(
1075 PURPLE_IM_CONVERSATION(conv)) == PURPLE_IM_TYPING) {
1076 strip = g_strdup_printf(_("\n%s is typing..."), purple_conversation_get_title(conv));
1077 gnt_text_view_append_text_with_tag(GNT_TEXT_VIEW(ggconv->tv),
1078 strip, GNT_TEXT_FLAG_DIM, "typing");
1079 g_free(strip);
1080 }
1081
1082 if (pos <= 1)
1083 gnt_text_view_scroll(GNT_TEXT_VIEW(ggconv->tv), 0);
1084
1085 if (flags & (PURPLE_MESSAGE_RECV | PURPLE_MESSAGE_NICK | PURPLE_MESSAGE_ERROR))
1086 gnt_widget_set_urgent(ggconv->tv);
1087 if (flags & PURPLE_MESSAGE_RECV && !gnt_widget_has_focus(ggconv->window)) {
1088 int count = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(conv), "unseen-count"));
1089 g_object_set_data(G_OBJECT(conv), "unseen-count", GINT_TO_POINTER(count + 1));
1090 purple_conversation_update(conv, PURPLE_CONVERSATION_UPDATE_UNSEEN);
1091 }
1092 }
1093
1094 static const char *
1095 chat_flag_text(PurpleChatUserFlags flags)
1096 {
1097 if (flags & PURPLE_CHAT_USER_FOUNDER)
1098 return "~";
1099 if (flags & PURPLE_CHAT_USER_OP)
1100 return "@";
1101 if (flags & PURPLE_CHAT_USER_HALFOP)
1102 return "%";
1103 if (flags & PURPLE_CHAT_USER_VOICE)
1104 return "+";
1105 return " ";
1106 }
1107
1108 static void
1109 finch_chat_add_users(PurpleChatConversation *chat, GList *users, gboolean new_arrivals)
1110 {
1111 PurpleConversation *conv = PURPLE_CONVERSATION(chat);
1112 FinchConv *ggc = FINCH_CONV(conv);
1113 GntEntry *entry = GNT_ENTRY(ggc->entry);
1114
1115 if (!new_arrivals)
1116 {
1117 /* Print the list of users in the room */
1118 GString *string = g_string_new(NULL);
1119 GList *iter;
1120 int count = g_list_length(users);
1121
1122 g_string_printf(string,
1123 ngettext("List of %d user:\n", "List of %d users:\n", count), count);
1124 for (iter = users; iter; iter = iter->next)
1125 {
1126 PurpleChatUser *chatuser = iter->data;
1127 const char *str;
1128
1129 if ((str = purple_chat_user_get_alias(chatuser)) == NULL)
1130 str = purple_chat_user_get_name(chatuser);
1131 g_string_append_printf(string, "[ %s ]", str);
1132 }
1133
1134 purple_conversation_write_system_message(
1135 conv, string->str, 0);
1136 g_string_free(string, TRUE);
1137 }
1138
1139 for (; users; users = users->next)
1140 {
1141 PurpleChatUser *chatuser = users->data;
1142 GntTree *tree = GNT_TREE(ggc->u.chat->userlist);
1143 gnt_entry_add_suggest(entry, purple_chat_user_get_name(chatuser));
1144 gnt_entry_add_suggest(entry, purple_chat_user_get_alias(chatuser));
1145 gnt_tree_add_row_after(tree, g_strdup(purple_chat_user_get_name(chatuser)),
1146 gnt_tree_create_row(tree, chat_flag_text(purple_chat_user_get_flags(chatuser)), purple_chat_user_get_alias(chatuser)), NULL, NULL);
1147 }
1148 }
1149
1150 static void
1151 finch_chat_rename_user(PurpleChatConversation *chat, const char *old, const char *new_n, const char *new_a)
1152 {
1153 /* Update the name for string completion */
1154 FinchConv *ggc = FINCH_CONV(PURPLE_CONVERSATION(chat));
1155 GntEntry *entry = GNT_ENTRY(ggc->entry);
1156 GntTree *tree = GNT_TREE(ggc->u.chat->userlist);
1157 PurpleChatUser *cb = purple_chat_conversation_find_user(chat, new_n);
1158
1159 gnt_entry_remove_suggest(entry, old);
1160 gnt_tree_remove(tree, (gpointer)old);
1161
1162 gnt_entry_add_suggest(entry, new_n);
1163 gnt_entry_add_suggest(entry, new_a);
1164 gnt_tree_add_row_after(tree, g_strdup(new_n),
1165 gnt_tree_create_row(tree, chat_flag_text(purple_chat_user_get_flags(cb)), new_a), NULL, NULL);
1166 }
1167
1168 static void
1169 finch_chat_remove_users(PurpleChatConversation *chat, GList *list)
1170 {
1171 /* Remove the name from string completion */
1172 FinchConv *ggc = FINCH_CONV(PURPLE_CONVERSATION(chat));
1173 GntEntry *entry = GNT_ENTRY(ggc->entry);
1174 for (; list; list = list->next) {
1175 GntTree *tree = GNT_TREE(ggc->u.chat->userlist);
1176 gnt_entry_remove_suggest(entry, list->data);
1177 gnt_tree_remove(tree, list->data);
1178 }
1179 }
1180
1181 static void
1182 finch_chat_update_user(PurpleChatUser *cb)
1183 {
1184 PurpleChatConversation *chat;
1185 FinchConv *ggc;
1186 if (!cb)
1187 return;
1188
1189 chat = purple_chat_user_get_chat(cb);
1190 ggc = FINCH_CONV(PURPLE_CONVERSATION(chat));
1191 gnt_tree_change_text(GNT_TREE(ggc->u.chat->userlist),
1192 (gpointer)purple_chat_user_get_name(cb), 0,
1193 chat_flag_text(purple_chat_user_get_flags(cb)));
1194 }
1195
1196 static void
1197 finch_conv_present(PurpleConversation *conv)
1198 {
1199 FinchConv *fc = FINCH_CONV(conv);
1200 if (fc && fc->window)
1201 gnt_window_present(fc->window);
1202 }
1203
1204 static gboolean
1205 finch_conv_has_focus(PurpleConversation *conv)
1206 {
1207 FinchConv *fc = FINCH_CONV(conv);
1208 if (fc && fc->window)
1209 return gnt_widget_has_focus(fc->window);
1210 return FALSE;
1211 }
1212
1213 static PurpleConversationUiOps conv_ui_ops =
1214 {
1215 finch_create_conversation,
1216 finch_destroy_conversation,
1217 NULL, /* write_chat */
1218 NULL, /* write_im */
1219 finch_write_conv,
1220 finch_chat_add_users,
1221 finch_chat_rename_user,
1222 finch_chat_remove_users,
1223 finch_chat_update_user,
1224 finch_conv_present, /* present */
1225 finch_conv_has_focus, /* has_focus */
1226 NULL, /* send_confirm */
1227 NULL,
1228 NULL,
1229 NULL,
1230 NULL
1231 };
1232
1233 PurpleConversationUiOps *finch_conv_get_ui_ops()
1234 {
1235 return &conv_ui_ops;
1236 }
1237
1238 /* Xerox */
1239 static PurpleCmdRet
1240 say_command_cb(PurpleConversation *conv,
1241 const char *cmd, char **args, char **error, void *data)
1242 {
1243 purple_conversation_send(conv, args[0]);
1244
1245 return PURPLE_CMD_RET_OK;
1246 }
1247
1248 /* Xerox */
1249 static PurpleCmdRet
1250 me_command_cb(PurpleConversation *conv,
1251 const char *cmd, char **args, char **error, void *data)
1252 {
1253 char *tmp;
1254
1255 tmp = g_strdup_printf("/me %s", args[0]);
1256 purple_conversation_send(conv, tmp);
1257
1258 g_free(tmp);
1259 return PURPLE_CMD_RET_OK;
1260 }
1261
1262 /* Xerox */
1263 static PurpleCmdRet
1264 debug_command_cb(PurpleConversation *conv,
1265 const char *cmd, char **args, char **error, void *data)
1266 {
1267 char *tmp, *markup;
1268
1269 if (!g_ascii_strcasecmp(args[0], "version")) {
1270 tmp = g_strdup_printf("Using Finch v%s with libpurple v%s.",
1271 DISPLAY_VERSION, purple_core_get_version());
1272 } else if (!g_ascii_strcasecmp(args[0], "plugins")) {
1273 /* Show all the loaded plugins, including plugins marked internal.
1274 * This is intentional, since third party protocols are often sources of bugs, and some
1275 * loaders can also be buggy.
1276 */
1277 GString *str = g_string_new("Loaded Plugins: ");
1278 const GList *plugins = purple_plugins_get_loaded();
1279 if (plugins) {
1280 for (; plugins; plugins = plugins->next) {
1281 PurplePluginInfo *plugin_info = purple_plugin_get_info(plugins->data);
1282 str = g_string_append(str, purple_plugin_info_get_name(plugin_info));
1283
1284 if (plugins->next)
1285 str = g_string_append(str, ", ");
1286 }
1287 } else {
1288 str = g_string_append(str, "(none)");
1289 }
1290
1291 tmp = g_string_free(str, FALSE);
1292 } else {
1293 purple_conversation_write_system_message(conv,
1294 _("Supported debug options are: plugins version"),
1295 PURPLE_MESSAGE_NO_LOG | PURPLE_MESSAGE_ERROR);
1296 return PURPLE_CMD_RET_OK;
1297 }
1298
1299 markup = g_markup_escape_text(tmp, -1);
1300 purple_conversation_send(conv, markup);
1301
1302 g_free(tmp);
1303 g_free(markup);
1304 return PURPLE_CMD_RET_OK;
1305 }
1306
1307 /* Xerox */
1308 static PurpleCmdRet
1309 clear_command_cb(PurpleConversation *conv,
1310 const char *cmd, char **args, char **error, void *data)
1311 {
1312 purple_conversation_clear_message_history(conv);
1313 return PURPLE_CMD_RET_OK;
1314 }
1315
1316 /* Xerox */
1317 static PurpleCmdRet
1318 help_command_cb(PurpleConversation *conv,
1319 const char *cmd, char **args, char **error, void *data)
1320 {
1321 GList *l, *text;
1322 GString *s;
1323
1324 if (args[0] != NULL) {
1325 s = g_string_new("");
1326 text = purple_cmd_help(conv, args[0]);
1327
1328 if (text) {
1329 for (l = text; l; l = l->next)
1330 if (l->next)
1331 g_string_append_printf(s, "%s\n", (char *)l->data);
1332 else
1333 g_string_append_printf(s, "%s", (char *)l->data);
1334 } else {
1335 g_string_append(s, _("No such command (in this context)."));
1336 }
1337 } else {
1338 s = g_string_new(_("Use \"/help &lt;command&gt;\" for help with a "
1339 "specific command.\nThe following commands are available in "
1340 "this context:\n"));
1341
1342 text = purple_cmd_list(conv);
1343 for (l = text; l; l = l->next)
1344 if (l->next)
1345 g_string_append_printf(s, "%s, ", (char *)l->data);
1346 else
1347 g_string_append_printf(s, "%s.", (char *)l->data);
1348 g_list_free(text);
1349 }
1350
1351 purple_conversation_write_system_message(conv, s->str, PURPLE_MESSAGE_NO_LOG);
1352 g_string_free(s, TRUE);
1353
1354 return PURPLE_CMD_RET_OK;
1355 }
1356
1357 static PurpleCmdRet
1358 cmd_show_window(PurpleConversation *conv, const char *cmd, char **args, char **error, gpointer data)
1359 {
1360 void (*callback)(void) = data;
1361 callback();
1362 return PURPLE_CMD_RET_OK;
1363 }
1364
1365 static PurpleCmdRet
1366 cmd_message_color(PurpleConversation *conv, const char *cmd, char **args, char **error, gpointer data)
1367 {
1368 int *msgclass = NULL;
1369 int fg, bg;
1370
1371 if (strcmp(args[0], "receive") == 0)
1372 msgclass = &color_message_receive;
1373 else if (strcmp(args[0], "send") == 0)
1374 msgclass = &color_message_send;
1375 else if (strcmp(args[0], "highlight") == 0)
1376 msgclass = &color_message_highlight;
1377 else if (strcmp(args[0], "action") == 0)
1378 msgclass = &color_message_action;
1379 else if (strcmp(args[0], "timestamp") == 0)
1380 msgclass = &color_timestamp;
1381 else {
1382 if (error)
1383 *error = g_strdup_printf(_("%s is not a valid message class. See '/help msgcolor' for valid message classes."), args[0]);
1384 return PURPLE_CMD_RET_FAILED;
1385 }
1386
1387 fg = gnt_colors_get_color(args[1]);
1388 if (fg == -EINVAL) {
1389 if (error)
1390 *error = g_strdup_printf(_("%s is not a valid color. See '/help msgcolor' for valid colors."), args[1]);
1391 return PURPLE_CMD_RET_FAILED;
1392 }
1393
1394 bg = gnt_colors_get_color(args[2]);
1395 if (bg == -EINVAL) {
1396 if (error)
1397 *error = g_strdup_printf(_("%s is not a valid color. See '/help msgcolor' for valid colors."), args[2]);
1398 return PURPLE_CMD_RET_FAILED;
1399 }
1400
1401 init_pair(*msgclass, fg, bg);
1402
1403 return PURPLE_CMD_RET_OK;
1404 }
1405
1406 static PurpleCmdRet
1407 users_command_cb(PurpleConversation *conv, const char *cmd, char **args, char **error, gpointer data)
1408 {
1409 FinchConv *fc = FINCH_CONV(conv);
1410 FinchConvChat *ch;
1411 if (!fc)
1412 return PURPLE_CMD_RET_FAILED;
1413
1414 ch = fc->u.chat;
1415 gnt_widget_set_visible(ch->userlist,
1416 (GNT_WIDGET_IS_FLAG_SET(ch->userlist, GNT_WIDGET_INVISIBLE)));
1417 gnt_box_readjust(GNT_BOX(fc->window));
1418 gnt_box_give_focus_to_child(GNT_BOX(fc->window), fc->entry);
1419 purple_prefs_set_bool(PREF_USERLIST, !(GNT_WIDGET_IS_FLAG_SET(ch->userlist, GNT_WIDGET_INVISIBLE)));
1420 return PURPLE_CMD_RET_OK;
1421 }
1422
1423 void finch_conversation_init()
1424 {
1425 color_message_send = gnt_style_get_color(NULL, "color-message-sent");
1426 if (!color_message_send)
1427 color_message_send = gnt_color_add_pair(COLOR_CYAN, -1);
1428 color_message_receive = gnt_style_get_color(NULL, "color-message-received");
1429 if (!color_message_receive)
1430 color_message_receive = gnt_color_add_pair(COLOR_RED, -1);
1431 color_message_highlight = gnt_style_get_color(NULL, "color-message-highlight");
1432 if (!color_message_highlight)
1433 color_message_highlight = gnt_color_add_pair(COLOR_GREEN, -1);
1434 color_timestamp = gnt_style_get_color(NULL, "color-timestamp");
1435 if (!color_timestamp)
1436 color_timestamp = gnt_color_add_pair(COLOR_BLUE, -1);
1437 color_message_action = gnt_style_get_color(NULL, "color-message-action");
1438 if (!color_message_action)
1439 color_message_action = gnt_color_add_pair(COLOR_YELLOW, -1);
1440 purple_prefs_add_none(PREF_ROOT);
1441 purple_prefs_add_none(PREF_ROOT "/size");
1442 purple_prefs_add_int(PREF_ROOT "/size/width", 70);
1443 purple_prefs_add_int(PREF_ROOT "/size/height", 20);
1444 purple_prefs_add_none(PREF_ROOT "/position");
1445 purple_prefs_add_int(PREF_ROOT "/position/x", 0);
1446 purple_prefs_add_int(PREF_ROOT "/position/y", 0);
1447 purple_prefs_add_none(PREF_CHAT);
1448 purple_prefs_add_bool(PREF_USERLIST, FALSE);
1449
1450 /* Xerox the commands */
1451 purple_cmd_register("say", "S", PURPLE_CMD_P_DEFAULT,
1452 PURPLE_CMD_FLAG_CHAT | PURPLE_CMD_FLAG_IM, NULL,
1453 say_command_cb, _("say &lt;message&gt;: Send a message normally as if you weren't using a command."), NULL);
1454 purple_cmd_register("me", "S", PURPLE_CMD_P_DEFAULT,
1455 PURPLE_CMD_FLAG_CHAT | PURPLE_CMD_FLAG_IM, NULL,
1456 me_command_cb, _("me &lt;action&gt;: Send an IRC style action to a buddy or chat."), NULL);
1457 purple_cmd_register("debug", "w", PURPLE_CMD_P_DEFAULT,
1458 PURPLE_CMD_FLAG_CHAT | PURPLE_CMD_FLAG_IM, NULL,
1459 debug_command_cb, _("debug &lt;option&gt;: Send various debug information to the current conversation."), NULL);
1460 purple_cmd_register("clear", "", PURPLE_CMD_P_DEFAULT,
1461 PURPLE_CMD_FLAG_CHAT | PURPLE_CMD_FLAG_IM, NULL,
1462 clear_command_cb, _("clear: Clears the conversation scrollback."), NULL);
1463 purple_cmd_register("help", "w", PURPLE_CMD_P_DEFAULT,
1464 PURPLE_CMD_FLAG_CHAT | PURPLE_CMD_FLAG_IM | PURPLE_CMD_FLAG_ALLOW_WRONG_ARGS, NULL,
1465 help_command_cb, _("help &lt;command&gt;: Help on a specific command."), NULL);
1466 purple_cmd_register("users", "", PURPLE_CMD_P_DEFAULT,
1467 PURPLE_CMD_FLAG_CHAT | PURPLE_CMD_FLAG_ALLOW_WRONG_ARGS, NULL,
1468 users_command_cb, _("users: Show the list of users in the chat."), NULL);
1469
1470 /* Now some commands to bring up some other windows */
1471 purple_cmd_register("plugins", "", PURPLE_CMD_P_DEFAULT,
1472 PURPLE_CMD_FLAG_CHAT | PURPLE_CMD_FLAG_IM, NULL,
1473 cmd_show_window, _("plugins: Show the plugins window."), finch_plugins_show_all);
1474 purple_cmd_register("buddylist", "", PURPLE_CMD_P_DEFAULT,
1475 PURPLE_CMD_FLAG_CHAT | PURPLE_CMD_FLAG_IM, NULL,
1476 cmd_show_window, _("buddylist: Show the buddylist."), finch_blist_show);
1477 purple_cmd_register("accounts", "", PURPLE_CMD_P_DEFAULT,
1478 PURPLE_CMD_FLAG_CHAT | PURPLE_CMD_FLAG_IM, NULL,
1479 cmd_show_window, _("accounts: Show the accounts window."), finch_accounts_show_all);
1480 purple_cmd_register("debugwin", "", PURPLE_CMD_P_DEFAULT,
1481 PURPLE_CMD_FLAG_CHAT | PURPLE_CMD_FLAG_IM, NULL,
1482 cmd_show_window, _("debugwin: Show the debug window."), finch_debug_window_show);
1483 purple_cmd_register("prefs", "", PURPLE_CMD_P_DEFAULT,
1484 PURPLE_CMD_FLAG_CHAT | PURPLE_CMD_FLAG_IM, NULL,
1485 cmd_show_window, _("prefs: Show the preference window."), finch_prefs_show_all);
1486 purple_cmd_register("status", "", PURPLE_CMD_P_DEFAULT,
1487 PURPLE_CMD_FLAG_CHAT | PURPLE_CMD_FLAG_IM, NULL,
1488 cmd_show_window, _("statuses: Show the savedstatuses window."), finch_savedstatus_show_all);
1489
1490 /* Allow customizing the message colors using a command during run-time */
1491 purple_cmd_register("msgcolor", "www", PURPLE_CMD_P_DEFAULT,
1492 PURPLE_CMD_FLAG_CHAT | PURPLE_CMD_FLAG_IM, NULL,
1493 cmd_message_color, _("msgcolor &lt;class&gt; &lt;foreground&gt; &lt;background&gt;: "
1494 "Set the color for different classes of messages in the conversation window.<br>"
1495 " &lt;class&gt;: receive, send, highlight, action, timestamp<br>"
1496 " &lt;foreground/background&gt;: black, red, green, blue, white, gray, darkgray, magenta, cyan, default<br><br>"
1497 "EXAMPLE:<br> msgcolor send cyan default"),
1498 NULL);
1499 purple_cmd_register("msgcolour", "www", PURPLE_CMD_P_DEFAULT,
1500 PURPLE_CMD_FLAG_CHAT | PURPLE_CMD_FLAG_IM, NULL,
1501 cmd_message_color, _("msgcolor &lt;class&gt; &lt;foreground&gt; &lt;background&gt;: "
1502 "Set the color for different classes of messages in the conversation window.<br>"
1503 " &lt;class&gt;: receive, send, highlight, action, timestamp<br>"
1504 " &lt;foreground/background&gt;: black, red, green, blue, white, gray, darkgray, magenta, cyan, default<br><br>"
1505 "EXAMPLE:<br> msgcolor send cyan default"),
1506 NULL);
1507
1508 purple_signal_connect(purple_conversations_get_handle(), "buddy-typing", finch_conv_get_handle(),
1509 PURPLE_CALLBACK(update_buddy_typing), NULL);
1510 purple_signal_connect(purple_conversations_get_handle(), "buddy-typing-stopped", finch_conv_get_handle(),
1511 PURPLE_CALLBACK(update_buddy_typing), NULL);
1512 purple_signal_connect(purple_conversations_get_handle(), "chat-left", finch_conv_get_handle(),
1513 PURPLE_CALLBACK(chat_left_cb), NULL);
1514 purple_signal_connect(purple_conversations_get_handle(), "cleared-message-history", finch_conv_get_handle(),
1515 PURPLE_CALLBACK(cleared_message_history_cb), NULL);
1516 purple_signal_connect(purple_conversations_get_handle(), "conversation-updated", finch_conv_get_handle(),
1517 PURPLE_CALLBACK(conv_updated), NULL);
1518 purple_signal_connect(purple_blist_get_handle(), "buddy-signed-on", finch_conv_get_handle(),
1519 PURPLE_CALLBACK(buddy_signed_on_off), NULL);
1520 purple_signal_connect(purple_blist_get_handle(), "buddy-signed-off", finch_conv_get_handle(),
1521 PURPLE_CALLBACK(buddy_signed_on_off), NULL);
1522 purple_signal_connect(purple_connections_get_handle(), "signed-on", finch_conv_get_handle(),
1523 PURPLE_CALLBACK(account_signed_on_off), NULL);
1524 purple_signal_connect(purple_connections_get_handle(), "signed-off", finch_conv_get_handle(),
1525 PURPLE_CALLBACK(account_signed_on_off), NULL);
1526 purple_signal_connect(purple_connections_get_handle(), "signing-off", finch_conv_get_handle(),
1527 PURPLE_CALLBACK(account_signing_off), NULL);
1528 }
1529
1530 void finch_conversation_uninit()
1531 {
1532 purple_signals_disconnect_by_handle(finch_conv_get_handle());
1533 }
1534
1535 void finch_conversation_set_active(PurpleConversation *conv)
1536 {
1537 FinchConv *ggconv = FINCH_CONV(conv);
1538 PurpleAccount *account;
1539 char *title;
1540
1541 g_return_if_fail(ggconv);
1542 g_return_if_fail(g_list_find(ggconv->list, conv));
1543 if (ggconv->active_conv == conv)
1544 return;
1545
1546 ggconv->active_conv = conv;
1547 gg_setup_commands(ggconv, TRUE);
1548 account = purple_conversation_get_account(conv);
1549 title = get_conversation_title(conv, account);
1550 gnt_screen_rename_widget(ggconv->window, title);
1551 g_free(title);
1552
1553 generate_e2ee_menu(ggconv);
1554 }
1555
1556 void finch_conversation_set_info_widget(PurpleConversation *conv, GntWidget *widget)
1557 {
1558 FinchConv *fc = FINCH_CONV(conv);
1559 int height, width;
1560
1561 gnt_box_remove_all(GNT_BOX(fc->info));
1562
1563 if (widget) {
1564 gnt_box_add_widget(GNT_BOX(fc->info), widget);
1565 gnt_box_readjust(GNT_BOX(fc->info));
1566 }
1567
1568 gnt_widget_get_size(fc->window, &width, &height);
1569 gnt_box_readjust(GNT_BOX(fc->window));
1570 gnt_screen_resize_widget(fc->window, width, height);
1571 gnt_box_give_focus_to_child(GNT_BOX(fc->window), fc->entry);
1572 }
1573
Git mirror of Pidgin's Mercurial repository