?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[gaim-migrate @ 5229]
[pidgin-git.git] / src / conversation.c
blob308fcbae540f8ffc6552f874b280822f3ecd4283
1 /*
2 * gaim
3 *
4 * Copyright (C) 2002-2003, Christian Hammond <chipx86@gnupdate.org>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 *
20 */
21
22 #ifdef HAVE_CONFIG_H
23 #include <config.h>
24 #endif
25
26 #include <string.h>
27 #include <stdlib.h>
28 #include <sys/stat.h>
29 #include <errno.h>
30 #include <ctype.h>
31 #include "conversation.h"
32 #include "gaim.h"
33 #include "prpl.h"
34
35 #ifdef _WIN32
36 #include "win32dep.h"
37 #endif
38
39 struct ConvPlacementData
40 {
41 char *name;
42 gaim_conv_placement_fnc fnc;
43 };
44
45 #define SEND_TYPED_TIMEOUT 5000
46
47 static struct gaim_window_ui_ops *win_ui_ops = NULL;
48
49 static GList *conversations = NULL;
50 static GList *ims = NULL;
51 static GList *chats = NULL;
52 static GList *windows = NULL;
53 static GList *conv_placement_fncs = NULL;
54 static gaim_conv_placement_fnc place_conv = NULL;
55 static int place_conv_index = -1;
56
57 static gint
58 insertname_compare(gconstpointer one, gconstpointer two)
59 {
60 const char *a = (const char *)one;
61 const char *b = (const char *)two;
62
63 if (*a == '@') {
64 if (*b != '@') return -1;
65
66 return strcasecmp(a + 1, b + 1);
67
68 } else if (*a == '%') {
69 if (*b != '%') return -1;
70
71 return strcasecmp(a + 1, b + 1);
72
73 } else if (*a == '+') {
74 if (*b == '@') return 1;
75 if (*b != '+') return -1;
76
77 return strcasecmp(a + 1, b + 1);
78
79 } else if (*b == '@' || *b == '%' || *b == '+')
80 return 1;
81
82 return strcasecmp(a, b);
83 }
84
85 static gboolean
86 find_nick(struct gaim_connection *gc, const char *message)
87 {
88 char *msg, *who, *p;
89 int n;
90
91 msg = g_utf8_strdown(message, -1);
92
93 who = g_utf8_strdown(gc->username, -1);
94 n = strlen(who);
95
96 if ((p = strstr(msg, who)) != NULL) {
97 if ((p == msg || !isalnum(*(p - 1))) && !isalnum(*(p + n))) {
98 g_free(who);
99 g_free(msg);
100
101 return TRUE;
102 }
103 }
104
105 g_free(who);
106
107 if (!gaim_utf8_strcasecmp(gc->username, gc->displayname)) {
108 g_free(msg);
109
110 return FALSE;
111 }
112
113 who = g_utf8_strdown(gc->displayname, -1);
114 n = strlen(who);
115
116 if (n > 0 && (p = strstr(msg, who)) != NULL) {
117 if ((p == msg || !isalnum(*(p - 1))) && !isalnum(*(p + n))) {
118 g_free(who);
119 g_free(msg);
120
121 return TRUE;
122 }
123 }
124
125 g_free(who);
126 g_free(msg);
127
128 return FALSE;
129 }
130
131 static gboolean
132 reset_typing(gpointer data)
133 {
134 char *name = (char *)data;
135 struct gaim_conversation *c = gaim_find_conversation(name);
136 struct gaim_im *im;
137
138 if (!c)
139 return FALSE;
140
141 im = GAIM_IM(c);
142
143 gaim_im_set_typing_state(im, NOT_TYPING);
144 gaim_im_update_typing(im);
145 gaim_im_stop_typing_timeout(im);
146
147 return FALSE;
148 }
149
150 static gboolean
151 send_typed(gpointer data)
152 {
153 struct gaim_conversation *conv = (struct gaim_conversation *)data;
154 struct gaim_connection *gc;
155 const char *name;
156
157 gc = gaim_conversation_get_gc(conv);
158 name = gaim_conversation_get_name(conv);
159
160 if (conv != NULL && gc != NULL && name != NULL) {
161 gaim_im_set_type_again(GAIM_IM(conv), TRUE);
162
163 /* XXX Somebody add const stuff! */
164 serv_send_typing(gc, (char *)name, TYPED);
165
166 debug_printf("typed...\n");
167 }
168
169 return FALSE;
170 }
171
172 static void
173 common_send(struct gaim_conversation *conv, const char *message)
174 {
175 GaimConversationType type;
176 struct gaim_connection *gc;
177 struct gaim_conversation_ui_ops *ops;
178 char *buf, *buf2, *buffy;
179 gulong length = 0;
180 gboolean binary = FALSE;
181 int plugin_return;
182 int limit;
183 int err = 0;
184 GList *first;
185
186 if ((gc = gaim_conversation_get_gc(conv)) == NULL)
187 return;
188
189 type = gaim_conversation_get_type(conv);
190 ops = gaim_conversation_get_ui_ops(conv);
191
192 limit = 32 * 1024; /* You shouldn't be sending more than 32K in your
193 messages. That's a book. */
194
195 buf = g_malloc(limit);
196 strncpy(buf, message, limit);
197
198 if (strlen(buf) == 0) {
199 g_free(buf);
200
201 return;
202 }
203
204 first = g_list_first(conv->send_history);
205
206 if (first->data)
207 g_free(first->data);
208
209 first->data = g_strdup(buf);
210
211 conv->send_history = g_list_prepend(first, NULL);
212
213 buf2 = g_malloc(limit);
214
215 if (gc->flags & OPT_CONN_HTML) {
216 if (convo_options & OPT_CONVO_SEND_LINKS)
217 linkify_text(buf);
218 }
219
220 buffy = g_strdup(buf);
221 plugin_return = plugin_event(
222 (type == GAIM_CONV_IM ? event_im_send : event_chat_send),
223 gc,
224 (type == GAIM_CONV_IM
225 ? gaim_conversation_get_name(conv)
226 : (void *)gaim_chat_get_id(GAIM_CHAT(conv))),
227 &buffy);
228
229 if (buffy == NULL) {
230 g_free(buf2);
231 g_free(buf);
232 return;
233 }
234
235 if (plugin_return) {
236 g_free(buffy);
237 g_free(buf2);
238 g_free(buf);
239 return;
240 }
241
242 strncpy(buf, buffy, limit);
243 g_free(buffy);
244
245 if (type == GAIM_CONV_IM) {
246 struct gaim_im *im = GAIM_IM(conv);
247
248 buffy = g_strdup(buf);
249 plugin_event(event_im_displayed_sent, gc,
250 gaim_conversation_get_name(conv), &buffy);
251
252 if (buffy != NULL) {
253 int imflags = 0;
254
255 if (conv->u.im->images != NULL) {
256 int id = 0, offset = 0;
257 char *bigbuf = NULL;
258 GSList *tmplist;
259
260 for (tmplist = conv->u.im->images;
261 tmplist != NULL;
262 tmplist = tmplist->next) {
263
264 char *img_filename = (char *)tmplist->data;
265 FILE *imgfile;
266 char *filename, *c;
267 struct stat st;
268 char imgtag[1024];
269
270 id++;
271
272 if (stat(img_filename, &st) != 0) {
273 debug_printf("Could not stat %s\n",
274 (char *)img_filename);
275 continue;
276 }
277
278 /*
279 * Here we check to make sure the user still wants to send
280 * the image. He may have deleted the <img> tag in which
281 * case we don't want to send the binary data.
282 */
283 filename = img_filename;
284
285 while ((c = strchr(filename, '/')) != NULL)
286 filename = c + 1;
287
288 g_snprintf(imgtag, sizeof(imgtag),
289 "<IMG SRC=\"file://%s\" ID=\"%d\" "
290 "DATASIZE=\"%d\">",
291 filename, id, (int)st.st_size);
292
293 if (strstr(buffy, imgtag) == 0) {
294 debug_printf("Not sending image: %s\n", img_filename);
295 continue;
296 }
297
298 if (!binary) {
299 length = strlen(buffy) + strlen("<BINARY></BINARY>");
300 bigbuf = g_malloc(length + 1);
301 g_snprintf(bigbuf,
302 strlen(buffy) + strlen("<BINARY> ") + 1,
303 "%s<BINARY>", buffy);
304
305 offset = strlen(buffy) + strlen("<BINARY>");
306 binary = TRUE;
307 }
308
309 g_snprintf(imgtag, sizeof(imgtag),
310 "<DATA ID=\"%d\" SIZE=\"%d\">",
311 id, (int)st.st_size);
312
313 length += strlen(imgtag) + st.st_size + strlen("</DATA>");
314
315 bigbuf = g_realloc(bigbuf, length + 1);
316
317 if ((imgfile = fopen(img_filename, "r")) == NULL) {
318 debug_printf("Could not open %s\n", img_filename);
319 continue;
320 }
321
322 strncpy(bigbuf + offset, imgtag, strlen(imgtag) + 1);
323
324 offset += strlen(imgtag);
325 offset += fread(bigbuf + offset, 1, st.st_size, imgfile);
326
327 fclose(imgfile);
328
329 strncpy(bigbuf + offset, "</DATA>",
330 strlen("</DATA>") + 1);
331
332 offset += strlen("</DATA>");
333 }
334
335 if (binary) {
336 strncpy(bigbuf + offset, "</BINARY>",
337 strlen("<BINARY>") + 1);
338
339 err = serv_send_im(gc,
340 (char *)gaim_conversation_get_name(conv),
341 bigbuf, length, imflags);
342 }
343 else
344 err = serv_send_im(gc,
345 (char *)gaim_conversation_get_name(conv),
346 buffy, -1, imflags);
347
348 if (err > 0) {
349 GSList *tempy;
350
351 for (tempy = conv->u.im->images;
352 tempy != NULL;
353 tempy = tempy->next) {
354
355 g_free(tempy->data);
356 }
357
358 g_slist_free(conv->u.im->images);
359 conv->u.im->images = NULL;
360
361 if (binary)
362 gaim_im_write(im, NULL, bigbuf, length,
363 WFLAG_SEND, time(NULL));
364 else
365 gaim_im_write(im, NULL, buffy, -1, WFLAG_SEND,
366 time(NULL));
367
368 if (im_options & OPT_IM_POPDOWN)
369 gaim_window_hide(gaim_conversation_get_window(conv));
370 }
371
372 if (binary)
373 g_free(bigbuf);
374 }
375 else {
376 err = serv_send_im(gc, (char *)gaim_conversation_get_name(conv),
377 buffy, -1, imflags);
378
379 if (err > 0) {
380 gaim_im_write(im, NULL, buf, -1, WFLAG_SEND, time(NULL));
381
382 if (im_options & OPT_IM_POPDOWN)
383 gaim_window_hide(gaim_conversation_get_window(conv));
384 }
385 }
386
387 g_free(buffy);
388 }
389 }
390 else {
391 err = serv_chat_send(gc, gaim_chat_get_id(GAIM_CHAT(conv)), buf);
392 }
393
394 g_free(buf2);
395 g_free(buf);
396
397 if (err < 0) {
398 if (err == -E2BIG)
399 do_error_dialog(_("Unable to send message. "
400 "The message is too large."), NULL,
401 GAIM_ERROR);
402 else if (err == -ENOTCONN)
403 debug_printf("Not yet connected.\n");
404 else
405 do_error_dialog(_("Unable to send message."), NULL, GAIM_ERROR);
406 }
407 else {
408 if (err > 0 && (away_options & OPT_AWAY_BACK_ON_IM)) {
409 if (awaymessage != NULL) {
410 do_im_back();
411 }
412 else if (gc->away) {
413 serv_set_away(gc, GAIM_AWAY_CUSTOM, NULL);
414 }
415 }
416 }
417
418 }
419
420 static void
421 update_conv_indexes(struct gaim_window *win)
422 {
423 GList *l;
424 int i;
425
426 for (l = gaim_window_get_conversations(win), i = 0;
427 l != NULL;
428 l = l->next, i++) {
429
430 struct gaim_conversation *conv = (struct gaim_conversation *)l->data;
431
432 conv->conversation_pos = i;
433 }
434 }
435
436 struct gaim_window *
437 gaim_window_new(void)
438 {
439 struct gaim_window *win;
440
441 win = g_malloc0(sizeof(struct gaim_window));
442
443 win->ui_ops = gaim_get_win_ui_ops();
444
445 if (win->ui_ops != NULL && win->ui_ops->new_window != NULL)
446 win->ui_ops->new_window(win);
447
448 windows = g_list_append(windows, win);
449
450 return win;
451 }
452
453 void
454 gaim_window_destroy(struct gaim_window *win)
455 {
456 struct gaim_window_ui_ops *ops;
457 GList *node;
458
459 if (win == NULL)
460 return;
461
462 ops = gaim_window_get_ui_ops(win);
463
464 /*
465 * If there are any conversations in this, destroy them all. The last
466 * conversation will call gaim_window_destroy(), but this time, this
467 * check will fail and the window will actually be destroyed.
468 *
469 * This is needed because chats may not close right away. They may
470 * wait for notification first. When they get that, the window is
471 * already destroyed, and gaim either crashes or spits out gtk warnings.
472 * The problem is fixed with this check.
473 */
474 if (gaim_window_get_conversation_count(win) > 0) {
475
476 node = g_list_first(gaim_window_get_conversations(win));
477 while(node != NULL)
478 {
479 struct gaim_conversation *conv = node->data;
480
481 node = g_list_next(node);
482
483 gaim_conversation_destroy(conv);
484 }
485 }
486 else
487 {
488 if (ops != NULL && ops->destroy_window != NULL)
489 ops->destroy_window(win);
490
491 g_list_free(gaim_window_get_conversations(win));
492
493 windows = g_list_remove(windows, win);
494
495 g_free(win);
496 }
497 }
498
499 void
500 gaim_window_show(struct gaim_window *win)
501 {
502 struct gaim_window_ui_ops *ops;
503
504 if (win == NULL)
505 return;
506
507 ops = gaim_window_get_ui_ops(win);
508
509 if (ops == NULL || ops->show == NULL)
510 return;
511
512 ops->show(win);
513 }
514
515 void
516 gaim_window_hide(struct gaim_window *win)
517 {
518 struct gaim_window_ui_ops *ops;
519
520 if (win == NULL)
521 return;
522
523 ops = gaim_window_get_ui_ops(win);
524
525 if (ops == NULL || ops->hide == NULL)
526 return;
527
528 ops->hide(win);
529 }
530
531 void
532 gaim_window_raise(struct gaim_window *win)
533 {
534 struct gaim_window_ui_ops *ops;
535
536 if (win == NULL)
537 return;
538
539 ops = gaim_window_get_ui_ops(win);
540
541 if (ops == NULL || ops->raise == NULL)
542 return;
543
544 ops->raise(win);
545 }
546
547 void
548 gaim_window_flash(struct gaim_window *win)
549 {
550 struct gaim_window_ui_ops *ops;
551
552 if (win == NULL)
553 return;
554
555 ops = gaim_window_get_ui_ops(win);
556
557 if (ops == NULL || ops->flash == NULL)
558 return;
559
560 ops->flash(win);
561 }
562
563 void
564 gaim_window_set_ui_ops(struct gaim_window *win, struct gaim_window_ui_ops *ops)
565 {
566 struct gaim_conversation_ui_ops *conv_ops = NULL;
567 GList *l;
568
569 if (win == NULL || win->ui_ops == ops)
570 return;
571
572 if (ops != NULL) {
573 if (ops->get_conversation_ui_ops != NULL)
574 conv_ops = ops->get_conversation_ui_ops();
575 }
576
577 if (win->ui_ops != NULL) {
578 if (win->ui_ops->destroy_window != NULL)
579 win->ui_ops->destroy_window(win);
580 }
581
582 win->ui_ops = ops;
583
584 if (win->ui_ops != NULL) {
585 if (win->ui_ops->new_window != NULL)
586 win->ui_ops->new_window(win);
587 }
588
589 for (l = gaim_window_get_conversations(win);
590 l != NULL;
591 l = l->next) {
592
593 struct gaim_conversation *conv = (struct gaim_conversation *)l;
594
595 gaim_conversation_set_ui_ops(conv, conv_ops);
596
597 if (win->ui_ops != NULL && win->ui_ops->add_conversation != NULL)
598 win->ui_ops->add_conversation(win, conv);
599 }
600 }
601
602 struct gaim_window_ui_ops *
603 gaim_window_get_ui_ops(const struct gaim_window *win)
604 {
605 if (win == NULL)
606 return NULL;
607
608 return win->ui_ops;
609 }
610
611 int
612 gaim_window_add_conversation(struct gaim_window *win,
613 struct gaim_conversation *conv)
614 {
615 struct gaim_window_ui_ops *ops;
616
617 if (win == NULL || conv == NULL)
618 return -1;
619
620 if (gaim_conversation_get_window(conv) != NULL) {
621 gaim_window_remove_conversation(
622 gaim_conversation_get_window(conv),
623 gaim_conversation_get_index(conv));
624 }
625
626 ops = gaim_window_get_ui_ops(win);
627
628 win->conversations = g_list_append(win->conversations, conv);
629 win->conversation_count++;
630
631 conv->conversation_pos = win->conversation_count - 1;
632
633 if (ops != NULL) {
634 conv->window = win;
635
636 if (ops->get_conversation_ui_ops != NULL)
637 gaim_conversation_set_ui_ops(conv, ops->get_conversation_ui_ops());
638
639 if (ops->add_conversation != NULL)
640 ops->add_conversation(win, conv);
641 }
642
643 return win->conversation_count - 1;
644 }
645
646 struct gaim_conversation *
647 gaim_window_remove_conversation(struct gaim_window *win, unsigned int index)
648 {
649 struct gaim_window_ui_ops *ops;
650 struct gaim_conversation *conv;
651 GList *node;
652
653 if (win == NULL || index >= gaim_window_get_conversation_count(win))
654 return NULL;
655
656 ops = gaim_window_get_ui_ops(win);
657
658 node = g_list_nth(gaim_window_get_conversations(win), index);
659 conv = (struct gaim_conversation *)node->data;
660
661 if (ops != NULL && ops->remove_conversation != NULL)
662 ops->remove_conversation(win, conv);
663
664 win->conversations = g_list_remove_link(win->conversations, node);
665
666 g_list_free_1(node);
667
668 win->conversation_count--;
669
670 conv->window = NULL;
671
672 if (gaim_window_get_conversation_count(win) == 0)
673 gaim_window_destroy(win);
674 else {
675 /* Change all the indexes. */
676 update_conv_indexes(win);
677 }
678
679 return conv;
680 }
681
682 void
683 gaim_window_move_conversation(struct gaim_window *win, unsigned int index,
684 unsigned int new_index)
685 {
686 struct gaim_window_ui_ops *ops;
687 struct gaim_conversation *conv;
688 GList *l;
689
690 if (win == NULL || index >= gaim_window_get_conversation_count(win) ||
691 index == new_index)
692 return;
693
694 /* We can't move this past the last index. */
695 if (new_index > gaim_window_get_conversation_count(win))
696 new_index = gaim_window_get_conversation_count(win);
697
698 /* Get the list item for this conversation at its current index. */
699 l = g_list_nth(gaim_window_get_conversations(win), index);
700
701 if (l == NULL) {
702 /* Should never happen. */
703 debug_printf("Misordered conversations list in window %p\n", win);
704
705 return;
706 }
707
708 conv = (struct gaim_conversation *)l->data;
709
710 /* Update the UI part of this. */
711 ops = gaim_window_get_ui_ops(win);
712
713 if (ops != NULL && ops->move_conversation != NULL)
714 ops->move_conversation(win, conv, new_index);
715
716 if (new_index > index)
717 new_index--;
718
719 /* Remove the old one. */
720 win->conversations = g_list_delete_link(win->conversations, l);
721
722 /* Insert it where it should go. */
723 win->conversations = g_list_insert(win->conversations, conv, new_index);
724
725 update_conv_indexes(win);
726 }
727
728 struct gaim_conversation *
729 gaim_window_get_conversation_at(const struct gaim_window *win,
730 unsigned int index)
731 {
732 if (win == NULL || index >= gaim_window_get_conversation_count(win))
733 return NULL;
734
735 return (struct gaim_conversation *)g_list_nth_data(
736 gaim_window_get_conversations(win), index);
737 }
738
739 size_t
740 gaim_window_get_conversation_count(const struct gaim_window *win)
741 {
742 if (win == NULL)
743 return 0;
744
745 return win->conversation_count;
746 }
747
748 void
749 gaim_window_switch_conversation(struct gaim_window *win, unsigned int index)
750 {
751 struct gaim_window_ui_ops *ops;
752
753 if (win == NULL || index < 0 ||
754 index >= gaim_window_get_conversation_count(win))
755 return;
756
757 ops = gaim_window_get_ui_ops(win);
758
759 if (ops != NULL && ops->switch_conversation != NULL)
760 ops->switch_conversation(win, index);
761
762 gaim_conversation_set_unseen(
763 gaim_window_get_conversation_at(win, index), 0);
764 }
765
766 struct gaim_conversation *
767 gaim_window_get_active_conversation(const struct gaim_window *win)
768 {
769 struct gaim_window_ui_ops *ops;
770
771 if (win == NULL)
772 return NULL;
773
774 ops = gaim_window_get_ui_ops(win);
775
776 if (ops != NULL && ops->get_active_index != NULL)
777 return gaim_window_get_conversation_at(win, ops->get_active_index(win));
778
779 return NULL;
780 }
781
782 GList *
783 gaim_window_get_conversations(const struct gaim_window *win)
784 {
785 if (win == NULL)
786 return NULL;
787
788 return win->conversations;
789 }
790
791 GList *
792 gaim_get_windows(void)
793 {
794 return windows;
795 }
796
797 struct gaim_window *
798 gaim_get_first_window_with_type(GaimConversationType type)
799 {
800 GList *wins, *convs;
801 struct gaim_window *win;
802 struct gaim_conversation *conv;
803
804 if (type == GAIM_CONV_UNKNOWN)
805 return NULL;
806
807 for (wins = gaim_get_windows(); wins != NULL; wins = wins->next) {
808 win = (struct gaim_window *)wins->data;
809
810 for (convs = gaim_window_get_conversations(win);
811 convs != NULL;
812 convs = convs->next) {
813
814 conv = (struct gaim_conversation *)convs->data;
815
816 if (gaim_conversation_get_type(conv) == type)
817 return win;
818 }
819 }
820
821 return NULL;
822 }
823
824 struct gaim_window *
825 gaim_get_last_window_with_type(GaimConversationType type)
826 {
827 GList *wins, *convs;
828 struct gaim_window *win;
829 struct gaim_conversation *conv;
830
831 if (type == GAIM_CONV_UNKNOWN)
832 return NULL;
833
834 for (wins = g_list_last(gaim_get_windows());
835 wins != NULL;
836 wins = wins->prev) {
837
838 win = (struct gaim_window *)wins->data;
839
840 for (convs = gaim_window_get_conversations(win);
841 convs != NULL;
842 convs = convs->next) {
843
844 conv = (struct gaim_conversation *)convs->data;
845
846 if (gaim_conversation_get_type(conv) == type)
847 return win;
848 }
849 }
850
851 return NULL;
852 }
853
854 /**************************************************************************
855 * Conversation API
856 **************************************************************************/
857 struct gaim_conversation *
858 gaim_conversation_new(GaimConversationType type, struct gaim_account *account,
859 const char *name)
860 {
861 struct gaim_conversation *conv;
862
863 if (type == GAIM_CONV_UNKNOWN)
864 return NULL;
865
866 /* Check if this conversation already exists. */
867 if ((conv = gaim_find_conversation_with_account(name, account)) != NULL)
868 return conv;
869
870 conv = g_malloc0(sizeof(struct gaim_conversation));
871
872 conv->type = type;
873 conv->account = account;
874 conv->name = g_strdup(name);
875 conv->title = g_strdup(name);
876 conv->send_history = g_list_append(NULL, NULL);
877 conv->history = g_string_new("");
878 conv->data = g_hash_table_new_full(g_str_hash, g_str_equal,
879 g_free, NULL);
880
881 if (type == GAIM_CONV_IM)
882 {
883 conv->u.im = g_malloc0(sizeof(struct gaim_im));
884 conv->u.im->conv = conv;
885
886 ims = g_list_append(ims, conv);
887
888 gaim_conversation_set_logging(conv,
889 (logging_options & OPT_LOG_CONVOS));
890 }
891 else if (type == GAIM_CONV_CHAT)
892 {
893 conv->u.chat = g_malloc0(sizeof(struct gaim_chat));
894 conv->u.chat->conv = conv;
895
896 chats = g_list_append(chats, conv);
897
898 gaim_conversation_set_logging(conv, (logging_options & OPT_LOG_CHATS));
899 }
900
901 conversations = g_list_append(conversations, conv);
902
903 /* Auto-set the title. */
904 gaim_conversation_autoset_title(conv);
905
906 /*
907 * Create a window if one does not exist. If it does, use the last
908 * created window.
909 */
910 if (windows == NULL ||
911 (type == GAIM_CONV_IM && !(im_options & OPT_IM_ONE_WINDOW)) ||
912 (type == GAIM_CONV_CHAT && !(chat_options & OPT_CHAT_ONE_WINDOW))) {
913 struct gaim_window *win;
914
915 win = gaim_window_new();
916 gaim_window_add_conversation(win, conv);
917
918 /* Ensure the window is visible. */
919 gaim_window_show(win);
920 }
921 else {
922 if (place_conv == NULL)
923 gaim_conv_placement_set_active(0);
924
925 place_conv(conv);
926 }
927
928 plugin_event(event_new_conversation, name);
929
930 return conv;
931 }
932
933 void
934 gaim_conversation_destroy(struct gaim_conversation *conv)
935 {
936 struct gaim_window *win;
937 struct gaim_conversation_ui_ops *ops;
938 struct gaim_connection *gc;
939 const char *name;
940 GList *node;
941
942 if (conv == NULL)
943 return;
944
945 win = gaim_conversation_get_window(conv);
946 ops = gaim_conversation_get_ui_ops(conv);
947 gc = gaim_conversation_get_gc(conv);
948 name = gaim_conversation_get_name(conv);
949
950 if (gaim_conversation_get_type(conv) == GAIM_CONV_IM) {
951 if (!(misc_options & OPT_MISC_STEALTH_TYPING))
952 serv_send_typing(gc, (char *)name, NOT_TYPING);
953
954 if (gc && gc->prpl->convo_closed != NULL)
955 gc->prpl->convo_closed(gc, (char *)name);
956 }
957 else if (gaim_conversation_get_type(conv) == GAIM_CONV_CHAT) {
958 /*
959 * This is unfortunately necessary, because calling serv_chat_leave()
960 * calls this gaim_conversation_destroy(), which leads to two calls
961 * here.. We can't just return after this, because then it'll return
962 * on the next pass. So, since serv_got_chat_left(), which is
963 * eventually called from the prpl that serv_chat_leave() calls,
964 * removes this conversation from the gc's buddy_chats list, we're
965 * going to check to see if this exists in the list. If so, we want
966 * to return after calling this, because it'll be called again. If not,
967 * fall through, because it'll have already been removed, and we'd
968 * be on the 2nd pass.
969 *
970 * Long paragraph. <-- Short sentence.
971 *
972 * -- ChipX86
973 */
974
975 if (gc && g_slist_find(gc->buddy_chats, conv) != NULL) {
976 serv_chat_leave(gc, gaim_chat_get_id(GAIM_CHAT(conv)));
977
978 return;
979 }
980 }
981
982 plugin_event(event_del_conversation, conv);
983
984 if (conv->name != NULL) g_free(conv->name);
985 if (conv->title != NULL) g_free(conv->title);
986
987 for (node = g_list_first(conv->send_history);
988 node != NULL;
989 node = g_list_next(node)) {
990
991 if (node->data != NULL)
992 g_free(node->data);
993 }
994
995 g_list_free(g_list_first(conv->send_history));
996
997 if (conv->history != NULL)
998 g_string_free(conv->history, TRUE);
999
1000 conversations = g_list_remove(conversations, conv);
1001
1002 if (conv->type == GAIM_CONV_IM) {
1003 GSList *snode;
1004
1005 gaim_im_stop_typing_timeout(conv->u.im);
1006 gaim_im_stop_type_again_timeout(conv->u.im);
1007
1008 for (snode = conv->u.im->images; snode != NULL; snode = snode->next) {
1009 if (snode->data != NULL)
1010 g_free(snode->data);
1011 }
1012
1013 g_slist_free(conv->u.im->images);
1014
1015 g_free(conv->u.im);
1016
1017 ims = g_list_remove(ims, conv);
1018 }
1019 else if (conv->type == GAIM_CONV_CHAT) {
1020
1021 for (node = conv->u.chat->in_room; node != NULL; node = node->next) {
1022 if (node->data != NULL)
1023 g_free(node->data);
1024 }
1025
1026 for (node = conv->u.chat->ignored; node != NULL; node = node->next) {
1027 if (node->data != NULL)
1028 g_free(node->data);
1029 }
1030
1031 g_list_free(conv->u.chat->in_room);
1032 g_list_free(conv->u.chat->ignored);
1033
1034 if (conv->u.chat->who != NULL)
1035 g_free(conv->u.chat->who);
1036
1037 if (conv->u.chat->topic != NULL)
1038 g_free(conv->u.chat->topic);
1039
1040 g_free(conv->u.chat);
1041
1042 chats = g_list_remove(chats, conv);
1043 }
1044
1045 g_hash_table_destroy(conv->data);
1046
1047 if (win != NULL) {
1048 gaim_window_remove_conversation(win,
1049 gaim_conversation_get_index(conv));
1050 }
1051
1052 if (ops != NULL && ops->destroy_conversation != NULL)
1053 ops->destroy_conversation(conv);
1054
1055 g_free(conv);
1056 }
1057
1058 GaimConversationType
1059 gaim_conversation_get_type(const struct gaim_conversation *conv)
1060 {
1061 if (conv == NULL)
1062 return GAIM_CONV_UNKNOWN;
1063
1064 return conv->type;
1065 }
1066
1067 void
1068 gaim_conversation_set_ui_ops(struct gaim_conversation *conv,
1069 struct gaim_conversation_ui_ops *ops)
1070 {
1071 if (conv == NULL || conv->ui_ops == ops)
1072 return;
1073
1074 if (conv->ui_ops != NULL && conv->ui_ops->destroy_conversation != NULL)
1075 conv->ui_ops->destroy_conversation(conv);
1076
1077 conv->ui_data = NULL;
1078
1079 conv->ui_ops = ops;
1080 }
1081
1082 struct gaim_conversation_ui_ops *
1083 gaim_conversation_get_ui_ops(struct gaim_conversation *conv)
1084 {
1085 if (conv == NULL)
1086 return NULL;
1087
1088 return conv->ui_ops;
1089 }
1090
1091 void
1092 gaim_conversation_set_account(struct gaim_conversation *conv,
1093 struct gaim_account *account)
1094 {
1095 if (conv == NULL || account == gaim_conversation_get_account(conv))
1096 return;
1097
1098 conv->account = account;
1099
1100 gaim_conversation_update(conv, GAIM_CONV_UPDATE_ACCOUNT);
1101 }
1102
1103 struct gaim_account *
1104 gaim_conversation_get_account(const struct gaim_conversation *conv)
1105 {
1106 if (conv == NULL)
1107 return NULL;
1108
1109 return conv->account;
1110 }
1111
1112 struct gaim_connection *
1113 gaim_conversation_get_gc(const struct gaim_conversation *conv)
1114 {
1115 struct gaim_account *account;
1116
1117 if (conv == NULL)
1118 return NULL;
1119
1120 account = gaim_conversation_get_account(conv);
1121
1122 if (account == NULL)
1123 return NULL;
1124
1125 return account->gc;
1126 }
1127
1128 void
1129 gaim_conversation_set_title(struct gaim_conversation *conv, const char *title)
1130 {
1131 struct gaim_conversation_ui_ops *ops;
1132
1133 if (conv == NULL || title == NULL)
1134 return;
1135
1136 if (conv->title != NULL)
1137 g_free(conv->title);
1138
1139 conv->title = g_strdup(title);
1140
1141 ops = gaim_conversation_get_ui_ops(conv);
1142
1143 if (ops != NULL && ops->set_title != NULL)
1144 ops->set_title(conv, conv->title);
1145 }
1146
1147 const char *
1148 gaim_conversation_get_title(const struct gaim_conversation *conv)
1149 {
1150 if (conv == NULL)
1151 return NULL;
1152
1153 return conv->title;
1154 }
1155
1156 void
1157 gaim_conversation_autoset_title(struct gaim_conversation *conv)
1158 {
1159 struct gaim_account *account;
1160 struct buddy *b;
1161 const char *text, *name;
1162
1163 if (conv == NULL)
1164 return;
1165
1166 account = gaim_conversation_get_account(conv);
1167 name = gaim_conversation_get_name(conv);
1168
1169 if (((im_options & OPT_IM_ALIAS_TAB) == OPT_IM_ALIAS_TAB) &&
1170 account != NULL && ((b = gaim_find_buddy(account, name)) != NULL)) {
1171
1172 text = gaim_get_buddy_alias(b);
1173 }
1174 else
1175 text = name;
1176
1177 gaim_conversation_set_title(conv, text);
1178 }
1179
1180 int
1181 gaim_conversation_get_index(const struct gaim_conversation *conv)
1182 {
1183 if (conv == NULL)
1184 return 0;
1185
1186 return conv->conversation_pos;
1187 }
1188
1189 void
1190 gaim_conversation_set_unseen(struct gaim_conversation *conv,
1191 GaimUnseenState state)
1192 {
1193 if (conv == NULL)
1194 return;
1195
1196 conv->unseen = state;
1197
1198 gaim_conversation_update(conv, GAIM_CONV_UPDATE_UNSEEN);
1199 }
1200
1201 void
1202 gaim_conversation_foreach(void (*func)(struct gaim_conversation *conv))
1203 {
1204 struct gaim_conversation *conv;
1205 GList *l;
1206
1207 if (func == NULL)
1208 return;
1209
1210 for (l = gaim_get_conversations(); l != NULL; l = l->next) {
1211 conv = (struct gaim_conversation *)l->data;
1212
1213 func(conv);
1214 }
1215 }
1216
1217 GaimUnseenState
1218 gaim_conversation_get_unseen(const struct gaim_conversation *conv)
1219 {
1220 if (conv == NULL)
1221 return 0;
1222
1223 return conv->unseen;
1224 }
1225
1226 const char *
1227 gaim_conversation_get_name(const struct gaim_conversation *conv)
1228 {
1229 if (conv == NULL)
1230 return NULL;
1231
1232 return conv->name;
1233 }
1234
1235 void
1236 gaim_conversation_set_logging(struct gaim_conversation *conv, gboolean log)
1237 {
1238 if (conv == NULL)
1239 return;
1240
1241 conv->logging = log;
1242
1243 gaim_conversation_update(conv, GAIM_CONV_UPDATE_LOGGING);
1244 }
1245
1246 gboolean
1247 gaim_conversation_is_logging(const struct gaim_conversation *conv)
1248 {
1249 if (conv == NULL)
1250 return FALSE;
1251
1252 return conv->logging;
1253 }
1254
1255 GList *
1256 gaim_conversation_get_send_history(const struct gaim_conversation *conv)
1257 {
1258 if (conv == NULL)
1259 return NULL;
1260
1261 return conv->send_history;
1262 }
1263
1264 void
1265 gaim_conversation_set_history(struct gaim_conversation *conv,
1266 GString *history)
1267 {
1268 if (conv == NULL)
1269 return;
1270
1271 conv->history = history;
1272 }
1273
1274 GString *
1275 gaim_conversation_get_history(const struct gaim_conversation *conv)
1276 {
1277 if (conv == NULL)
1278 return NULL;
1279
1280 return conv->history;
1281 }
1282
1283 struct gaim_window *
1284 gaim_conversation_get_window(const struct gaim_conversation *conv)
1285 {
1286 if (conv == NULL)
1287 return NULL;
1288
1289 return conv->window;
1290 }
1291
1292 struct gaim_im *
1293 gaim_conversation_get_im_data(const struct gaim_conversation *conv)
1294 {
1295 if (conv == NULL)
1296 return NULL;
1297
1298 if (gaim_conversation_get_type(conv) != GAIM_CONV_IM)
1299 return NULL;
1300
1301 return conv->u.im;
1302 }
1303
1304 struct gaim_chat *
1305 gaim_conversation_get_chat_data(const struct gaim_conversation *conv)
1306 {
1307 if (conv == NULL)
1308 return NULL;
1309
1310 if (gaim_conversation_get_type(conv) != GAIM_CONV_CHAT)
1311 return NULL;
1312
1313 return conv->u.chat;
1314 }
1315
1316 void
1317 gaim_conversation_set_data(struct gaim_conversation *conv, const char *key,
1318 gpointer data)
1319 {
1320 if (conv == NULL || key == NULL)
1321 return;
1322
1323 g_hash_table_replace(conv->data, g_strdup(key), data);
1324 }
1325
1326 gpointer
1327 gaim_conversation_get_data(struct gaim_conversation *conv, const char *key)
1328 {
1329 if (conv == NULL || key == NULL)
1330 return NULL;
1331
1332 return g_hash_table_lookup(conv->data, key);
1333 }
1334
1335 GList *
1336 gaim_get_conversations(void)
1337 {
1338 return conversations;
1339 }
1340
1341 GList *
1342 gaim_get_ims(void)
1343 {
1344 return ims;
1345 }
1346
1347 GList *
1348 gaim_get_chats(void)
1349 {
1350 return chats;
1351 }
1352
1353 struct gaim_conversation *
1354 gaim_find_conversation(const char *name)
1355 {
1356 struct gaim_conversation *c = NULL;
1357 char *cuser;
1358 GList *cnv;
1359
1360 if (name == NULL)
1361 return NULL;
1362
1363 cuser = g_strdup(normalize(name));
1364
1365 for (cnv = gaim_get_conversations(); cnv != NULL; cnv = cnv->next) {
1366 c = (struct gaim_conversation *)cnv->data;
1367
1368 if (!gaim_utf8_strcasecmp(cuser, normalize(gaim_conversation_get_name(c))))
1369 break;
1370
1371 c = NULL;
1372 }
1373
1374 g_free(cuser);
1375
1376 return c;
1377 }
1378
1379 struct gaim_conversation *
1380 gaim_find_conversation_with_account(const char *name, const struct gaim_account *account)
1381 {
1382 struct gaim_conversation *c = NULL;
1383 char *cuser;
1384 GList *cnv;
1385
1386 if (name == NULL)
1387 return NULL;
1388
1389 cuser = g_strdup(normalize(name));
1390
1391 for (cnv = gaim_get_conversations(); cnv != NULL; cnv = cnv->next) {
1392 c = (struct gaim_conversation *)cnv->data;
1393
1394 if (!gaim_utf8_strcasecmp(cuser, normalize(gaim_conversation_get_name(c))) &&
1395 account == gaim_conversation_get_account(c)) {
1396
1397 break;
1398 }
1399
1400 c = NULL;
1401 }
1402
1403 g_free(cuser);
1404
1405 return c;
1406 }
1407
1408 void
1409 gaim_conversation_write(struct gaim_conversation *conv, const char *who,
1410 const char *message, size_t length, int flags,
1411 time_t mtime)
1412 {
1413 struct gaim_account *account;
1414 struct gaim_conversation_ui_ops *ops;
1415 struct gaim_window *win;
1416 struct buddy *b;
1417 GaimUnseenState unseen;
1418 /* int logging_font_options = 0; */
1419
1420 if (conv == NULL || message == NULL)
1421 return;
1422
1423 ops = gaim_conversation_get_ui_ops(conv);
1424
1425 if (ops == NULL || ops->write_conv == NULL)
1426 return;
1427
1428 account = gaim_conversation_get_account(conv);
1429
1430 if (gaim_conversation_get_type(conv) == GAIM_CONV_CHAT &&
1431 (account->gc == NULL || !g_slist_find(account->gc->buddy_chats, conv)))
1432 return;
1433
1434 if (gaim_conversation_get_type(conv) == GAIM_CONV_IM &&
1435 !g_list_find(gaim_get_conversations(), conv))
1436 return;
1437
1438 if (gaim_conversation_get_type(conv) == GAIM_CONV_IM ||
1439 !(account->gc->prpl->options & OPT_PROTO_UNIQUE_CHATNAME)) {
1440
1441 if (who == NULL) {
1442 if (flags & WFLAG_SEND) {
1443 b = gaim_find_buddy(account, account->gc->username);
1444 if (b != NULL && strcmp(b->name, gaim_get_buddy_alias(b)))
1445 who = gaim_get_buddy_alias(b);
1446 else if (*account->alias)
1447 who = account->alias;
1448 else if (*account->gc->displayname)
1449 who = account->gc->displayname;
1450 else
1451 who = account->gc->username;
1452 }
1453 else {
1454 b = gaim_find_buddy(account, gaim_conversation_get_name(conv));
1455
1456 if (b != NULL)
1457 who = gaim_get_buddy_alias(b);
1458 else
1459 who = gaim_conversation_get_name(conv);
1460 }
1461 }
1462 else {
1463 b = gaim_find_buddy(account, who);
1464
1465 if (b != NULL)
1466 who = gaim_get_buddy_alias(b);
1467 }
1468 }
1469
1470 ops->write_conv(conv, who, message, length, flags, mtime);
1471
1472 win = gaim_conversation_get_window(conv);
1473
1474 if (!(flags & WFLAG_NOLOG) &&
1475 ((gaim_conversation_get_type(conv) == GAIM_CONV_CHAT &&
1476 (chat_options & OPT_CHAT_POPUP)) ||
1477 (gaim_conversation_get_type(conv) == GAIM_CONV_IM &&
1478 (im_options & OPT_IM_POPUP)))) {
1479
1480 gaim_window_show(win);
1481 }
1482
1483 /* Tab highlighting */
1484 if (!(flags & WFLAG_RECV) && !(flags & WFLAG_SYSTEM))
1485 return;
1486
1487 if (gaim_conversation_get_type(conv) == GAIM_CONV_IM) {
1488 if ((flags & WFLAG_RECV) == WFLAG_RECV)
1489 gaim_im_set_typing_state(GAIM_IM(conv), NOT_TYPING);
1490 }
1491
1492 if (gaim_window_get_active_conversation(win) != conv) {
1493 if ((flags & WFLAG_NICK) == WFLAG_NICK ||
1494 gaim_conversation_get_unseen(conv) == GAIM_UNSEEN_NICK)
1495 unseen = GAIM_UNSEEN_NICK;
1496 else
1497 unseen = GAIM_UNSEEN_TEXT;
1498 }
1499 else
1500 unseen = GAIM_UNSEEN_NONE;
1501
1502 gaim_conversation_set_unseen(conv, unseen);
1503 }
1504
1505 void
1506 gaim_conversation_update_progress(struct gaim_conversation *conv,
1507 float percent)
1508 {
1509 struct gaim_conversation_ui_ops *ops;
1510
1511 if (conv == NULL)
1512 return;
1513
1514 if (percent < 0)
1515 percent = 0;
1516
1517 /*
1518 * NOTE: A percent >= 1 indicates that the progress bar should be
1519 * closed.
1520 */
1521 ops = gaim_conversation_get_ui_ops(conv);
1522
1523 if (ops != NULL && ops->update_progress != NULL)
1524 ops->update_progress(conv, percent);
1525 }
1526
1527 void
1528 gaim_conversation_update(struct gaim_conversation *conv,
1529 GaimConvUpdateType type)
1530 {
1531 struct gaim_conversation_ui_ops *ops;
1532
1533 if (conv == NULL)
1534 return;
1535
1536 ops = gaim_conversation_get_ui_ops(conv);
1537
1538 if (ops != NULL && ops->updated != NULL)
1539 ops->updated(conv, type);
1540 }
1541
1542 /**************************************************************************
1543 * IM Conversation API
1544 **************************************************************************/
1545 struct gaim_conversation *
1546 gaim_im_get_conversation(struct gaim_im *im)
1547 {
1548 if (im == NULL)
1549 return NULL;
1550
1551 return im->conv;
1552 }
1553
1554 void
1555 gaim_im_set_typing_state(struct gaim_im *im, int state)
1556 {
1557 if (im == NULL)
1558 return;
1559
1560 im->typing_state = state;
1561 }
1562
1563 int
1564 gaim_im_get_typing_state(const struct gaim_im *im)
1565 {
1566 if (im == NULL)
1567 return 0;
1568
1569 return im->typing_state;
1570 }
1571
1572 void
1573 gaim_im_start_typing_timeout(struct gaim_im *im, int timeout)
1574 {
1575 struct gaim_conversation *conv;
1576 const char *name;
1577
1578 if (im == NULL)
1579 return;
1580
1581 if (im->typing_timeout > 0)
1582 gaim_im_stop_typing_timeout(im);
1583
1584 conv = gaim_im_get_conversation(im);
1585 name = gaim_conversation_get_name(conv);
1586
1587 im->typing_timeout = g_timeout_add_full(G_PRIORITY_DEFAULT_IDLE,
1588 timeout * 1000, reset_typing, g_strdup(name), g_free);
1589 }
1590
1591 void
1592 gaim_im_stop_typing_timeout(struct gaim_im *im)
1593 {
1594 if (im == NULL)
1595 return;
1596
1597 if (im->typing_timeout == 0)
1598 return;
1599
1600 g_source_remove(im->typing_timeout);
1601 im->typing_timeout = 0;
1602 }
1603
1604 guint
1605 gaim_im_get_typing_timeout(const struct gaim_im *im)
1606 {
1607 if (im == NULL)
1608 return 0;
1609
1610 return im->typing_timeout;
1611 }
1612
1613 void
1614 gaim_im_set_type_again(struct gaim_im *im, time_t val)
1615 {
1616 if (im == NULL)
1617 return;
1618
1619 im->type_again = val;
1620 }
1621
1622 time_t
1623 gaim_im_get_type_again(const struct gaim_im *im)
1624 {
1625 if (im == NULL)
1626 return 0;
1627
1628 return im->type_again;
1629 }
1630
1631 void
1632 gaim_im_start_type_again_timeout(struct gaim_im *im)
1633 {
1634 if (im == NULL)
1635 return;
1636
1637 im->type_again_timeout = g_timeout_add(SEND_TYPED_TIMEOUT, send_typed,
1638 gaim_im_get_conversation(im));
1639 }
1640
1641 void
1642 gaim_im_stop_type_again_timeout(struct gaim_im *im)
1643 {
1644 if (im == NULL)
1645 return;
1646
1647 if (im->type_again_timeout == 0)
1648 return;
1649
1650 g_source_remove(im->type_again_timeout);
1651 im->type_again_timeout = 0;
1652 }
1653
1654 guint
1655 gaim_im_get_type_again_timeout(const struct gaim_im *im)
1656 {
1657 if (im == NULL)
1658 return 0;
1659
1660 return im->type_again_timeout;
1661 }
1662
1663 void
1664 gaim_im_update_typing(struct gaim_im *im)
1665 {
1666 if (im == NULL)
1667 return;
1668
1669 gaim_conversation_update(gaim_im_get_conversation(im),
1670 GAIM_CONV_UPDATE_TYPING);
1671 }
1672
1673 void
1674 gaim_im_write(struct gaim_im *im, const char *who, const char *message,
1675 size_t len, int flags, time_t mtime)
1676 {
1677 struct gaim_conversation *c;
1678
1679 if (im == NULL || message == NULL)
1680 return;
1681
1682 c = gaim_im_get_conversation(im);
1683
1684 /* Raise the window, if specified in prefs. */
1685 if (!(flags & WFLAG_NOLOG) & (im_options & OPT_IM_POPUP))
1686 gaim_window_raise(gaim_conversation_get_window(c));
1687
1688 if (c->ui_ops != NULL && c->ui_ops->write_im != NULL)
1689 c->ui_ops->write_im(c, who, message, len, flags, mtime);
1690 else
1691 gaim_conversation_write(c, who, message, -1, flags, mtime);
1692 }
1693
1694 void
1695 gaim_im_send(struct gaim_im *im, const char *message)
1696 {
1697 if (im == NULL || message == NULL)
1698 return;
1699
1700 common_send(gaim_im_get_conversation(im), message);
1701 }
1702
1703 /**************************************************************************
1704 * Chat Conversation API
1705 **************************************************************************/
1706
1707 struct gaim_conversation *
1708 gaim_chat_get_conversation(struct gaim_chat *chat)
1709 {
1710 if (chat == NULL)
1711 return NULL;
1712
1713 return chat->conv;
1714 }
1715
1716 GList *
1717 gaim_chat_set_users(struct gaim_chat *chat, GList *users)
1718 {
1719 if (chat == NULL)
1720 return NULL;
1721
1722 chat->in_room = users;
1723
1724 return users;
1725 }
1726
1727 GList *
1728 gaim_chat_get_users(const struct gaim_chat *chat)
1729 {
1730 if (chat == NULL)
1731 return NULL;
1732
1733 return chat->in_room;
1734 }
1735
1736 void
1737 gaim_chat_ignore(struct gaim_chat *chat, const char *name)
1738 {
1739 if (chat == NULL || name == NULL)
1740 return;
1741
1742 /* Make sure the user isn't already ignored. */
1743 if (gaim_chat_is_user_ignored(chat, name))
1744 return;
1745
1746 gaim_chat_set_ignored(chat,
1747 g_list_append(gaim_chat_get_ignored(chat), g_strdup(name)));
1748 }
1749
1750 void
1751 gaim_chat_unignore(struct gaim_chat *chat, const char *name)
1752 {
1753 GList *item;
1754
1755 if (chat == NULL || name == NULL)
1756 return;
1757
1758 /* Make sure the user is actually ignored. */
1759 if (!gaim_chat_is_user_ignored(chat, name))
1760 return;
1761
1762 item = g_list_find(gaim_chat_get_ignored(chat),
1763 gaim_chat_get_ignored_user(chat, name));
1764
1765 gaim_chat_set_ignored(chat,
1766 g_list_remove_link(gaim_chat_get_ignored(chat), item));
1767
1768 g_free(item->data);
1769 g_list_free_1(item);
1770 }
1771
1772 GList *
1773 gaim_chat_set_ignored(struct gaim_chat *chat, GList *ignored)
1774 {
1775 if (chat == NULL)
1776 return NULL;
1777
1778 chat->ignored = ignored;
1779
1780 return ignored;
1781 }
1782
1783 GList *
1784 gaim_chat_get_ignored(const struct gaim_chat *chat)
1785 {
1786 if (chat == NULL)
1787 return NULL;
1788
1789 return chat->ignored;
1790 }
1791
1792 const char *
1793 gaim_chat_get_ignored_user(const struct gaim_chat *chat, const char *user)
1794 {
1795 GList *ignored;
1796
1797 if (chat == NULL || user == NULL)
1798 return NULL;
1799
1800 for (ignored = gaim_chat_get_ignored(chat);
1801 ignored != NULL;
1802 ignored = ignored->next) {
1803
1804 const char *ign = (const char *)ignored->data;
1805
1806 if (!gaim_utf8_strcasecmp(user, ign) ||
1807 ((*ign == '+' || *ign == '%') && !gaim_utf8_strcasecmp(user, ign + 1)))
1808 return ign;
1809
1810 if (*ign == '@') {
1811 ign++;
1812
1813 if ((*ign == '+' && !gaim_utf8_strcasecmp(user, ign + 1)) ||
1814 (*ign != '+' && !gaim_utf8_strcasecmp(user, ign)))
1815 return ign;
1816 }
1817 }
1818
1819 return NULL;
1820 }
1821
1822 gboolean
1823 gaim_chat_is_user_ignored(const struct gaim_chat *chat, const char *user)
1824 {
1825 if (chat == NULL || user == NULL)
1826 return FALSE;
1827
1828 return (gaim_chat_get_ignored_user(chat, user) != NULL);
1829 }
1830
1831 void
1832 gaim_chat_set_topic(struct gaim_chat *chat, const char *who, const char *topic)
1833 {
1834 if (chat == NULL)
1835 return;
1836
1837 if (chat->who != NULL) free(chat->who);
1838 if (chat->topic != NULL) free(chat->topic);
1839
1840 chat->who = (who == NULL ? NULL : g_strdup(who));
1841 chat->topic = (topic == NULL ? NULL : g_strdup(topic));
1842
1843 gaim_conversation_update(gaim_chat_get_conversation(chat),
1844 GAIM_CONV_UPDATE_TOPIC);
1845 }
1846
1847 const char *
1848 gaim_chat_get_topic(const struct gaim_chat *chat)
1849 {
1850 if (chat == NULL)
1851 return NULL;
1852
1853 return chat->topic;
1854 }
1855
1856 void
1857 gaim_chat_set_id(struct gaim_chat *chat, int id)
1858 {
1859 if (chat == NULL)
1860 return;
1861
1862 chat->id = id;
1863 }
1864
1865 int
1866 gaim_chat_get_id(const struct gaim_chat *chat)
1867 {
1868 if (chat == NULL)
1869 return -1;
1870
1871 return chat->id;
1872 }
1873
1874 void
1875 gaim_chat_write(struct gaim_chat *chat, const char *who,
1876 const char *message, int flags, time_t mtime)
1877 {
1878 struct gaim_conversation *conv;
1879 struct gaim_connection *gc;
1880
1881 if (chat == NULL || who == NULL || message == NULL)
1882 return;
1883
1884 conv = gaim_chat_get_conversation(chat);
1885 gc = gaim_conversation_get_gc(conv);
1886
1887 /* Don't display this if the person who wrote it is ignored. */
1888 if (gaim_chat_is_user_ignored(chat, who))
1889 return;
1890
1891 /* Raise the window, if specified in prefs. */
1892 if (!(flags & WFLAG_NOLOG) & (chat_options & OPT_CHAT_POPUP))
1893 gaim_window_raise(gaim_conversation_get_window(conv));
1894
1895 if (!(flags & WFLAG_WHISPER)) {
1896 char *str;
1897
1898 str = g_strdup(normalize(who));
1899
1900 if (!gaim_utf8_strcasecmp(str, normalize(gc->username)) ||
1901 !gaim_utf8_strcasecmp(str, normalize(gc->displayname))) {
1902
1903 flags |= WFLAG_SEND;
1904 }
1905 else {
1906 flags |= WFLAG_RECV;
1907
1908 if (find_nick(gc, message))
1909 flags |= WFLAG_NICK;
1910 }
1911
1912 g_free(str);
1913 }
1914
1915 /* Pass this on to either the ops structure or the default write func. */
1916 if (conv->ui_ops != NULL && conv->ui_ops->write_chat != NULL)
1917 conv->ui_ops->write_chat(conv, who, message, flags, mtime);
1918 else
1919 gaim_conversation_write(conv, who, message, -1, flags, mtime);
1920 }
1921
1922 void
1923 gaim_chat_send(struct gaim_chat *chat, const char *message)
1924 {
1925 if (chat == NULL || message == NULL)
1926 return;
1927
1928 common_send(gaim_chat_get_conversation(chat), message);
1929 }
1930
1931 void
1932 gaim_chat_add_user(struct gaim_chat *chat, const char *user,
1933 const char *extra_msg)
1934 {
1935 struct gaim_conversation *conv;
1936 struct gaim_conversation_ui_ops *ops;
1937 char tmp[BUF_LONG];
1938
1939 if (chat == NULL || user == NULL)
1940 return;
1941
1942 conv = gaim_chat_get_conversation(chat);
1943 ops = gaim_conversation_get_ui_ops(conv);
1944
1945 gaim_chat_set_users(chat,
1946 g_list_insert_sorted(gaim_chat_get_users(chat), g_strdup(user),
1947 insertname_compare));
1948
1949 plugin_event(event_chat_buddy_join,
1950 gaim_conversation_get_gc(conv), gaim_chat_get_id(chat),
1951 user);
1952
1953 if (ops != NULL && ops->chat_add_user != NULL)
1954 ops->chat_add_user(conv, user);
1955
1956 if (chat_options & OPT_CHAT_LOGON) {
1957 if (extra_msg == NULL)
1958 g_snprintf(tmp, sizeof(tmp), _("%s entered the room."), user);
1959 else
1960 g_snprintf(tmp, sizeof(tmp),
1961 _("%s [<I>%s</I>] entered the room."),
1962 user, extra_msg);
1963
1964 gaim_conversation_write(conv, NULL, tmp, -1, WFLAG_SYSTEM, time(NULL));
1965 }
1966 }
1967
1968 void
1969 gaim_chat_rename_user(struct gaim_chat *chat, const char *old_user,
1970 const char *new_user)
1971 {
1972 struct gaim_conversation *conv;
1973 struct gaim_conversation_ui_ops *ops;
1974 char tmp[BUF_LONG];
1975 GList *names;
1976
1977 if (chat == NULL || old_user == NULL || new_user == NULL)
1978 return;
1979
1980 conv = gaim_chat_get_conversation(chat);
1981 ops = gaim_conversation_get_ui_ops(conv);
1982
1983 gaim_chat_set_users(chat,
1984 g_list_insert_sorted(gaim_chat_get_users(chat), g_strdup(new_user),
1985 insertname_compare));
1986
1987 if (ops != NULL && ops->chat_rename_user != NULL)
1988 ops->chat_rename_user(conv, old_user, new_user);
1989
1990 for (names = gaim_chat_get_users(chat);
1991 names != NULL;
1992 names = names->next) {
1993
1994 if (!gaim_utf8_strcasecmp((char *)names->data, old_user)) {
1995 gaim_chat_set_users(chat,
1996 g_list_remove(gaim_chat_get_users(chat), names->data));
1997 break;
1998 }
1999 }
2000
2001 if (gaim_chat_is_user_ignored(chat, old_user)) {
2002 gaim_chat_unignore(chat, old_user);
2003 gaim_chat_ignore(chat, new_user);
2004 }
2005 else if (gaim_chat_is_user_ignored(chat, new_user))
2006 gaim_chat_unignore(chat, new_user);
2007
2008 if (chat_options & OPT_CHAT_LOGON) {
2009 g_snprintf(tmp, sizeof(tmp),
2010 _("%s is now known as %s"), old_user, new_user);
2011
2012 gaim_conversation_write(conv, NULL, tmp, -1, WFLAG_SYSTEM, time(NULL));
2013 }
2014 }
2015
2016 void
2017 gaim_chat_remove_user(struct gaim_chat *chat, const char *user,
2018 const char *reason)
2019 {
2020 struct gaim_conversation *conv;
2021 struct gaim_conversation_ui_ops *ops;
2022 char tmp[BUF_LONG];
2023 GList *names;
2024
2025 if (chat == NULL || user == NULL)
2026 return;
2027
2028 conv = gaim_chat_get_conversation(chat);
2029 ops = gaim_conversation_get_ui_ops(conv);
2030
2031 plugin_event(event_chat_buddy_leave, gaim_conversation_get_gc(conv),
2032 gaim_chat_get_id(chat), user);
2033
2034 if (ops != NULL && ops->chat_remove_user != NULL)
2035 ops->chat_remove_user(conv, user);
2036
2037 for (names = gaim_chat_get_users(chat);
2038 names != NULL;
2039 names = names->next) {
2040
2041 if (!gaim_utf8_strcasecmp((char *)names->data, user)) {
2042 gaim_chat_set_users(chat,
2043 g_list_remove(gaim_chat_get_users(chat), names->data));
2044 break;
2045 }
2046 }
2047
2048 /* NOTE: Don't remove them from ignored in case they re-enter. */
2049
2050 if (chat_options & OPT_CHAT_LOGON) {
2051 if (reason != NULL && *reason != '\0')
2052 g_snprintf(tmp, sizeof(tmp),
2053 _("%s left the room (%s)."), user, reason);
2054 else
2055 g_snprintf(tmp, sizeof(tmp), _("%s left the room."), user);
2056
2057 gaim_conversation_write(conv, NULL, tmp, -1, WFLAG_SYSTEM, time(NULL));
2058 }
2059 }
2060
2061 struct gaim_conversation *
2062 gaim_find_chat(struct gaim_connection *gc, int id)
2063 {
2064 GList *l;
2065 struct gaim_conversation *conv;
2066
2067 for (l = gaim_get_chats(); l != NULL; l = l->next) {
2068 conv = (struct gaim_conversation *)l->data;
2069
2070 if (gaim_chat_get_id(GAIM_CHAT(conv)) == id &&
2071 gaim_conversation_get_gc(conv) == gc)
2072 return conv;
2073 }
2074
2075 return NULL;
2076 }
2077
2078 /**************************************************************************
2079 * Conversation placement functions
2080 **************************************************************************/
2081 /* This one places conversations in the last made window. */
2082 static void
2083 conv_placement_last_created_win(struct gaim_conversation *conv)
2084 {
2085 struct gaim_window *win;
2086
2087 if (convo_options & OPT_CONVO_COMBINE)
2088 win = g_list_last(gaim_get_windows())->data;
2089 else
2090 win = gaim_get_last_window_with_type(gaim_conversation_get_type(conv));
2091
2092 if (win == NULL) {
2093 win = gaim_window_new();
2094
2095 gaim_window_add_conversation(win, conv);
2096 gaim_window_show(win);
2097 }
2098 else
2099 gaim_window_add_conversation(win, conv);
2100 }
2101
2102 /* This one places each conversation in its own window. */
2103 static void
2104 conv_placement_new_window(struct gaim_conversation *conv)
2105 {
2106 struct gaim_window *win;
2107
2108 win = gaim_window_new();
2109
2110 gaim_window_add_conversation(win, conv);
2111
2112 gaim_window_show(win);
2113 }
2114
2115 /*
2116 * This groups things by, well, group. Buddies from groups will always be
2117 * grouped together, and a buddy from a group not belonging to any currently
2118 * open windows will get a new window.
2119 */
2120 static void
2121 conv_placement_by_group(struct gaim_conversation *conv)
2122 {
2123 struct gaim_window *win;
2124 GaimConversationType type;
2125
2126 type = gaim_conversation_get_type(conv);
2127
2128 if (type != GAIM_CONV_IM) {
2129 win = gaim_get_last_window_with_type(type);
2130
2131 if (win == NULL)
2132 conv_placement_new_window(conv);
2133 else
2134 gaim_window_add_conversation(win, conv);
2135 }
2136 else {
2137 struct buddy *b;
2138 struct group *grp = NULL;
2139 GList *wins, *convs;
2140
2141 b = gaim_find_buddy(gaim_conversation_get_account(conv),
2142 gaim_conversation_get_name(conv));
2143
2144 if (b != NULL)
2145 grp = gaim_find_buddys_group(b);
2146
2147 /* Go through the list of IMs and find one with this group. */
2148 for (wins = gaim_get_windows(); wins != NULL; wins = wins->next) {
2149 struct gaim_window *win2;
2150 struct gaim_conversation *conv2;
2151 struct buddy *b2;
2152 struct group *g2 = NULL;
2153
2154 win2 = (struct gaim_window *)wins->data;
2155
2156 for (convs = gaim_window_get_conversations(win2);
2157 convs != NULL;
2158 convs = convs->next) {
2159
2160 conv2 = (struct gaim_conversation *)convs->data;
2161
2162 b2 = gaim_find_buddy(gaim_conversation_get_account(conv2),
2163 gaim_conversation_get_name(conv2));
2164
2165 if (b2 != NULL)
2166 g2 = gaim_find_buddys_group(b2);
2167
2168 if (grp == g2) {
2169 gaim_window_add_conversation(win2, conv);
2170
2171 return;
2172 }
2173 }
2174 }
2175
2176 /* Make a new window. */
2177 conv_placement_new_window(conv);
2178 }
2179 }
2180
2181 /* This groups things by account. Otherwise, the same semantics as above */
2182 static void
2183 conv_placement_by_account(struct gaim_conversation *conv)
2184 {
2185 GaimConversationType type;
2186 GList *wins, *convs;
2187 struct gaim_account *account;
2188
2189
2190 account = gaim_conversation_get_account(conv);
2191 type = gaim_conversation_get_type(conv);
2192
2193
2194 /* Go through the list of IMs and find one with this group. */
2195 for (wins = gaim_get_windows(); wins != NULL; wins = wins->next) {
2196 struct gaim_window *win2;
2197 struct gaim_conversation *conv2;
2198
2199 win2 = (struct gaim_window *)wins->data;
2200
2201 for (convs = gaim_window_get_conversations(win2);
2202 convs != NULL;
2203 convs = convs->next) {
2204
2205 conv2 = (struct gaim_conversation *)convs->data;
2206
2207 if (((convo_options & OPT_CONVO_COMBINE) ||
2208 type == gaim_conversation_get_type(conv2)) &&
2209 account == gaim_conversation_get_account(conv2)) {
2210 gaim_window_add_conversation(win2, conv);
2211 return;
2212 }
2213
2214 }
2215 }
2216 /* Make a new window. */
2217 conv_placement_new_window(conv);
2218 }
2219
2220 static int
2221 add_conv_placement_fnc(const char *name, gaim_conv_placement_fnc fnc)
2222 {
2223 struct ConvPlacementData *data;
2224
2225 data = g_malloc0(sizeof(struct ConvPlacementData));
2226
2227 data->name = g_strdup(name);
2228 data->fnc = fnc;
2229
2230 conv_placement_fncs = g_list_append(conv_placement_fncs, data);
2231
2232 return gaim_conv_placement_get_fnc_count() - 1;
2233 }
2234
2235 static void
2236 ensure_default_funcs(void)
2237 {
2238 if (conv_placement_fncs == NULL) {
2239 add_conv_placement_fnc(_("Last created window"),
2240 conv_placement_last_created_win);
2241 add_conv_placement_fnc(_("New window"),
2242 conv_placement_new_window);
2243 add_conv_placement_fnc(_("By group"),
2244 conv_placement_by_group);
2245 add_conv_placement_fnc(_("By account"),
2246 conv_placement_by_account);
2247 }
2248 }
2249
2250 int
2251 gaim_conv_placement_add_fnc(const char *name, gaim_conv_placement_fnc fnc)
2252 {
2253 if (name == NULL || fnc == NULL)
2254 return -1;
2255
2256 if (conv_placement_fncs == NULL)
2257 ensure_default_funcs();
2258
2259 return add_conv_placement_fnc(name, fnc);
2260 }
2261
2262 void
2263 gaim_conv_placement_remove_fnc(int index)
2264 {
2265 struct ConvPlacementData *data;
2266 GList *node;
2267
2268 if (index < 0 || index > g_list_length(conv_placement_fncs))
2269 return;
2270
2271 node = g_list_nth(conv_placement_fncs, index);
2272 data = (struct ConvPlacementData *)node->data;
2273
2274 g_free(data->name);
2275 g_free(data);
2276
2277 conv_placement_fncs = g_list_remove_link(conv_placement_fncs, node);
2278 g_list_free_1(node);
2279 }
2280
2281 int
2282 gaim_conv_placement_get_fnc_count(void)
2283 {
2284 ensure_default_funcs();
2285
2286 return g_list_length(conv_placement_fncs);
2287 }
2288
2289 const char *
2290 gaim_conv_placement_get_name(int index)
2291 {
2292 struct ConvPlacementData *data;
2293
2294 ensure_default_funcs();
2295
2296 if (index < 0 || index > g_list_length(conv_placement_fncs))
2297 return NULL;
2298
2299 data = g_list_nth_data(conv_placement_fncs, index);
2300
2301 if (data == NULL)
2302 return NULL;
2303
2304 return data->name;
2305 }
2306
2307 gaim_conv_placement_fnc
2308 gaim_conv_placement_get_fnc(int index)
2309 {
2310 struct ConvPlacementData *data;
2311
2312 ensure_default_funcs();
2313
2314 if (index < 0 || index > g_list_length(conv_placement_fncs))
2315 return NULL;
2316
2317 data = g_list_nth_data(conv_placement_fncs, index);
2318
2319 if (data == NULL)
2320 return NULL;
2321
2322 return data->fnc;
2323 }
2324
2325 int
2326 gaim_conv_placement_get_fnc_index(gaim_conv_placement_fnc fnc)
2327 {
2328 struct ConvPlacementData *data;
2329 GList *node;
2330 int i;
2331
2332 ensure_default_funcs();
2333
2334 for (node = conv_placement_fncs, i = 0;
2335 node != NULL;
2336 node = node->next, i++) {
2337
2338 data = (struct ConvPlacementData *)node->data;
2339
2340 if (data->fnc == fnc)
2341 return i;
2342 }
2343
2344 return -1;
2345 }
2346
2347 int
2348 gaim_conv_placement_get_active(void)
2349 {
2350 return place_conv_index;
2351 }
2352
2353 void
2354 gaim_conv_placement_set_active(int index)
2355 {
2356 gaim_conv_placement_fnc fnc;
2357
2358 ensure_default_funcs();
2359
2360 fnc = gaim_conv_placement_get_fnc(index);
2361
2362 if (fnc == NULL)
2363 return;
2364
2365 place_conv = fnc;
2366 place_conv_index = index;
2367 }
2368
2369 void
2370 gaim_set_win_ui_ops(struct gaim_window_ui_ops *ops)
2371 {
2372 win_ui_ops = ops;
2373 }
2374
2375 struct gaim_window_ui_ops *
2376 gaim_get_win_ui_ops(void)
2377 {
2378 return win_ui_ops;
2379 }
Git mirror of Pidgin's Mercurial repository