Mercurial > pidgin.yaz

comparison src/buddy.c @ 1:2846a03bda67

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[gaim-migrate @ 10] The other missing files :) committer: Tailor Script <tailor@pidgin.im>
author Rob Flynn <gaim@robflynn.com>
date Thu, 23 Mar 2000 03:13:54 +0000
parents
children e7b30e18fd6c
comparison
equal deleted inserted replaced
0:a5ace2e037bc 1:2846a03bda67
1 /*
2 * gaim
3 *
4 * Copyright (C) 1998-1999, Mark Spencer <markster@marko.net>
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 USE_APPLET
23 #include <gnome.h>
24 #include <applet-widget.h>
25 #endif /* USE_APPLET */
26 #include <string.h>
27 #include <stdio.h>
28 #include <stdlib.h>
29 #include <math.h>
30 #include <time.h>
31
32 #include <gtk/gtk.h>
33 #include <gdk/gdkx.h>
34 #include "gaim.h"
35 #include "pixmaps/admin_icon.xpm"
36 #include "pixmaps/aol_icon.xpm"
37 #include "pixmaps/free_icon.xpm"
38 #include "pixmaps/dt_icon.xpm"
39 #include "pixmaps/no_icon.xpm"
40 #include "pixmaps/login_icon.xpm"
41 #include "pixmaps/logout_icon.xpm"
42
43 #include "pixmaps/buddyadd.xpm"
44 #include "pixmaps/buddydel.xpm"
45 #include "pixmaps/buddychat.xpm"
46 #include "pixmaps/im.xpm"
47 #include "pixmaps/info.xpm"
48 #include "pixmaps/permadd.xpm"
49 #include "pixmaps/permdel.xpm"
50 #include "pixmaps/away_icon.xpm"
51
52 static GtkTooltips *tips;
53 static GtkWidget *editpane;
54 static GtkWidget *buddypane;
55 static GtkWidget *permitpane;
56 static GtkWidget *edittree;
57 static GtkWidget *permtree;
58 static GtkWidget *imbutton, *infobutton, *chatbutton;
59 static GtkWidget *addbutton, *rembutton;
60 static GtkWidget *addpermbutton, *rempermbutton;
61 static GtkWidget *lagometer = NULL;
62 static GtkWidget *lagometer_box = NULL;
63
64 static int last_lag_us;
65
66
67 GtkWidget *blist = NULL;
68 GtkWidget *bpmenu;
69 GtkWidget *buddies;
70 int permdeny;
71
72
73 /* Predefine some functions */
74 static void new_bp_callback(GtkWidget *w, char *name);
75 static void log_callback(GtkWidget *w, char *name);
76
77
78 void destroy_buddy()
79 {
80 if (blist)
81 gtk_widget_destroy(blist);
82 blist=NULL;
83 }
84
85 void update_num_groups()
86 {
87 GList *grp = groups;
88 GList *mem;
89 struct buddy *b;
90 struct group *g;
91 int pres, total;
92 char buf[BUF_LONG];
93
94 if (!(display_options & OPT_DISP_SHOW_GRPNUM))
95 return;
96
97 while(grp) {
98 g = (struct group *)grp->data;
99 mem = g->members;
100 pres = 0;
101 total = 0;
102 while(mem) {
103 b = (struct buddy *)mem->data;
104 if (b->present)
105 pres++;
106 total++;
107
108
109 mem = mem->next;
110 }
111
112 g_snprintf(buf, sizeof(buf), "%s (%d/%d)", g->name, pres, total);
113
114 gtk_label_set(GTK_LABEL(g->label), buf);
115 grp = grp->next;
116 }
117
118 }
119
120 void update_show_idlepix()
121 {
122 GList *grp = groups;
123 GList *mem;
124 struct group *g;
125 struct buddy *b;
126
127 while (grp) {
128 g = (struct group *)grp->data;
129 mem = g->members;
130
131 while(mem) {
132 b = (struct buddy *)mem->data;
133
134 if (display_options & OPT_DISP_SHOW_IDLETIME)
135 gtk_widget_show(b->idletime);
136 else
137 gtk_widget_hide(b->idletime);
138
139 if (display_options & OPT_DISP_SHOW_PIXMAPS)
140 gtk_widget_show(b->pix);
141 else
142 gtk_widget_hide(b->pix);
143 mem = mem->next;
144 }
145 grp = grp->next;
146 }
147 }
148
149 void update_all_buddies()
150 {
151 GList *grp = groups;
152 GList *mem;
153 struct buddy *b;
154 struct group *g;
155
156 while(grp) {
157 g = (struct group *)grp->data;
158 mem = g->members;
159 while(mem) {
160 b = (struct buddy *)mem->data;
161
162 set_buddy(b);
163
164 mem = mem->next;
165 }
166 grp = grp->next;
167 }
168
169
170 }
171
172 void update_lagometer(int us)
173 {
174 double pct;
175
176
177
178 if (us != -1)
179 last_lag_us = us;
180
181
182 if (lagometer_box == NULL)
183 return;
184
185
186 if (!(general_options & OPT_GEN_SHOW_LAGMETER))
187 gtk_widget_hide(lagometer_box);
188 else
189 gtk_widget_show(lagometer_box);
190
191
192 pct = last_lag_us/100000;
193 pct = 25 * log(pct);
194
195 if (pct < 0)
196 pct = 0;
197
198 if (pct > 100)
199 pct = 100;
200
201
202 pct /= 100;
203
204
205 gtk_progress_bar_update(GTK_PROGRESS_BAR(lagometer), pct);
206 }
207
208 static void adjust_pic(GtkWidget *button, const char *c, gchar **xpm)
209 {
210 GdkPixmap *pm;
211 GdkBitmap *bm;
212 GtkWidget *pic;
213 GtkWidget *label;
214
215 /*if the user had opted to put pictures on the buttons*/
216 if (display_options & OPT_DISP_SHOW_BUTTON_XPM) {
217 pm = gdk_pixmap_create_from_xpm_d(blist->window, &bm,
218 NULL, xpm);
219 pic = gtk_pixmap_new(pm, bm);
220 gtk_widget_show(pic);
221 label = GTK_BIN(button)->child;
222 gtk_container_remove(GTK_CONTAINER(button), label);
223 gtk_container_add(GTK_CONTAINER(button), pic);
224 } else {
225 label = gtk_label_new(c);
226 gtk_widget_show(label);
227 pic = GTK_BIN(button)->child;
228 gtk_container_remove(GTK_CONTAINER(button), pic);
229 gtk_container_add(GTK_CONTAINER(button), label);
230 }
231
232 }
233
234
235 void update_button_pix()
236 {
237
238 adjust_pic(addbutton, "Add", (gchar **)buddyadd_xpm);
239 adjust_pic(rembutton, "Remove", (gchar **)buddydel_xpm);
240 adjust_pic(chatbutton, "Chat", (gchar **)buddychat_xpm);
241 adjust_pic(imbutton, "IM", (gchar **)im_xpm);
242 adjust_pic(infobutton, "Info", (gchar **)info_xpm);
243 adjust_pic(addpermbutton, "Add", (gchar **)permadd_xpm);
244 adjust_pic(rempermbutton, "Remove", (gchar **)permdel_xpm);
245
246 }
247
248
249
250 #ifdef USE_APPLET
251 gint applet_destroy_buddy( GtkWidget *widget, GdkEvent *event,gpointer *data ) {
252 GList *mem;
253 set_applet_draw_closed();
254
255 /****NO LONGER NEEDED
256 while(groups) {
257 mem = ((struct group *)groups->data)->members;
258 while(mem) {
259 g_free(mem->data);
260 mem = g_list_remove(mem, mem->data);
261 }
262 g_free(groups->data);
263 groups = g_list_remove(groups, groups->data);
264 }
265
266 destroy_buddy();
267 */
268 gnome_buddy_hide();
269 applet_widget_register_callback(APPLET_WIDGET(applet),
270 "buddy",
271 _("Buddy List"),
272 (AppletCallbackFunc)make_buddy,
273 NULL);
274 return (TRUE);
275 }
276
277 void gnome_buddy_show(){
278 gtk_widget_show( blist );
279 }
280
281 void gnome_buddy_hide(){
282 gtk_widget_hide( blist );
283 }
284
285 void gnome_buddy_set_pos( gint x, gint y ){
286 gtk_widget_set_uposition ( blist, x, y );
287 }
288
289 GtkRequisition gnome_buddy_get_dimentions(){
290 return blist->requisition;
291 }
292
293 #endif
294
295
296 void signoff()
297 {
298 GList *mem;
299 while(groups) {
300 mem = ((struct group *)groups->data)->members;
301 while(mem) {
302 g_free(mem->data);
303 mem = g_list_remove(mem, mem->data);
304 }
305 g_free(groups->data);
306 groups = g_list_remove(groups, groups->data);
307 }
308
309 serv_close();
310 destroy_all_dialogs();
311 destroy_buddy();
312 hide_login_progress("");
313 #ifdef USE_APPLET
314 set_applet_draw_closed();
315 applet_widget_unregister_callback(APPLET_WIDGET(applet),"signoff");
316 applet_widget_unregister_callback(APPLET_WIDGET(applet),"away");
317 applet_widget_unregister_callback(APPLET_WIDGET(applet),"buddy");
318 applet_widget_register_callback(APPLET_WIDGET(applet),
319 "signon",
320 _("Signon"),
321 applet_show_login,
322 NULL);
323 #else
324 show_login();
325 #endif /* USE_APPLET */
326 }
327
328 void handle_click_group(GtkWidget *widget, GdkEventButton *event, gpointer func_data)
329 {
330 if (event->type == GDK_2BUTTON_PRESS) {
331 if (GTK_TREE_ITEM(widget)->expanded)
332 gtk_tree_item_collapse(GTK_TREE_ITEM(widget));
333 else
334 gtk_tree_item_expand(GTK_TREE_ITEM(widget));
335 } else {
336 }
337 }
338
339 void pressed_im(GtkWidget *widget, struct buddy *b)
340 {
341 struct conversation *c;
342
343 c = find_conversation(b->name);
344
345 if (c != NULL) {
346 gdk_window_raise(c->window->window);
347 } else {
348 c = new_conversation(b->name);
349 }
350 }
351
352 void pressed_info(GtkWidget *widget, struct buddy *b)
353 {
354 serv_get_info(b->name);
355
356 }
357
358 void pressed_dir_info(GtkWidget *widget, struct buddy *b)
359 {
360 serv_get_dir(b->name);
361
362 }
363
364 void handle_click_buddy(GtkWidget *widget, GdkEventButton *event, struct buddy *b)
365 {
366 if (event->type == GDK_2BUTTON_PRESS && event->button == 1) {
367 struct conversation *c;
368
369 c = find_conversation(b->name);
370
371 if (c != NULL) {
372 gdk_window_raise(c->window->window);
373 } else {
374 c = new_conversation(b->name);
375 }
376 } else if (event->type == GDK_BUTTON_PRESS && event->button == 3) {
377 GtkWidget *menu, *button;
378 /* We're gonna make us a menu right here */
379
380 menu = gtk_menu_new();
381
382 button = gtk_menu_item_new_with_label("IM");
383 gtk_signal_connect(GTK_OBJECT(button), "activate",
384 GTK_SIGNAL_FUNC(pressed_im), b);
385 gtk_menu_append(GTK_MENU(menu), button);
386 gtk_widget_show(button);
387
388 button = gtk_menu_item_new_with_label("Info");
389 gtk_signal_connect(GTK_OBJECT(button), "activate",
390 GTK_SIGNAL_FUNC(pressed_info), b);
391 gtk_menu_append(GTK_MENU(menu), button);
392 gtk_widget_show(button);
393
394 button = gtk_menu_item_new_with_label("Dir Info");
395 gtk_signal_connect(GTK_OBJECT(button), "activate",
396 GTK_SIGNAL_FUNC(pressed_dir_info), b);
397 gtk_menu_append(GTK_MENU(menu), button);
398 gtk_widget_show(button);
399
400 button = gtk_menu_item_new_with_label("Toggle Logging");
401 gtk_signal_connect(GTK_OBJECT(button), "activate",
402 GTK_SIGNAL_FUNC(log_callback), b->name);
403 gtk_menu_append(GTK_MENU(menu), button);
404 gtk_widget_show(button);
405
406 button = gtk_menu_item_new_with_label("Add Buddy Pounce");
407 gtk_signal_connect(GTK_OBJECT(button), "activate",
408 GTK_SIGNAL_FUNC(new_bp_callback), b->name);
409 gtk_menu_append(GTK_MENU(menu), button);
410 gtk_widget_show(button);
411
412
413
414 gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL,
415 event->button, event->time);
416
417 } else if (event->type == GDK_3BUTTON_PRESS && event->button == 2) {
418 if (!strcasecmp("zilding", normalize(b->name)))
419 show_ee_dialog(0);
420 else if (!strcasecmp("robflynn", normalize(b->name)))
421 show_ee_dialog(1);
422 else if (!strcasecmp("flynorange", normalize(b->name)))
423 show_ee_dialog(2);
424
425 } else {
426
427 /* Anything for other buttons? :) */
428 }
429 }
430
431
432
433 void remove_buddy(struct group *rem_g, struct buddy *rem_b)
434 {
435 GList *grp;
436 GList *mem;
437
438 struct group *delg;
439 struct buddy *delb;
440
441 grp = g_list_find(groups, rem_g);
442 delg = (struct group *)grp->data;
443 mem = delg->members;
444
445 mem = g_list_find(mem, rem_b);
446 delb = (struct buddy *)mem->data;
447
448 gtk_tree_remove_items(GTK_TREE(delg->tree), g_list_append(NULL, delb->item));
449 delg->members = g_list_remove(delg->members, delb);
450 serv_remove_buddy(delb->name);
451 g_free(delb);
452
453 serv_save_config();
454
455 update_num_groups();
456
457
458 }
459
460 void remove_group(struct group *rem_g)
461 {
462 GList *grp;
463 GList *mem;
464
465 struct group *delg;
466 struct buddy *delb;
467
468 grp = g_list_find(groups, rem_g);
469 delg = (struct group *)grp->data;
470 mem = delg->members;
471
472 while(delg->members) {
473 delb = (struct buddy *)delg->members->data;
474 gtk_tree_remove_items(GTK_TREE(delg->tree), g_list_append(NULL, delb->item));
475 delg->members = g_list_remove(delg->members, delb);
476 serv_remove_buddy(delb->name);
477 g_free(delb);
478 }
479
480
481 gtk_tree_remove_items(GTK_TREE(buddies), g_list_append(NULL, delg->item));
482 groups = g_list_remove(groups, delg);
483 g_free(delg);
484
485 serv_save_config();
486 }
487
488
489
490 void build_permit_tree()
491 {
492 GtkWidget *ti;
493 GtkWidget *sub;
494 GList *plist = permit;
495 GList *dlist = deny;
496
497 gtk_tree_clear_items(GTK_TREE(permtree), 0, -1);
498
499 ti = gtk_tree_item_new_with_label("Permit");
500 sub = gtk_tree_new();
501 gtk_widget_show(ti);
502 gtk_widget_show(sub);
503 gtk_tree_prepend(GTK_TREE(permtree), ti);
504 gtk_tree_item_set_subtree(GTK_TREE_ITEM(ti), sub);
505 gtk_tree_item_expand(GTK_TREE_ITEM(ti));
506
507 while(plist) {
508 ti = gtk_tree_item_new_with_label((char *)plist->data);
509 gtk_widget_show(ti);
510 gtk_tree_prepend(GTK_TREE(sub), ti);
511 plist = plist->next;
512 }
513
514
515 ti = gtk_tree_item_new_with_label("Deny");
516 sub = gtk_tree_new();
517 gtk_widget_show(ti);
518 gtk_widget_show(sub);
519 gtk_tree_prepend(GTK_TREE(permtree), ti);
520 gtk_tree_item_set_subtree(GTK_TREE_ITEM(ti), sub);
521 gtk_tree_item_expand(GTK_TREE_ITEM(ti));
522
523 while(dlist) {
524 ti = gtk_tree_item_new_with_label((char *)dlist->data);
525 gtk_widget_show(ti);
526 gtk_tree_prepend(GTK_TREE(sub), ti);
527 dlist = dlist->next;
528 }
529
530
531 }
532
533
534 gboolean edit_drag_compare_func (GtkCTree *ctree, GtkCTreeNode *source_node,
535 GtkCTreeNode *new_parent, GtkCTreeNode *new_sibling)
536 {
537 gboolean leaf;
538
539 gtk_ctree_get_node_info (ctree, source_node, NULL,
540 NULL, NULL, NULL, NULL, NULL, &leaf, NULL);
541
542
543 if (leaf) {
544 if (!new_parent)
545 return FALSE;
546 } else {
547
548 if (new_parent)
549 return FALSE;
550
551 }
552
553 return TRUE;
554 }
555
556
557
558 static void edit_tree_move (GtkCTree *ctree, GtkCTreeNode *child, GtkCTreeNode *parent,
559 GtkCTreeNode *sibling, gpointer data)
560 {
561 char *source;
562 char *target1;
563 char *target2;
564
565 gtk_ctree_get_node_info (ctree, child, &source,
566 NULL, NULL, NULL, NULL, NULL, NULL, NULL);
567 if (parent)
568 gtk_ctree_get_node_info (ctree, parent, &target1,
569 NULL, NULL, NULL, NULL, NULL, NULL, NULL);
570 if (sibling)
571 gtk_ctree_get_node_info (ctree, sibling, &target2,
572 NULL, NULL, NULL, NULL, NULL, NULL, NULL);
573
574
575 if (!parent) {
576 GList *grps, *buds;
577 struct group *g, *g2;
578 GList *tmp;
579 int pos;
580 struct buddy *b;
581 /* Okay we've moved group order... */
582
583 g = find_group(source);
584
585 gtk_widget_ref(g->tree);
586
587 buds = g->members;
588 while(buds) {
589 b = (struct buddy *)buds->data;
590 gtk_widget_ref(b->item);
591 gtk_widget_ref(b->label);
592 gtk_widget_ref(b->idletime);
593 gtk_widget_ref(b->pix);
594 buds = buds->next;
595 }
596
597
598
599
600 pos = g_list_index(GTK_TREE(buddies)->children, g->item);
601
602 tmp = g_list_append(NULL, g->item);
603 gtk_tree_remove_items(GTK_TREE(buddies), tmp);
604 g_list_free(tmp);
605
606 groups = g_list_remove(groups, g);
607
608 g->item = gtk_tree_item_new_with_label(g->name);
609 gtk_widget_show(g->item);
610
611 if (sibling) {
612 g2 = find_group(target2);
613 pos = g_list_index(groups, g2);
614 if (pos == 0) {
615 groups = g_list_prepend(groups, g);
616 gtk_tree_prepend(GTK_TREE(buddies), g->item);
617 } else {
618 groups = g_list_insert(groups, g, pos);
619 gtk_tree_insert(GTK_TREE(buddies), g->item, pos);
620 }
621
622 } else {
623 groups = g_list_append(groups, g);
624 gtk_tree_append(GTK_TREE(buddies), g->item);
625
626 }
627
628 gtk_tree_item_set_subtree (GTK_TREE_ITEM(g->item), g->tree);
629 gtk_tree_item_expand (GTK_TREE_ITEM(g->item));
630 gtk_signal_connect(GTK_OBJECT(g->item), "button_press_event",
631 GTK_SIGNAL_FUNC(handle_click_group),
632 NULL);
633 gtk_object_set_user_data(GTK_OBJECT(g->item), NULL);
634
635 gtk_widget_unref(g->tree);
636
637 update_num_groups();
638
639
640 buds = g->members;
641
642 while(buds) {
643 b = (struct buddy *)buds->data;
644 set_buddy(b);
645 buds = buds->next;
646 }
647
648 grps = groups;
649 while(grps) {
650 g = (struct group *)grps->data;
651 grps = grps->next;
652 }
653
654 } else {
655 struct group *new_g, *old_g;
656 struct buddy *b, *s;
657 GtkWidget *gtree;
658 GtkWidget *owner;
659 GList *temp;
660 int pos;
661
662 b = find_buddy(source);
663 new_g = find_group(target1);
664 old_g = find_group_by_buddy(source);
665 gtree = old_g->tree;
666 if (sibling)
667 s = find_buddy(target2);
668 else
669 s = NULL;
670
671 old_g->members = g_list_remove(old_g->members, b);
672
673 gtk_widget_ref(b->item);
674 gtk_widget_ref(b->label);
675 gtk_widget_ref(b->pix);
676 gtk_widget_ref(b->idletime);
677 gtk_widget_ref(gtree);
678
679 owner = GTK_TREE(gtree)->tree_owner;
680
681 temp = g_list_append(NULL, b->item);
682 gtk_tree_remove_items(GTK_TREE(old_g->tree), temp);
683 g_list_free(temp);
684
685 if (gtree->parent == NULL){
686 gtk_tree_item_set_subtree (GTK_TREE_ITEM(owner), gtree);
687 gtk_tree_item_expand (GTK_TREE_ITEM(owner));
688 }
689
690 if (!sibling) {
691 gtk_tree_append(GTK_TREE(new_g->tree), b->item);
692 new_g->members = g_list_append(new_g->members, b);
693 } else {
694 pos = g_list_index(new_g->members, s);
695 if (pos != 0) {
696 new_g->members = g_list_insert(new_g->members, b, pos);
697 gtk_tree_insert(GTK_TREE(new_g->tree), b->item, pos);
698 } else {
699 new_g->members = g_list_prepend(new_g->members, b);
700 gtk_tree_prepend(GTK_TREE(new_g->tree), b->item);
701
702 }
703 }
704
705 gtk_widget_unref(b->item);
706 gtk_widget_unref(b->label);
707 gtk_widget_unref(b->pix);
708 gtk_widget_unref(b->idletime);
709 gtk_widget_unref(gtree);
710
711 gtk_ctree_expand(ctree, parent);
712
713 update_num_groups();
714 update_show_idlepix();
715 set_buddy(b);
716
717
718
719
720
721 }
722
723 serv_save_config();
724 }
725
726
727
728 void build_edit_tree()
729 {
730 GtkCTreeNode *p = NULL, *n;
731 GList *grp = groups;
732 GList *mem;
733 struct group *g;
734 struct buddy *b;
735 char *text[1];
736
737 gtk_clist_freeze(GTK_CLIST(edittree));
738 gtk_clist_clear(GTK_CLIST(edittree));
739
740
741 while(grp) {
742 g = (struct group *)grp->data;
743
744 text[0] = g->name;
745
746 p = gtk_ctree_insert_node(GTK_CTREE(edittree), NULL,
747 NULL, text, 5, NULL, NULL,
748 NULL, NULL, 0, 1);
749
750 n = NULL;
751
752 mem = g->members;
753
754 while(mem) {
755 b = (struct buddy *)mem->data;
756
757 text[0] = b->name;
758
759 n = gtk_ctree_insert_node(GTK_CTREE(edittree),
760 p, NULL, text, 5,
761 NULL, NULL,
762 NULL, NULL, 1, 1);
763
764 mem = mem->next;
765
766 }
767 grp = grp->next;
768 }
769
770 gtk_clist_thaw(GTK_CLIST(edittree));
771
772 }
773
774 struct buddy *add_buddy(char *group, char *buddy)
775 {
776 struct buddy *b;
777 struct group *g;
778 GdkPixmap *pm;
779 GdkBitmap *bm;
780 GtkWidget *box;
781
782
783 if ((b = find_buddy(buddy)) != NULL)
784 return b;
785
786 g = find_group(group);
787
788 if (g == NULL)
789 g = add_group(group);
790
791 b = (struct buddy *)g_new0(struct buddy, 1);
792
793 if (!b)
794 return NULL;
795
796 b->present = 0;
797 b->item = gtk_tree_item_new();
798
799 g_snprintf(b->name, sizeof(b->name), "%s", buddy);
800 g->members = g_list_append(g->members, b);
801
802
803 if (blist == NULL)
804 return b;
805
806 box = gtk_hbox_new(FALSE, 1);
807 pm = gdk_pixmap_create_from_xpm_d(blist->window, &bm,
808 NULL, (gchar **)login_icon_xpm);
809 b->pix = gtk_pixmap_new(pm, bm);
810
811 b->idle = 0;
812
813 gtk_widget_show(b->pix);
814
815 b->label = gtk_label_new(buddy);
816 gtk_misc_set_alignment(GTK_MISC(b->label), 0.0, 0.5);
817
818 b->idletime = gtk_label_new("");
819
820 gtk_tree_append(GTK_TREE(g->tree),b->item);
821 gtk_container_add(GTK_CONTAINER(b->item), box);
822
823 gtk_box_pack_start(GTK_BOX(box), b->pix, FALSE, FALSE, 1);
824 gtk_box_pack_start(GTK_BOX(box), b->label, TRUE, TRUE, 1);
825 gtk_box_pack_start(GTK_BOX(box), b->idletime, FALSE, FALSE, 1);
826
827 gtk_widget_show(b->label);
828 gtk_widget_show(box);
829
830 gtk_object_set_user_data(GTK_OBJECT(b->item), b);
831
832 gtk_signal_connect(GTK_OBJECT(b->item), "button_press_event",
833 GTK_SIGNAL_FUNC(handle_click_buddy), b);
834
835 return b;
836 }
837
838
839 struct group *add_group(char *group)
840 {
841 struct group *g;
842 g = (struct group *)g_new0(struct group, 1);
843 if (!g)
844 return NULL;
845
846 strncpy(g->name, group, sizeof(g->name));
847 groups = g_list_append(groups, g);
848
849 if (blist == NULL)
850 return g;
851
852 g->item = gtk_tree_item_new();
853 g->label = gtk_label_new(g->name);
854 gtk_misc_set_alignment(GTK_MISC(g->label), 0.0, 0.5);
855 gtk_widget_show(g->label);
856 gtk_container_add(GTK_CONTAINER(g->item), g->label);
857 g->tree = gtk_tree_new();
858 gtk_widget_show(g->item);
859 gtk_widget_show(g->tree);
860 gtk_tree_append(GTK_TREE(buddies), g->item);
861 gtk_tree_item_set_subtree(GTK_TREE_ITEM(g->item), g->tree);
862 gtk_tree_item_expand(GTK_TREE_ITEM(g->item));
863 gtk_signal_connect(GTK_OBJECT(g->item), "button_press_event",
864 GTK_SIGNAL_FUNC(handle_click_group),
865 NULL);
866 gtk_object_set_user_data(GTK_OBJECT(g->item), NULL);
867 g->members = NULL;
868
869
870 build_edit_tree();
871
872 return g;
873
874 }
875
876
877 static void do_del_buddy(GtkWidget *w, GtkCTree *ctree)
878 {
879 GtkCTreeNode *node;
880 char *bud, *grp;
881 struct buddy *b;
882 struct group *g;
883 GList *i;
884
885 i = GTK_CLIST(edittree)->selection;
886 if (i) {
887 node = i->data;
888
889 if (GTK_CTREE_ROW(node)->is_leaf) {
890 gtk_ctree_get_node_info (GTK_CTREE(edittree), node, &bud,
891 NULL, NULL, NULL, NULL, NULL, NULL, NULL);
892
893 b = find_buddy(bud);
894 g = find_group_by_buddy(bud);
895 remove_buddy(g, b);
896 } else {
897 gtk_ctree_get_node_info (ctree, node, &grp,
898 NULL, NULL, NULL, NULL, NULL, NULL, NULL);
899 g = find_group(grp);
900 remove_group(g);
901 }
902
903 build_edit_tree();
904 serv_save_config();
905 } else {
906 /* Nothing selected. */
907 }
908 update_num_groups();
909 }
910
911 static void do_del_perm(GtkWidget *w, GtkTree *permtree)
912 {
913 GtkLabel *label, *plabel;
914 GtkWidget *item, *pitem;
915 char *c, *d;
916 GList *i;
917
918 GList *plist;
919 GList *dlist;
920 int level;
921
922 plist = permit;
923 dlist = deny;
924
925 i = GTK_TREE_SELECTION(permtree);
926 if (i) {
927 item = GTK_WIDGET(i->data);
928 gtk_tree_unselect_child(GTK_TREE(permtree), item);
929 label = GTK_LABEL(GTK_BIN(item)->child);
930 gtk_label_get(label, &c);
931 level = GTK_TREE(item->parent)->level;
932 if (level > 0) {
933 pitem = GTK_WIDGET(GTK_TREE(item->parent)->tree_owner);
934 plabel = GTK_LABEL(GTK_BIN(pitem)->child);
935 gtk_label_get(plabel, &d);
936 if (!strcasecmp(d, "Permit")) {
937 while(plist) {
938 if (!strcasecmp((char *)(plist->data), c)) {
939 permit = g_list_remove(permit, plist->data);
940 break;
941 }
942
943 plist = plist->next;
944 }
945
946 } else {
947 while(dlist) {
948 if (!strcasecmp((char *)(dlist->data), c)) {
949 deny = g_list_remove(deny, dlist->data);
950
951 break;
952 }
953 dlist = dlist->next;
954 }
955
956 }
957
958
959 } else {
960 /* Can't delete groups here! :) */
961 return;
962 }
963 serv_set_permit_deny();
964 gtk_tree_clear_items(GTK_TREE(permtree), 0, -1);
965 build_permit_tree();
966 serv_save_config();
967 }
968 }
969
970
971
972 void gaimreg_callback(GtkWidget *widget)
973 {
974 show_register_dialog();
975 }
976
977 void import_callback(GtkWidget *widget, void *null)
978 {
979 show_import_dialog();
980 }
981
982 void export_callback(GtkWidget *widget, void *null)
983 {
984 show_export_dialog();
985 }
986
987
988
989 void do_quit()
990 {
991 exit(0);
992 }
993
994 void add_buddy_callback(GtkWidget *widget, void *dummy)
995 {
996 char *grp = NULL;
997 GtkCTreeNode *node;
998 GList *i;
999
1000 i = GTK_CLIST(edittree)->selection;
1001 if (i) {
1002 node = i->data;
1003
1004 if (GTK_CTREE_ROW(node)->is_leaf) {
1005 node = GTK_CTREE_ROW(node)->parent;
1006 }
1007
1008 gtk_ctree_get_node_info (GTK_CTREE(edittree), node, &grp,
1009 NULL, NULL, NULL, NULL, NULL, NULL, NULL);
1010 }
1011 show_add_buddy(NULL, grp);
1012
1013 }
1014
1015 void add_perm_callback(GtkWidget *widget, void *dummy)
1016 {
1017 show_add_perm(NULL);
1018 }
1019
1020
1021 static void info_callback(GtkWidget *widget, GtkTree *tree)
1022 {
1023 GList *i;
1024 struct buddy *b = NULL;
1025 i = GTK_TREE_SELECTION(tree);
1026 if (i) {
1027 b = gtk_object_get_user_data(GTK_OBJECT(i->data));
1028 } else {
1029 return;
1030 }
1031 if (!b->name)
1032 return;
1033 serv_get_info(b->name);
1034 }
1035
1036
1037 void chat_callback(GtkWidget *widget, GtkTree *tree)
1038 {
1039 join_chat();
1040 }
1041
1042 struct group *find_group(char *group)
1043 {
1044 struct group *g;
1045 GList *grp = groups;
1046 char *grpname = g_malloc(strlen(group) + 1);
1047
1048 strcpy(grpname, normalize(group));
1049 while (grp) {
1050 g = (struct group *)grp->data;
1051 if (!strcasecmp(normalize(g->name), grpname)) {
1052 g_free(grpname);
1053 return g;
1054 }
1055 grp = grp->next;
1056 }
1057
1058 g_free(grpname);
1059 return NULL;
1060
1061 }
1062
1063
1064 struct group *find_group_by_buddy(char *who)
1065 {
1066 struct group *g;
1067 struct buddy *b;
1068 GList *grp = groups;
1069 GList *mem;
1070 char *whoname = g_malloc(strlen(who) + 1);
1071
1072 strcpy(whoname, normalize(who));
1073
1074 while(grp) {
1075 g = (struct group *)grp->data;
1076
1077 mem = g->members;
1078 while(mem) {
1079 b = (struct buddy *)mem->data;
1080 if (!strcasecmp(normalize(b->name), whoname)) {
1081 g_free(whoname);
1082 return g;
1083 }
1084 mem = mem->next;
1085 }
1086 grp = grp->next;
1087 }
1088 g_free(whoname);
1089 return NULL;
1090 }
1091
1092
1093 struct buddy *find_buddy(char *who)
1094 {
1095 struct group *g;
1096 struct buddy *b;
1097 GList *grp = groups;
1098 GList *mem;
1099 char *whoname = g_malloc(strlen(who) + 1);
1100
1101 strcpy(whoname, normalize(who));
1102
1103 while(grp) {
1104 g = (struct group *)grp->data;
1105
1106 mem = g->members;
1107 while(mem) {
1108 b = (struct buddy *)mem->data;
1109 if (!strcasecmp(normalize(b->name), whoname)) {
1110 g_free(whoname);
1111 return b;
1112 }
1113 mem = mem->next;
1114 }
1115 grp = grp->next;
1116 }
1117 g_free(whoname);
1118 return NULL;
1119 }
1120
1121
1122 void rem_bp(GtkWidget *w, struct buddy_pounce *b)
1123 {
1124 buddy_pounces = g_list_remove(buddy_pounces, b);
1125 }
1126
1127 void do_pounce(char *name)
1128 {
1129 char *who = g_malloc(64);
1130 char *buf = g_malloc(BUF_LONG);
1131
1132 struct buddy_pounce *b;
1133 struct conversation *c;
1134
1135 GList *bp = buddy_pounces;
1136
1137 strcpy(who, normalize(name));
1138
1139 while(bp) {
1140 b = (struct buddy_pounce *)bp->data;;
1141 if (!strcasecmp(who, normalize(b->name))) {
1142 if (b->popup == 1)
1143 {
1144 c = find_conversation(name);
1145 if (c == NULL)
1146 c = new_conversation(name);
1147 }
1148 if (b->sendim == 1)
1149 {
1150 c = find_conversation(name);
1151 if (c == NULL)
1152 c = new_conversation(name);
1153
1154 write_to_conv(c, b->message, WFLAG_SEND);
1155
1156 escape_text(b->message);
1157
1158 serv_send_im(name, b->message, 0);
1159 }
1160
1161 rem_bp(NULL, b);
1162
1163 }
1164 bp = bp->next;
1165 }
1166 g_free(who);
1167 g_free(buf);
1168 }
1169
1170 static void new_bp_callback(GtkWidget *w, char *name)
1171 {
1172 show_new_bp(name);
1173 }
1174
1175 static void log_callback(GtkWidget *w, char *name)
1176 {
1177 struct conversation *c = find_conversation(name);
1178
1179 if (find_log_info(name))
1180 {
1181 if (c) {
1182 set_state_lock(1);
1183 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(c->log_button), FALSE);
1184 set_state_lock(0);
1185 }
1186 rm_log(find_log_info(name));
1187 }
1188 else
1189 {
1190 show_log_dialog(name);
1191 if (c) {
1192 set_state_lock(1);
1193 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(c->log_button), TRUE);
1194 set_state_lock(0);
1195 }
1196 }
1197 }
1198
1199 void do_bp_menu()
1200 {
1201 GtkWidget *menuitem, *mess, *messmenu;
1202 static GtkWidget *remmenu;
1203 GtkWidget *remitem;
1204 GtkWidget *sep;
1205 GList *l;
1206 struct buddy_pounce *b;
1207 GList *bp = buddy_pounces;
1208
1209 l = gtk_container_children(GTK_CONTAINER(bpmenu));
1210
1211 while(l) {
1212 gtk_widget_destroy(GTK_WIDGET(l->data));
1213 l = l->next;
1214 }
1215
1216 remmenu = gtk_menu_new();
1217
1218 menuitem = gtk_menu_item_new_with_label("New Buddy Pounce");
1219 gtk_menu_append(GTK_MENU(bpmenu), menuitem);
1220 gtk_widget_show(menuitem);
1221 gtk_signal_connect(GTK_OBJECT(menuitem), "activate", GTK_SIGNAL_FUNC(new_bp_callback), NULL);
1222
1223
1224 while(bp) {
1225
1226 b = (struct buddy_pounce *)bp->data;
1227 remitem = gtk_menu_item_new_with_label(b->name);
1228 gtk_menu_append(GTK_MENU(remmenu), remitem);
1229 gtk_widget_show(remitem);
1230 gtk_signal_connect(GTK_OBJECT(remitem), "activate", GTK_SIGNAL_FUNC(rem_bp), b);
1231
1232 bp = bp->next;
1233
1234 }
1235
1236 menuitem = gtk_menu_item_new_with_label("Remove Buddy Pounce");
1237 gtk_menu_append(GTK_MENU(bpmenu), menuitem);
1238 gtk_widget_show(menuitem);
1239 gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), remmenu);
1240 gtk_widget_show(remmenu);
1241
1242
1243 sep = gtk_hseparator_new();
1244 menuitem = gtk_menu_item_new();
1245 gtk_menu_append(GTK_MENU(bpmenu), menuitem);
1246 gtk_container_add(GTK_CONTAINER(menuitem), sep);
1247 gtk_widget_set_sensitive(menuitem, FALSE);
1248 gtk_widget_show(menuitem);
1249 gtk_widget_show(sep);
1250
1251 bp = buddy_pounces;;
1252
1253 while(bp) {
1254
1255 b = (struct buddy_pounce *)bp->data;
1256
1257 menuitem = gtk_menu_item_new_with_label(b->name);
1258 gtk_menu_append(GTK_MENU(bpmenu), menuitem);
1259 messmenu = gtk_menu_new();
1260 gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), messmenu);
1261 gtk_widget_show(menuitem);
1262
1263
1264
1265 mess = gtk_menu_item_new_with_label(b->message);
1266 gtk_menu_append(GTK_MENU(messmenu), mess);
1267 gtk_widget_show(mess);
1268
1269 bp = bp->next;
1270
1271 }
1272
1273 }
1274
1275
1276 gint log_timeout(char *name)
1277 {
1278 struct buddy *b;
1279
1280 b = find_buddy(name);
1281
1282 if(!b)
1283 return FALSE;
1284
1285 b->log_timer = 0;
1286
1287 if (!b->present)
1288 gtk_widget_hide(b->item);
1289 else
1290 set_buddy(b);
1291
1292 return FALSE;
1293 }
1294
1295
1296 void set_buddy(struct buddy *b)
1297 {
1298 char *who;
1299 char infotip[256];
1300 char idlet[16];
1301 char warn[256];
1302 int i;
1303 int ihrs, imin;
1304 time_t t;
1305 GdkPixmap *pm;
1306 GdkBitmap *bm;
1307 char *itime, *sotime;
1308
1309 if (b->present) {
1310 time(&t);
1311
1312 ihrs = (t - b->idle) / 3600;
1313 imin = ((t - b->idle) / 60) % 60;
1314
1315 if (ihrs)
1316 g_snprintf(idlet, sizeof(idlet), "(%d:%02d)", ihrs, imin);
1317 else
1318 g_snprintf(idlet, sizeof(idlet), "(%02d)", imin);
1319
1320 gtk_widget_hide(b->idletime);
1321
1322 if (b->idle)
1323 gtk_label_set(GTK_LABEL(b->idletime), idlet);
1324 else
1325 gtk_label_set(GTK_LABEL(b->idletime), "");
1326 if (display_options & OPT_DISP_SHOW_IDLETIME)
1327 gtk_widget_show(b->idletime);
1328
1329
1330 sotime = sec_to_text(t - b->signon + correction_time);
1331 if (b->idle) {
1332 itime = sec_to_text(t - b->idle);
1333 } else {
1334 itime = g_malloc(1);
1335 itime[0] = 0;
1336 }
1337
1338 if (b->evil) {
1339 g_snprintf(warn, sizeof(warn), "Warnings: %d%%\n", b->evil);
1340
1341 } else
1342 warn[0] = '\0';
1343
1344 i = g_snprintf(infotip, sizeof(infotip), "Name: %s \nLogged in: %s\n%s%s%s", b->name, sotime, warn, ((b->idle) ? "Idle: " : ""), itime);
1345
1346 gtk_tooltips_set_tip(tips, GTK_WIDGET(b->item), infotip, "");
1347
1348 g_free(sotime);
1349 g_free(itime);
1350
1351
1352
1353 if (!GTK_WIDGET_VISIBLE(b->item)) {
1354
1355 play_sound(BUDDY_ARRIVE);
1356
1357 who = g_malloc(sizeof(b->name) + 10);
1358 strcpy(who, b->name);
1359
1360 g_free(who);
1361 pm = gdk_pixmap_create_from_xpm_d(blist->window, &bm,
1362 NULL, (gchar **)login_icon_xpm);
1363 gtk_widget_hide(b->pix);
1364 gtk_pixmap_set(GTK_PIXMAP(b->pix), pm, bm);
1365 if (display_options & OPT_DISP_SHOW_PIXMAPS)
1366 gtk_widget_show(b->pix);
1367
1368 if (display_options & OPT_DISP_SHOW_LOGON) {
1369 struct conversation *c = find_conversation(b->name);
1370 if (c) {
1371 char tmp[1024];
1372
1373
1374 g_snprintf(tmp, sizeof(tmp), "<HR><B>%s logged in%s%s.</B><BR><HR>", b->name,
1375 ((display_options & OPT_DISP_SHOW_TIME) ? " @ " : ""),
1376 ((display_options & OPT_DISP_SHOW_TIME) ? date() : ""));
1377
1378
1379 write_to_conv(c, tmp, WFLAG_SYSTEM);
1380
1381 }
1382 }
1383
1384
1385 gtk_widget_show(b->item);
1386 gtk_widget_show(b->label);
1387 b->log_timer = gtk_timeout_add(10000, (GtkFunction) log_timeout, b->name);
1388 update_num_groups();
1389 update_show_idlepix();
1390 setup_buddy_chats();
1391 return;
1392 }
1393
1394
1395
1396 if (!b->log_timer) {
1397 gtk_widget_hide(b->pix);
1398 if (b->uc & UC_UNAVAILABLE) {
1399 pm = gdk_pixmap_create_from_xpm_d(blist->window, &bm,
1400 NULL, (gchar **)away_icon_xpm);
1401 gtk_pixmap_set(GTK_PIXMAP(b->pix), pm, bm);
1402 } else if (b->uc & UC_AOL) {
1403 pm = gdk_pixmap_create_from_xpm_d(blist->window, &bm,
1404 NULL, (gchar **)aol_icon_xpm);
1405 gtk_pixmap_set(GTK_PIXMAP(b->pix), pm, bm);
1406 } else if (b->uc & UC_NORMAL) {
1407 pm = gdk_pixmap_create_from_xpm_d(blist->window, &bm,
1408 NULL, (gchar **)free_icon_xpm);
1409 gtk_pixmap_set(GTK_PIXMAP(b->pix), pm, bm);
1410 } else if (b->uc & UC_ADMIN) {
1411 pm = gdk_pixmap_create_from_xpm_d(blist->window, &bm,
1412 NULL, (gchar **)admin_icon_xpm);
1413 gtk_pixmap_set(GTK_PIXMAP(b->pix), pm, bm);
1414 } else if (b->uc & UC_UNCONFIRMED) {
1415 pm = gdk_pixmap_create_from_xpm_d(blist->window, &bm,
1416 NULL, (gchar **)dt_icon_xpm);
1417 gtk_pixmap_set(GTK_PIXMAP(b->pix), pm, bm);
1418 } else {
1419 pm = gdk_pixmap_create_from_xpm_d(blist->window, &bm,
1420 NULL, (gchar **)no_icon_xpm);
1421 gtk_pixmap_set(GTK_PIXMAP(b->pix), pm, bm);
1422 }
1423 if (display_options & OPT_DISP_SHOW_PIXMAPS)
1424 gtk_widget_show(b->pix);
1425 }
1426
1427
1428
1429 } else {
1430 if (GTK_WIDGET_VISIBLE(b->item)) {
1431 play_sound(BUDDY_LEAVE);
1432 pm = gdk_pixmap_create_from_xpm_d(blist->window, &bm,
1433 NULL, (gchar **)logout_icon_xpm);
1434 gtk_widget_hide(b->pix);
1435 gtk_pixmap_set(GTK_PIXMAP(b->pix), pm, bm);
1436 if (display_options & OPT_DISP_SHOW_PIXMAPS)
1437 gtk_widget_show(b->pix);
1438 if (display_options & OPT_DISP_SHOW_LOGON) {
1439 struct conversation *c = find_conversation(b->name);
1440 if (c) {
1441 char tmp[1024];
1442
1443
1444 g_snprintf(tmp, sizeof(tmp), "<HR><B>%s logged out%s%s.</B><BR><HR>", b->name,
1445 ((display_options & OPT_DISP_SHOW_TIME) ? " @ " : ""),
1446 ((display_options & OPT_DISP_SHOW_TIME) ? date() : ""));
1447
1448
1449 write_to_conv(c, tmp, WFLAG_SYSTEM);
1450
1451 }
1452 }
1453 b->log_timer = gtk_timeout_add(10000, (GtkFunction)log_timeout, b->name);
1454 update_num_groups();
1455 update_show_idlepix();
1456 }
1457 }
1458 setup_buddy_chats();
1459 }
1460
1461
1462 static void set_permit(GtkWidget *w, int *data)
1463 {
1464 permdeny = (int)data;
1465 /* printf("BLAH BLAH %d %d", permdeny, (int) data); */
1466 /* We don't save this 'at home', it's on the server.
1467 * So, we gotta resend the config to the server. */
1468 serv_save_config();
1469 }
1470
1471
1472 static void move_blist_window(GtkWidget *w, GdkEventConfigure *e, void *dummy)
1473 {
1474 int x, y, width, height;
1475 int save = 0;
1476 gdk_window_get_position(blist->window, &x, &y);
1477 gdk_window_get_size(blist->window, &width, &height);
1478
1479 if(e->send_event) { /* Is a position event */
1480 if (blist_pos.x != x || blist_pos.y != y)
1481 save = 1;
1482 blist_pos.x = x;
1483 blist_pos.y = y;
1484 } else { /* Is a size event */
1485 if (blist_pos.xoff != x || blist_pos.yoff != y ||
1486 blist_pos.width != width || blist_pos.width != width)
1487 save = 1;
1488
1489 blist_pos.width = width;
1490 blist_pos.height = height;
1491 blist_pos.xoff = x;
1492 blist_pos.yoff = y;
1493 }
1494
1495 if (save)
1496 save_prefs();
1497
1498 }
1499
1500
1501 /*******************************************************************
1502 *
1503 * Helper funs for making the menu
1504 *
1505 *******************************************************************/
1506
1507 void gaim_seperator(GtkWidget *menu)
1508 {
1509 GtkWidget *sep, *menuitem;
1510 sep = gtk_hseparator_new();
1511 menuitem = gtk_menu_item_new();
1512 gtk_menu_append(GTK_MENU(menu), menuitem);
1513 gtk_container_add(GTK_CONTAINER(menuitem), sep);
1514 gtk_widget_set_sensitive(menuitem, FALSE);
1515 gtk_widget_show(menuitem);
1516 gtk_widget_show(sep);
1517 }
1518
1519 GtkWidget *gaim_new_item(GtkWidget *menu, const char *str, GtkSignalFunc sf)
1520 {
1521 GtkWidget *menuitem;
1522 menuitem = gtk_menu_item_new_with_label(str);
1523 if (menu)
1524 gtk_menu_append(GTK_MENU(menu), menuitem);
1525 gtk_widget_show(menuitem);
1526 if (sf)
1527 gtk_signal_connect(GTK_OBJECT(menuitem), "activate", sf, NULL);
1528 return menuitem;
1529 }
1530
1531
1532
1533
1534
1535 void show_buddy_list()
1536 {
1537
1538 /* Build the buddy list, based on *config */
1539
1540 GtkWidget *sw;
1541 GtkWidget *menu;
1542 GtkWidget *findmenu;
1543 GtkWidget *setmenu;
1544 GtkWidget *menubar;
1545 GtkWidget *vbox;
1546 GtkWidget *hbox;
1547 GtkWidget *menuitem;
1548 GtkWidget *notebook;
1549 GtkWidget *label;
1550 GtkWidget *bbox;
1551 GtkWidget *permopt;
1552 GtkWidget *tbox;
1553 GtkWidget *xbox;
1554 GtkWidget *pbox;
1555
1556
1557 #ifdef USE_APPLET
1558 blist = gtk_window_new(GTK_WINDOW_DIALOG);
1559 #else
1560 blist = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1561 #endif
1562
1563 gtk_widget_realize(blist);
1564 aol_icon(blist->window);
1565
1566 gtk_window_set_policy(GTK_WINDOW(blist), TRUE, TRUE, TRUE);
1567
1568 menubar = gtk_menu_bar_new();
1569
1570 menu = gtk_menu_new();
1571
1572
1573 menuitem = gaim_new_item(NULL, "File", NULL);
1574 gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), menu);
1575 gtk_menu_bar_append(GTK_MENU_BAR(menubar), menuitem);
1576
1577 gaim_new_item(menu, "Add A Buddy", GTK_SIGNAL_FUNC(add_buddy_callback));
1578 gaim_seperator(menu);
1579 gaim_new_item(menu, "Import Buddy List", GTK_SIGNAL_FUNC(import_callback));
1580 gaim_new_item(menu, "Export Buddy List", GTK_SIGNAL_FUNC(export_callback));
1581 if (!(general_options & OPT_GEN_REGISTERED))
1582 {
1583 gaim_seperator(menu);
1584 gaim_new_item(menu, "Register", GTK_SIGNAL_FUNC(gaimreg_callback));
1585 }
1586 gaim_seperator(menu);
1587 gaim_new_item(menu, "Signoff", GTK_SIGNAL_FUNC(signoff));
1588
1589 #ifndef USE_APPLET
1590 gaim_new_item(menu, "Quit", GTK_SIGNAL_FUNC(do_quit));
1591 #else
1592 gaim_new_item(menu, "Close", GTK_SIGNAL_FUNC(applet_destroy_buddy));
1593 #endif
1594
1595 menu = gtk_menu_new();
1596
1597 menuitem = gaim_new_item(NULL, "Tools", NULL);
1598 gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), menu);
1599 gtk_menu_bar_append(GTK_MENU_BAR(menubar), menuitem);
1600
1601 awaymenu = gtk_menu_new();
1602 menuitem = gaim_new_item(menu, "Away", NULL);
1603 gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), awaymenu);
1604 do_away_menu();
1605
1606 bpmenu = gtk_menu_new();
1607 menuitem = gaim_new_item(menu, "Buddy Pounce", NULL);
1608 gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), bpmenu);
1609 do_bp_menu();
1610
1611 gaim_seperator(menu);
1612
1613 findmenu = gtk_menu_new();
1614 gtk_widget_show(findmenu);
1615 menuitem = gaim_new_item(menu, "Search for Buddy", NULL);
1616 gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), findmenu);
1617 gtk_widget_show(menuitem);
1618 menuitem = gtk_menu_item_new_with_label("by Email");
1619 gtk_menu_append(GTK_MENU(findmenu), menuitem);
1620 gtk_signal_connect(GTK_OBJECT(menuitem), "activate", GTK_SIGNAL_FUNC(show_find_email), NULL);
1621 gtk_widget_show(menuitem);
1622 menuitem = gtk_menu_item_new_with_label("by Dir Info");
1623 gtk_menu_append(GTK_MENU(findmenu), menuitem);
1624 gtk_signal_connect(GTK_OBJECT(menuitem), "activate", GTK_SIGNAL_FUNC(show_find_info), NULL);
1625 gtk_widget_show(menuitem);
1626
1627
1628 setmenu = gtk_menu_new();
1629 gtk_widget_show(setmenu);
1630 menuitem = gaim_new_item(menu, "Settings", NULL);
1631 gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), setmenu);
1632 gtk_widget_show(menuitem);
1633 menuitem = gtk_menu_item_new_with_label("User Info");
1634 gtk_menu_append(GTK_MENU(setmenu), menuitem);
1635 gtk_signal_connect(GTK_OBJECT(menuitem), "activate", GTK_SIGNAL_FUNC(show_set_info), NULL);
1636 gtk_widget_show(menuitem);
1637 menuitem = gtk_menu_item_new_with_label("Directory Info");
1638 gtk_menu_append(GTK_MENU(setmenu), menuitem);
1639 gtk_signal_connect(GTK_OBJECT(menuitem), "activate", GTK_SIGNAL_FUNC(show_set_dir), NULL);
1640 gtk_widget_show(menuitem);
1641
1642 /* Ok, this is the menu hookup for the plugin stuff */
1643 #ifdef GAIM_PLUGINS
1644 gaim_seperator(menu);
1645
1646 gaim_new_item(menu, "Plugins", GTK_SIGNAL_FUNC(show_plugins));
1647 #endif
1648
1649 /*---------------*/
1650
1651 gaim_seperator(menu);
1652
1653 gaim_new_item(menu, "Preferences", GTK_SIGNAL_FUNC(show_prefs));
1654
1655 menu = gtk_menu_new();
1656
1657 menuitem = gaim_new_item(NULL, "Help", NULL);
1658 gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), menu);
1659 gtk_menu_item_right_justify(GTK_MENU_ITEM(menuitem));
1660 gtk_menu_bar_append(GTK_MENU_BAR(menubar), menuitem);
1661
1662 gaim_new_item(menu, "About", show_about);
1663
1664 gtk_widget_show(menubar);
1665
1666 lagometer_box = gtk_hbox_new(FALSE, 0);
1667
1668
1669 lagometer = gtk_progress_bar_new();
1670 gtk_widget_show(lagometer);
1671
1672 label = gtk_label_new("Lag-O-Meter: ");
1673 gtk_widget_show(label);
1674
1675 gtk_box_pack_start(GTK_BOX(lagometer_box), label, FALSE, FALSE, 5);
1676 gtk_box_pack_start(GTK_BOX(lagometer_box), lagometer, TRUE, TRUE, 5);
1677
1678 gtk_widget_set_usize(lagometer, 5, 5);
1679
1680
1681 if ((general_options & OPT_GEN_SHOW_LAGMETER))
1682 gtk_widget_show(lagometer_box);
1683
1684
1685 vbox = gtk_vbox_new(FALSE, 10);
1686
1687 notebook = gtk_notebook_new();
1688
1689
1690
1691
1692 /* Do buddy list stuff */
1693
1694 buddypane = gtk_vbox_new(FALSE, 0);
1695
1696 imbutton = gtk_button_new_with_label("Im");
1697 infobutton = gtk_button_new_with_label("Info");
1698 chatbutton = gtk_button_new_with_label("Chat");
1699
1700 hbox = gtk_hbox_new(TRUE, 10);
1701
1702 buddies = gtk_tree_new();
1703 sw = gtk_scrolled_window_new(NULL, NULL);
1704
1705
1706
1707
1708
1709 tips = gtk_tooltips_new();
1710 gtk_object_set_data(GTK_OBJECT(blist), "Buddy List", tips);
1711
1712
1713
1714 /* Now the buddy list */
1715 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(sw),buddies);
1716 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw),
1717 GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
1718 gtk_widget_set_usize(sw,200,200);
1719 gtk_widget_show(buddies);
1720 gtk_widget_show(sw);
1721
1722 /* Put the buttons in the hbox */
1723 gtk_widget_show(imbutton);
1724 gtk_widget_show(chatbutton);
1725 gtk_widget_show(infobutton);
1726
1727 gtk_box_pack_start(GTK_BOX(hbox), imbutton, TRUE, TRUE, 0);
1728 gtk_box_pack_start(GTK_BOX(hbox), infobutton, TRUE, TRUE, 0);
1729 gtk_box_pack_start(GTK_BOX(hbox), chatbutton, TRUE, TRUE, 0);
1730 gtk_container_border_width(GTK_CONTAINER(hbox), 10);
1731
1732
1733 gtk_tooltips_set_tip(tips,infobutton, "Information on selected Buddy", "Penguin");
1734 gtk_tooltips_set_tip(tips,imbutton, "Send Instant Message", "Penguin");
1735 gtk_tooltips_set_tip(tips,chatbutton, "Start/join a Buddy Chat", "Penguin");
1736
1737 gtk_box_pack_start(GTK_BOX(buddypane), sw, TRUE, TRUE, 0);
1738 gtk_box_pack_start(GTK_BOX(buddypane), hbox, FALSE, FALSE, 0);
1739
1740 gtk_widget_show(hbox);
1741 gtk_widget_show(buddypane);
1742
1743
1744
1745 /* Swing the edit buddy */
1746 editpane = gtk_vbox_new(FALSE, 0);
1747
1748
1749 addbutton = gtk_button_new_with_label("Add");
1750 rembutton = gtk_button_new_with_label("Remove");
1751 edittree = gtk_ctree_new(1, 0);
1752 gtk_ctree_set_line_style (GTK_CTREE(edittree), GTK_CTREE_LINES_SOLID);
1753 gtk_ctree_set_expander_style(GTK_CTREE(edittree), GTK_CTREE_EXPANDER_SQUARE);
1754 gtk_clist_set_reorderable(GTK_CLIST(edittree), TRUE);
1755
1756 gtk_ctree_set_drag_compare_func (GTK_CTREE(edittree),
1757 (GtkCTreeCompareDragFunc)edit_drag_compare_func);
1758
1759
1760 gtk_signal_connect_after (GTK_OBJECT (edittree), "tree_move",
1761 GTK_SIGNAL_FUNC (edit_tree_move), NULL);
1762
1763
1764 bbox = gtk_hbox_new(TRUE, 10);
1765 tbox = gtk_scrolled_window_new(NULL, NULL);
1766 /* Put the buttons in the box */
1767 gtk_box_pack_start(GTK_BOX(bbox), addbutton, TRUE, TRUE, 10);
1768 gtk_box_pack_start(GTK_BOX(bbox), rembutton, TRUE, TRUE, 10);
1769
1770 gtk_tooltips_set_tip(tips, addbutton, "Add a new Buddy", "Penguin");
1771 gtk_tooltips_set_tip(tips, rembutton, "Remove selected Buddy", "Penguin");
1772
1773 /* And the boxes in the box */
1774 gtk_box_pack_start(GTK_BOX(editpane), tbox, TRUE, TRUE, 5);
1775 gtk_box_pack_start(GTK_BOX(editpane), bbox, FALSE, FALSE, 5);
1776
1777 /* Handle closes right */
1778
1779
1780
1781 /* Finish up */
1782 gtk_widget_show(addbutton);
1783 gtk_widget_show(rembutton);
1784 gtk_widget_show(edittree);
1785 gtk_widget_show(tbox);
1786 gtk_widget_show(bbox);
1787 gtk_widget_show(editpane);
1788
1789
1790 /* Permit/Deny */
1791
1792 permitpane = gtk_vbox_new(FALSE, 0);
1793
1794 permopt = gtk_radio_button_new_with_label(NULL, "Allow anyone");
1795 gtk_box_pack_start(GTK_BOX(permitpane), permopt, FALSE, FALSE, 0);
1796 gtk_signal_connect(GTK_OBJECT(permopt), "clicked", GTK_SIGNAL_FUNC(set_permit), (void *)1);
1797 gtk_widget_show(permopt);
1798 if (permdeny == 1)
1799 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(permopt), TRUE);
1800
1801 permopt = gtk_radio_button_new_with_label(gtk_radio_button_group(GTK_RADIO_BUTTON(permopt)), "Permit some");
1802 gtk_box_pack_start(GTK_BOX(permitpane), permopt, FALSE, FALSE, 0);
1803 gtk_signal_connect(GTK_OBJECT(permopt), "clicked", GTK_SIGNAL_FUNC(set_permit), (void *)3);
1804 gtk_widget_show(permopt);
1805 if (permdeny == 3)
1806 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(permopt), TRUE);
1807
1808
1809 permopt = gtk_radio_button_new_with_label(gtk_radio_button_group(GTK_RADIO_BUTTON(permopt)), "Deny some");
1810 gtk_box_pack_start(GTK_BOX(permitpane), permopt, FALSE, FALSE, 0);
1811 gtk_signal_connect(GTK_OBJECT(permopt), "clicked", GTK_SIGNAL_FUNC(set_permit), (void *)4);
1812 gtk_widget_show(permopt);
1813 if (permdeny == 4)
1814 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(permopt), TRUE);
1815
1816
1817
1818 addpermbutton = gtk_button_new_with_label("Add");
1819 rempermbutton = gtk_button_new_with_label("Remove");
1820
1821 permtree = gtk_tree_new();
1822 pbox = gtk_hbox_new(TRUE, 10);
1823 xbox = gtk_scrolled_window_new(NULL, NULL);
1824 /* Put the buttons in the box */
1825 gtk_box_pack_start(GTK_BOX(pbox), addpermbutton, TRUE, TRUE, 10);
1826 gtk_box_pack_start(GTK_BOX(pbox), rempermbutton, TRUE, TRUE, 10);
1827
1828
1829 gtk_tooltips_set_tip(tips, addpermbutton, "Add buddy to permit/deny", "Penguin");
1830 gtk_tooltips_set_tip(tips, rempermbutton, "Remove buddy from permit/deny", "Penguin");
1831 /* And the boxes in the box */
1832 gtk_box_pack_start(GTK_BOX(permitpane), xbox, TRUE, TRUE, 5);
1833 gtk_box_pack_start(GTK_BOX(permitpane), pbox, FALSE, FALSE, 5);
1834
1835 /* Handle closes right */
1836
1837
1838
1839 /* Finish up */
1840 gtk_widget_show(addpermbutton);
1841 gtk_widget_show(rempermbutton);
1842 gtk_widget_show(permtree);
1843 gtk_widget_show(xbox);
1844 gtk_widget_show(pbox);
1845 gtk_widget_show(permitpane);
1846
1847
1848
1849 label = gtk_label_new("Online");
1850 gtk_notebook_append_page(GTK_NOTEBOOK(notebook), buddypane, label);
1851 label = gtk_label_new("Edit Buddies");
1852 gtk_notebook_append_page(GTK_NOTEBOOK(notebook), editpane, label);
1853 label = gtk_label_new("Permit");
1854 gtk_notebook_append_page(GTK_NOTEBOOK(notebook), permitpane, label);
1855
1856 gtk_widget_show_all(notebook);
1857
1858 /* Pack things in the vbox */
1859 gtk_widget_show(vbox);
1860
1861
1862 gtk_widget_show(notebook);
1863
1864 /* Enable buttons */
1865
1866 gtk_signal_connect(GTK_OBJECT(imbutton), "clicked", GTK_SIGNAL_FUNC(show_im_dialog), buddies);
1867 gtk_signal_connect(GTK_OBJECT(infobutton), "clicked", GTK_SIGNAL_FUNC(info_callback), buddies);
1868 gtk_signal_connect(GTK_OBJECT(chatbutton), "clicked", GTK_SIGNAL_FUNC(chat_callback), buddies);
1869 gtk_signal_connect(GTK_OBJECT(rembutton), "clicked", GTK_SIGNAL_FUNC(do_del_buddy), edittree);
1870 gtk_signal_connect(GTK_OBJECT(addbutton), "clicked", GTK_SIGNAL_FUNC(add_buddy_callback), NULL);
1871 gtk_signal_connect(GTK_OBJECT(addpermbutton), "clicked", GTK_SIGNAL_FUNC(add_perm_callback), NULL);
1872 gtk_signal_connect(GTK_OBJECT(rempermbutton), "clicked", GTK_SIGNAL_FUNC(do_del_perm), permtree);
1873 gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, TRUE, 0);
1874 gtk_box_pack_start(GTK_BOX(vbox), lagometer_box, FALSE, TRUE, 0);
1875 gtk_box_pack_start(GTK_BOX(vbox), notebook, TRUE, TRUE, 0);
1876
1877 gtk_container_add(GTK_CONTAINER(blist), vbox);
1878
1879 #ifndef USE_APPLET
1880 gtk_signal_connect(GTK_OBJECT(blist), "delete_event", GTK_SIGNAL_FUNC(do_quit), blist);
1881 #else
1882 gtk_signal_connect(GTK_OBJECT(blist), "delete_event", GTK_SIGNAL_FUNC(applet_destroy_buddy), NULL);
1883 #endif
1884
1885 gtk_signal_connect(GTK_OBJECT(blist), "configure_event", GTK_SIGNAL_FUNC(move_blist_window), NULL);
1886
1887
1888
1889 /* The edit tree */
1890 gtk_container_add(GTK_CONTAINER(tbox), edittree);
1891 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(tbox),
1892 GTK_POLICY_NEVER,GTK_POLICY_AUTOMATIC);
1893
1894
1895 /* The permit tree */
1896 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(xbox), permtree);
1897 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(xbox),
1898 GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
1899
1900 gtk_window_set_title(GTK_WINDOW(blist), "Gaim - Buddy List");
1901
1902 if (general_options & OPT_GEN_SAVED_WINDOWS) {
1903 if (blist_pos.width != 0) { /* Sanity check! */
1904 gtk_widget_set_uposition(blist, blist_pos.x - blist_pos.xoff, blist_pos.y - blist_pos.yoff);
1905 gtk_widget_set_usize(blist, blist_pos.width, blist_pos.height);
1906 }
1907 }
1908 }
1909
1910 void refresh_buddy_window()
1911 {
1912 setup_buddy_chats();
1913
1914 build_edit_tree();
1915 build_permit_tree();
1916
1917 update_button_pix();
1918 gtk_widget_show(blist);
1919
1920
1921 }
1922