1
|
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;
|
10
|
83 #ifdef USE_APPLET
|
|
84 buddy_created = FALSE;
|
|
85 #endif
|
1
|
86 }
|
|
87
|
|
88 void update_num_groups()
|
|
89 {
|
|
90 GList *grp = groups;
|
|
91 GList *mem;
|
|
92 struct buddy *b;
|
|
93 struct group *g;
|
|
94 int pres, total;
|
|
95 char buf[BUF_LONG];
|
|
96
|
|
97 if (!(display_options & OPT_DISP_SHOW_GRPNUM))
|
|
98 return;
|
|
99
|
|
100 while(grp) {
|
|
101 g = (struct group *)grp->data;
|
|
102 mem = g->members;
|
|
103 pres = 0;
|
|
104 total = 0;
|
|
105 while(mem) {
|
|
106 b = (struct buddy *)mem->data;
|
|
107 if (b->present)
|
|
108 pres++;
|
|
109 total++;
|
|
110
|
|
111
|
|
112 mem = mem->next;
|
|
113 }
|
|
114
|
|
115 g_snprintf(buf, sizeof(buf), "%s (%d/%d)", g->name, pres, total);
|
|
116
|
|
117 gtk_label_set(GTK_LABEL(g->label), buf);
|
|
118 grp = grp->next;
|
|
119 }
|
|
120
|
|
121 }
|
|
122
|
|
123 void update_show_idlepix()
|
|
124 {
|
|
125 GList *grp = groups;
|
|
126 GList *mem;
|
|
127 struct group *g;
|
|
128 struct buddy *b;
|
|
129
|
|
130 while (grp) {
|
|
131 g = (struct group *)grp->data;
|
|
132 mem = g->members;
|
|
133
|
|
134 while(mem) {
|
|
135 b = (struct buddy *)mem->data;
|
|
136
|
|
137 if (display_options & OPT_DISP_SHOW_IDLETIME)
|
|
138 gtk_widget_show(b->idletime);
|
|
139 else
|
|
140 gtk_widget_hide(b->idletime);
|
|
141
|
|
142 if (display_options & OPT_DISP_SHOW_PIXMAPS)
|
|
143 gtk_widget_show(b->pix);
|
|
144 else
|
|
145 gtk_widget_hide(b->pix);
|
|
146 mem = mem->next;
|
|
147 }
|
|
148 grp = grp->next;
|
|
149 }
|
|
150 }
|
|
151
|
|
152 void update_all_buddies()
|
|
153 {
|
|
154 GList *grp = groups;
|
|
155 GList *mem;
|
|
156 struct buddy *b;
|
|
157 struct group *g;
|
|
158
|
|
159 while(grp) {
|
|
160 g = (struct group *)grp->data;
|
|
161 mem = g->members;
|
|
162 while(mem) {
|
|
163 b = (struct buddy *)mem->data;
|
|
164
|
59
|
165 if (b->present || !GTK_WIDGET_VISIBLE(b->item))
|
|
166 set_buddy(b);
|
1
|
167
|
|
168 mem = mem->next;
|
|
169 }
|
|
170 grp = grp->next;
|
|
171 }
|
|
172
|
|
173
|
|
174 }
|
|
175
|
|
176 void update_lagometer(int us)
|
|
177 {
|
|
178 double pct;
|
|
179
|
|
180
|
|
181
|
|
182 if (us != -1)
|
|
183 last_lag_us = us;
|
|
184
|
|
185
|
|
186 if (lagometer_box == NULL)
|
|
187 return;
|
|
188
|
|
189
|
|
190 if (!(general_options & OPT_GEN_SHOW_LAGMETER))
|
|
191 gtk_widget_hide(lagometer_box);
|
|
192 else
|
|
193 gtk_widget_show(lagometer_box);
|
|
194
|
|
195
|
|
196 pct = last_lag_us/100000;
|
6
|
197
|
|
198 if (pct > 0)
|
|
199 pct = 25 * log(pct);
|
1
|
200
|
|
201 if (pct < 0)
|
|
202 pct = 0;
|
|
203
|
|
204 if (pct > 100)
|
|
205 pct = 100;
|
|
206
|
|
207
|
|
208 pct /= 100;
|
|
209
|
|
210
|
|
211 gtk_progress_bar_update(GTK_PROGRESS_BAR(lagometer), pct);
|
|
212 }
|
|
213
|
|
214 static void adjust_pic(GtkWidget *button, const char *c, gchar **xpm)
|
|
215 {
|
|
216 GdkPixmap *pm;
|
|
217 GdkBitmap *bm;
|
|
218 GtkWidget *pic;
|
|
219 GtkWidget *label;
|
|
220
|
|
221 /*if the user had opted to put pictures on the buttons*/
|
|
222 if (display_options & OPT_DISP_SHOW_BUTTON_XPM) {
|
|
223 pm = gdk_pixmap_create_from_xpm_d(blist->window, &bm,
|
|
224 NULL, xpm);
|
|
225 pic = gtk_pixmap_new(pm, bm);
|
|
226 gtk_widget_show(pic);
|
|
227 label = GTK_BIN(button)->child;
|
|
228 gtk_container_remove(GTK_CONTAINER(button), label);
|
|
229 gtk_container_add(GTK_CONTAINER(button), pic);
|
|
230 } else {
|
|
231 label = gtk_label_new(c);
|
|
232 gtk_widget_show(label);
|
|
233 pic = GTK_BIN(button)->child;
|
|
234 gtk_container_remove(GTK_CONTAINER(button), pic);
|
|
235 gtk_container_add(GTK_CONTAINER(button), label);
|
|
236 }
|
|
237
|
|
238 }
|
|
239
|
|
240
|
|
241 void update_button_pix()
|
|
242 {
|
|
243
|
|
244 adjust_pic(addbutton, "Add", (gchar **)buddyadd_xpm);
|
|
245 adjust_pic(rembutton, "Remove", (gchar **)buddydel_xpm);
|
|
246 adjust_pic(chatbutton, "Chat", (gchar **)buddychat_xpm);
|
|
247 adjust_pic(imbutton, "IM", (gchar **)im_xpm);
|
|
248 adjust_pic(infobutton, "Info", (gchar **)info_xpm);
|
|
249 adjust_pic(addpermbutton, "Add", (gchar **)permadd_xpm);
|
|
250 adjust_pic(rempermbutton, "Remove", (gchar **)permdel_xpm);
|
|
251
|
|
252 }
|
|
253
|
|
254
|
|
255
|
|
256 #ifdef USE_APPLET
|
|
257 gint applet_destroy_buddy( GtkWidget *widget, GdkEvent *event,gpointer *data ) {
|
|
258 GList *mem;
|
|
259 set_applet_draw_closed();
|
|
260
|
|
261 /****NO LONGER NEEDED
|
|
262 while(groups) {
|
|
263 mem = ((struct group *)groups->data)->members;
|
|
264 while(mem) {
|
|
265 g_free(mem->data);
|
|
266 mem = g_list_remove(mem, mem->data);
|
|
267 }
|
|
268 g_free(groups->data);
|
|
269 groups = g_list_remove(groups, groups->data);
|
|
270 }
|
|
271
|
|
272 destroy_buddy();
|
|
273 */
|
|
274 gnome_buddy_hide();
|
|
275 applet_widget_register_callback(APPLET_WIDGET(applet),
|
|
276 "buddy",
|
|
277 _("Buddy List"),
|
|
278 (AppletCallbackFunc)make_buddy,
|
|
279 NULL);
|
|
280 return (TRUE);
|
|
281 }
|
|
282
|
|
283 void gnome_buddy_show(){
|
|
284 gtk_widget_show( blist );
|
|
285 }
|
|
286
|
|
287 void gnome_buddy_hide(){
|
|
288 gtk_widget_hide( blist );
|
|
289 }
|
|
290
|
|
291 void gnome_buddy_set_pos( gint x, gint y ){
|
|
292 gtk_widget_set_uposition ( blist, x, y );
|
|
293 }
|
|
294
|
|
295 GtkRequisition gnome_buddy_get_dimentions(){
|
|
296 return blist->requisition;
|
|
297 }
|
|
298
|
|
299 #endif
|
|
300
|
|
301
|
|
302 void signoff()
|
|
303 {
|
|
304 GList *mem;
|
|
305 while(groups) {
|
|
306 mem = ((struct group *)groups->data)->members;
|
|
307 while(mem) {
|
|
308 g_free(mem->data);
|
|
309 mem = g_list_remove(mem, mem->data);
|
|
310 }
|
|
311 g_free(groups->data);
|
|
312 groups = g_list_remove(groups, groups->data);
|
|
313 }
|
|
314
|
|
315 serv_close();
|
|
316 destroy_all_dialogs();
|
|
317 destroy_buddy();
|
|
318 hide_login_progress("");
|
|
319 #ifdef USE_APPLET
|
|
320 set_applet_draw_closed();
|
|
321 applet_widget_unregister_callback(APPLET_WIDGET(applet),"signoff");
|
18
|
322 remove_applet_away();
|
1
|
323 applet_widget_unregister_callback(APPLET_WIDGET(applet),"buddy");
|
|
324 applet_widget_register_callback(APPLET_WIDGET(applet),
|
|
325 "signon",
|
|
326 _("Signon"),
|
|
327 applet_show_login,
|
|
328 NULL);
|
|
329 #else
|
|
330 show_login();
|
|
331 #endif /* USE_APPLET */
|
|
332 }
|
|
333
|
|
334 void handle_click_group(GtkWidget *widget, GdkEventButton *event, gpointer func_data)
|
|
335 {
|
|
336 if (event->type == GDK_2BUTTON_PRESS) {
|
|
337 if (GTK_TREE_ITEM(widget)->expanded)
|
|
338 gtk_tree_item_collapse(GTK_TREE_ITEM(widget));
|
|
339 else
|
|
340 gtk_tree_item_expand(GTK_TREE_ITEM(widget));
|
|
341 } else {
|
|
342 }
|
|
343 }
|
|
344
|
|
345 void pressed_im(GtkWidget *widget, struct buddy *b)
|
|
346 {
|
|
347 struct conversation *c;
|
|
348
|
|
349 c = find_conversation(b->name);
|
|
350
|
|
351 if (c != NULL) {
|
|
352 gdk_window_raise(c->window->window);
|
|
353 } else {
|
|
354 c = new_conversation(b->name);
|
|
355 }
|
|
356 }
|
|
357
|
|
358 void pressed_info(GtkWidget *widget, struct buddy *b)
|
|
359 {
|
|
360 serv_get_info(b->name);
|
|
361
|
|
362 }
|
|
363
|
|
364 void pressed_dir_info(GtkWidget *widget, struct buddy *b)
|
|
365 {
|
|
366 serv_get_dir(b->name);
|
|
367
|
|
368 }
|
|
369
|
|
370 void handle_click_buddy(GtkWidget *widget, GdkEventButton *event, struct buddy *b)
|
|
371 {
|
|
372 if (event->type == GDK_2BUTTON_PRESS && event->button == 1) {
|
|
373 struct conversation *c;
|
|
374
|
|
375 c = find_conversation(b->name);
|
|
376
|
|
377 if (c != NULL) {
|
|
378 gdk_window_raise(c->window->window);
|
|
379 } else {
|
|
380 c = new_conversation(b->name);
|
|
381 }
|
|
382 } else if (event->type == GDK_BUTTON_PRESS && event->button == 3) {
|
|
383 GtkWidget *menu, *button;
|
|
384 /* We're gonna make us a menu right here */
|
|
385
|
|
386 menu = gtk_menu_new();
|
|
387
|
|
388 button = gtk_menu_item_new_with_label("IM");
|
|
389 gtk_signal_connect(GTK_OBJECT(button), "activate",
|
|
390 GTK_SIGNAL_FUNC(pressed_im), b);
|
|
391 gtk_menu_append(GTK_MENU(menu), button);
|
|
392 gtk_widget_show(button);
|
|
393
|
|
394 button = gtk_menu_item_new_with_label("Info");
|
|
395 gtk_signal_connect(GTK_OBJECT(button), "activate",
|
|
396 GTK_SIGNAL_FUNC(pressed_info), b);
|
|
397 gtk_menu_append(GTK_MENU(menu), button);
|
|
398 gtk_widget_show(button);
|
|
399
|
|
400 button = gtk_menu_item_new_with_label("Dir Info");
|
|
401 gtk_signal_connect(GTK_OBJECT(button), "activate",
|
|
402 GTK_SIGNAL_FUNC(pressed_dir_info), b);
|
|
403 gtk_menu_append(GTK_MENU(menu), button);
|
|
404 gtk_widget_show(button);
|
|
405
|
|
406 button = gtk_menu_item_new_with_label("Toggle Logging");
|
|
407 gtk_signal_connect(GTK_OBJECT(button), "activate",
|
|
408 GTK_SIGNAL_FUNC(log_callback), b->name);
|
|
409 gtk_menu_append(GTK_MENU(menu), button);
|
|
410 gtk_widget_show(button);
|
|
411
|
|
412 button = gtk_menu_item_new_with_label("Add Buddy Pounce");
|
|
413 gtk_signal_connect(GTK_OBJECT(button), "activate",
|
|
414 GTK_SIGNAL_FUNC(new_bp_callback), b->name);
|
|
415 gtk_menu_append(GTK_MENU(menu), button);
|
|
416 gtk_widget_show(button);
|
|
417
|
|
418
|
|
419
|
|
420 gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL,
|
|
421 event->button, event->time);
|
|
422
|
|
423 } else if (event->type == GDK_3BUTTON_PRESS && event->button == 2) {
|
|
424 if (!strcasecmp("zilding", normalize(b->name)))
|
|
425 show_ee_dialog(0);
|
|
426 else if (!strcasecmp("robflynn", normalize(b->name)))
|
|
427 show_ee_dialog(1);
|
|
428 else if (!strcasecmp("flynorange", normalize(b->name)))
|
|
429 show_ee_dialog(2);
|
|
430
|
|
431 } else {
|
|
432
|
|
433 /* Anything for other buttons? :) */
|
|
434 }
|
|
435 }
|
|
436
|
|
437
|
|
438
|
|
439 void remove_buddy(struct group *rem_g, struct buddy *rem_b)
|
|
440 {
|
|
441 GList *grp;
|
|
442 GList *mem;
|
|
443
|
|
444 struct group *delg;
|
|
445 struct buddy *delb;
|
|
446
|
|
447 grp = g_list_find(groups, rem_g);
|
|
448 delg = (struct group *)grp->data;
|
|
449 mem = delg->members;
|
|
450
|
|
451 mem = g_list_find(mem, rem_b);
|
|
452 delb = (struct buddy *)mem->data;
|
|
453
|
|
454 gtk_tree_remove_items(GTK_TREE(delg->tree), g_list_append(NULL, delb->item));
|
|
455 delg->members = g_list_remove(delg->members, delb);
|
|
456 serv_remove_buddy(delb->name);
|
|
457 g_free(delb);
|
|
458
|
|
459 serv_save_config();
|
|
460
|
|
461 update_num_groups();
|
|
462
|
|
463
|
|
464 }
|
|
465
|
|
466 void remove_group(struct group *rem_g)
|
|
467 {
|
|
468 GList *grp;
|
|
469 GList *mem;
|
|
470
|
|
471 struct group *delg;
|
|
472 struct buddy *delb;
|
|
473
|
|
474 grp = g_list_find(groups, rem_g);
|
|
475 delg = (struct group *)grp->data;
|
|
476 mem = delg->members;
|
|
477
|
|
478 while(delg->members) {
|
|
479 delb = (struct buddy *)delg->members->data;
|
|
480 gtk_tree_remove_items(GTK_TREE(delg->tree), g_list_append(NULL, delb->item));
|
|
481 delg->members = g_list_remove(delg->members, delb);
|
|
482 serv_remove_buddy(delb->name);
|
|
483 g_free(delb);
|
|
484 }
|
|
485
|
|
486
|
|
487 gtk_tree_remove_items(GTK_TREE(buddies), g_list_append(NULL, delg->item));
|
|
488 groups = g_list_remove(groups, delg);
|
|
489 g_free(delg);
|
|
490
|
|
491 serv_save_config();
|
|
492 }
|
|
493
|
|
494
|
|
495
|
|
496 void build_permit_tree()
|
|
497 {
|
|
498 GtkWidget *ti;
|
|
499 GtkWidget *sub;
|
|
500 GList *plist = permit;
|
|
501 GList *dlist = deny;
|
|
502
|
|
503 gtk_tree_clear_items(GTK_TREE(permtree), 0, -1);
|
|
504
|
|
505 ti = gtk_tree_item_new_with_label("Permit");
|
|
506 sub = gtk_tree_new();
|
|
507 gtk_widget_show(ti);
|
|
508 gtk_widget_show(sub);
|
|
509 gtk_tree_prepend(GTK_TREE(permtree), ti);
|
|
510 gtk_tree_item_set_subtree(GTK_TREE_ITEM(ti), sub);
|
|
511 gtk_tree_item_expand(GTK_TREE_ITEM(ti));
|
|
512
|
|
513 while(plist) {
|
|
514 ti = gtk_tree_item_new_with_label((char *)plist->data);
|
|
515 gtk_widget_show(ti);
|
|
516 gtk_tree_prepend(GTK_TREE(sub), ti);
|
|
517 plist = plist->next;
|
|
518 }
|
|
519
|
|
520
|
|
521 ti = gtk_tree_item_new_with_label("Deny");
|
|
522 sub = gtk_tree_new();
|
|
523 gtk_widget_show(ti);
|
|
524 gtk_widget_show(sub);
|
|
525 gtk_tree_prepend(GTK_TREE(permtree), ti);
|
|
526 gtk_tree_item_set_subtree(GTK_TREE_ITEM(ti), sub);
|
|
527 gtk_tree_item_expand(GTK_TREE_ITEM(ti));
|
|
528
|
|
529 while(dlist) {
|
|
530 ti = gtk_tree_item_new_with_label((char *)dlist->data);
|
|
531 gtk_widget_show(ti);
|
|
532 gtk_tree_prepend(GTK_TREE(sub), ti);
|
|
533 dlist = dlist->next;
|
|
534 }
|
|
535
|
|
536
|
|
537 }
|
|
538
|
|
539
|
|
540 gboolean edit_drag_compare_func (GtkCTree *ctree, GtkCTreeNode *source_node,
|
|
541 GtkCTreeNode *new_parent, GtkCTreeNode *new_sibling)
|
|
542 {
|
|
543 gboolean leaf;
|
|
544
|
|
545 gtk_ctree_get_node_info (ctree, source_node, NULL,
|
|
546 NULL, NULL, NULL, NULL, NULL, &leaf, NULL);
|
|
547
|
|
548
|
|
549 if (leaf) {
|
|
550 if (!new_parent)
|
|
551 return FALSE;
|
|
552 } else {
|
|
553
|
|
554 if (new_parent)
|
|
555 return FALSE;
|
|
556
|
|
557 }
|
|
558
|
|
559 return TRUE;
|
|
560 }
|
|
561
|
|
562
|
|
563
|
|
564 static void edit_tree_move (GtkCTree *ctree, GtkCTreeNode *child, GtkCTreeNode *parent,
|
|
565 GtkCTreeNode *sibling, gpointer data)
|
|
566 {
|
|
567 char *source;
|
|
568 char *target1;
|
|
569 char *target2;
|
|
570
|
|
571 gtk_ctree_get_node_info (ctree, child, &source,
|
|
572 NULL, NULL, NULL, NULL, NULL, NULL, NULL);
|
|
573 if (parent)
|
|
574 gtk_ctree_get_node_info (ctree, parent, &target1,
|
|
575 NULL, NULL, NULL, NULL, NULL, NULL, NULL);
|
|
576 if (sibling)
|
|
577 gtk_ctree_get_node_info (ctree, sibling, &target2,
|
|
578 NULL, NULL, NULL, NULL, NULL, NULL, NULL);
|
|
579
|
|
580
|
|
581 if (!parent) {
|
|
582 GList *grps, *buds;
|
|
583 struct group *g, *g2;
|
|
584 GList *tmp;
|
|
585 int pos;
|
|
586 struct buddy *b;
|
|
587 /* Okay we've moved group order... */
|
|
588
|
|
589 g = find_group(source);
|
|
590
|
|
591 gtk_widget_ref(g->tree);
|
|
592
|
|
593 buds = g->members;
|
|
594 while(buds) {
|
|
595 b = (struct buddy *)buds->data;
|
|
596 gtk_widget_ref(b->item);
|
|
597 gtk_widget_ref(b->label);
|
|
598 gtk_widget_ref(b->idletime);
|
|
599 gtk_widget_ref(b->pix);
|
|
600 buds = buds->next;
|
|
601 }
|
|
602
|
|
603
|
|
604
|
|
605
|
|
606 pos = g_list_index(GTK_TREE(buddies)->children, g->item);
|
|
607
|
|
608 tmp = g_list_append(NULL, g->item);
|
|
609 gtk_tree_remove_items(GTK_TREE(buddies), tmp);
|
|
610 g_list_free(tmp);
|
|
611
|
|
612 groups = g_list_remove(groups, g);
|
|
613
|
|
614 g->item = gtk_tree_item_new_with_label(g->name);
|
|
615 gtk_widget_show(g->item);
|
|
616
|
|
617 if (sibling) {
|
|
618 g2 = find_group(target2);
|
|
619 pos = g_list_index(groups, g2);
|
|
620 if (pos == 0) {
|
|
621 groups = g_list_prepend(groups, g);
|
|
622 gtk_tree_prepend(GTK_TREE(buddies), g->item);
|
|
623 } else {
|
|
624 groups = g_list_insert(groups, g, pos);
|
|
625 gtk_tree_insert(GTK_TREE(buddies), g->item, pos);
|
|
626 }
|
|
627
|
|
628 } else {
|
|
629 groups = g_list_append(groups, g);
|
|
630 gtk_tree_append(GTK_TREE(buddies), g->item);
|
|
631
|
|
632 }
|
|
633
|
|
634 gtk_tree_item_set_subtree (GTK_TREE_ITEM(g->item), g->tree);
|
|
635 gtk_tree_item_expand (GTK_TREE_ITEM(g->item));
|
|
636 gtk_signal_connect(GTK_OBJECT(g->item), "button_press_event",
|
|
637 GTK_SIGNAL_FUNC(handle_click_group),
|
|
638 NULL);
|
|
639 gtk_object_set_user_data(GTK_OBJECT(g->item), NULL);
|
|
640
|
|
641 gtk_widget_unref(g->tree);
|
|
642
|
|
643 update_num_groups();
|
|
644
|
|
645
|
|
646 buds = g->members;
|
|
647
|
|
648 while(buds) {
|
|
649 b = (struct buddy *)buds->data;
|
|
650 set_buddy(b);
|
|
651 buds = buds->next;
|
|
652 }
|
|
653
|
|
654 grps = groups;
|
|
655 while(grps) {
|
|
656 g = (struct group *)grps->data;
|
|
657 grps = grps->next;
|
|
658 }
|
|
659
|
|
660 } else {
|
|
661 struct group *new_g, *old_g;
|
|
662 struct buddy *b, *s;
|
|
663 GtkWidget *gtree;
|
|
664 GtkWidget *owner;
|
|
665 GList *temp;
|
|
666 int pos;
|
|
667
|
|
668 b = find_buddy(source);
|
|
669 new_g = find_group(target1);
|
|
670 old_g = find_group_by_buddy(source);
|
|
671 gtree = old_g->tree;
|
|
672 if (sibling)
|
|
673 s = find_buddy(target2);
|
|
674 else
|
|
675 s = NULL;
|
|
676
|
|
677 old_g->members = g_list_remove(old_g->members, b);
|
|
678
|
|
679 gtk_widget_ref(b->item);
|
|
680 gtk_widget_ref(b->label);
|
|
681 gtk_widget_ref(b->pix);
|
|
682 gtk_widget_ref(b->idletime);
|
|
683 gtk_widget_ref(gtree);
|
|
684
|
|
685 owner = GTK_TREE(gtree)->tree_owner;
|
|
686
|
|
687 temp = g_list_append(NULL, b->item);
|
|
688 gtk_tree_remove_items(GTK_TREE(old_g->tree), temp);
|
|
689 g_list_free(temp);
|
|
690
|
|
691 if (gtree->parent == NULL){
|
|
692 gtk_tree_item_set_subtree (GTK_TREE_ITEM(owner), gtree);
|
|
693 gtk_tree_item_expand (GTK_TREE_ITEM(owner));
|
|
694 }
|
|
695
|
|
696 if (!sibling) {
|
|
697 gtk_tree_append(GTK_TREE(new_g->tree), b->item);
|
|
698 new_g->members = g_list_append(new_g->members, b);
|
|
699 } else {
|
|
700 pos = g_list_index(new_g->members, s);
|
|
701 if (pos != 0) {
|
|
702 new_g->members = g_list_insert(new_g->members, b, pos);
|
|
703 gtk_tree_insert(GTK_TREE(new_g->tree), b->item, pos);
|
|
704 } else {
|
|
705 new_g->members = g_list_prepend(new_g->members, b);
|
|
706 gtk_tree_prepend(GTK_TREE(new_g->tree), b->item);
|
|
707
|
|
708 }
|
|
709 }
|
|
710
|
|
711 gtk_widget_unref(b->item);
|
|
712 gtk_widget_unref(b->label);
|
|
713 gtk_widget_unref(b->pix);
|
|
714 gtk_widget_unref(b->idletime);
|
|
715 gtk_widget_unref(gtree);
|
|
716
|
|
717 gtk_ctree_expand(ctree, parent);
|
|
718
|
|
719 update_num_groups();
|
|
720 update_show_idlepix();
|
|
721 set_buddy(b);
|
|
722
|
|
723
|
|
724
|
|
725
|
|
726
|
|
727 }
|
|
728
|
|
729 serv_save_config();
|
|
730 }
|
|
731
|
|
732
|
|
733
|
|
734 void build_edit_tree()
|
|
735 {
|
|
736 GtkCTreeNode *p = NULL, *n;
|
|
737 GList *grp = groups;
|
|
738 GList *mem;
|
|
739 struct group *g;
|
|
740 struct buddy *b;
|
|
741 char *text[1];
|
|
742
|
|
743 gtk_clist_freeze(GTK_CLIST(edittree));
|
|
744 gtk_clist_clear(GTK_CLIST(edittree));
|
|
745
|
|
746
|
|
747 while(grp) {
|
|
748 g = (struct group *)grp->data;
|
|
749
|
|
750 text[0] = g->name;
|
|
751
|
|
752 p = gtk_ctree_insert_node(GTK_CTREE(edittree), NULL,
|
|
753 NULL, text, 5, NULL, NULL,
|
|
754 NULL, NULL, 0, 1);
|
|
755
|
|
756 n = NULL;
|
|
757
|
|
758 mem = g->members;
|
|
759
|
|
760 while(mem) {
|
|
761 b = (struct buddy *)mem->data;
|
|
762
|
|
763 text[0] = b->name;
|
|
764
|
|
765 n = gtk_ctree_insert_node(GTK_CTREE(edittree),
|
|
766 p, NULL, text, 5,
|
|
767 NULL, NULL,
|
|
768 NULL, NULL, 1, 1);
|
|
769
|
|
770 mem = mem->next;
|
|
771
|
|
772 }
|
|
773 grp = grp->next;
|
|
774 }
|
|
775
|
|
776 gtk_clist_thaw(GTK_CLIST(edittree));
|
|
777
|
|
778 }
|
|
779
|
|
780 struct buddy *add_buddy(char *group, char *buddy)
|
|
781 {
|
|
782 struct buddy *b;
|
|
783 struct group *g;
|
|
784 GdkPixmap *pm;
|
|
785 GdkBitmap *bm;
|
|
786 GtkWidget *box;
|
|
787
|
|
788
|
|
789 if ((b = find_buddy(buddy)) != NULL)
|
|
790 return b;
|
|
791
|
|
792 g = find_group(group);
|
|
793
|
|
794 if (g == NULL)
|
|
795 g = add_group(group);
|
|
796
|
|
797 b = (struct buddy *)g_new0(struct buddy, 1);
|
|
798
|
|
799 if (!b)
|
|
800 return NULL;
|
|
801
|
|
802 b->present = 0;
|
|
803 b->item = gtk_tree_item_new();
|
|
804
|
|
805 g_snprintf(b->name, sizeof(b->name), "%s", buddy);
|
|
806 g->members = g_list_append(g->members, b);
|
|
807
|
|
808
|
|
809 if (blist == NULL)
|
|
810 return b;
|
|
811
|
|
812 box = gtk_hbox_new(FALSE, 1);
|
|
813 pm = gdk_pixmap_create_from_xpm_d(blist->window, &bm,
|
|
814 NULL, (gchar **)login_icon_xpm);
|
|
815 b->pix = gtk_pixmap_new(pm, bm);
|
|
816
|
|
817 b->idle = 0;
|
|
818
|
|
819 gtk_widget_show(b->pix);
|
|
820
|
|
821 b->label = gtk_label_new(buddy);
|
|
822 gtk_misc_set_alignment(GTK_MISC(b->label), 0.0, 0.5);
|
|
823
|
|
824 b->idletime = gtk_label_new("");
|
|
825
|
|
826 gtk_tree_append(GTK_TREE(g->tree),b->item);
|
|
827 gtk_container_add(GTK_CONTAINER(b->item), box);
|
|
828
|
|
829 gtk_box_pack_start(GTK_BOX(box), b->pix, FALSE, FALSE, 1);
|
|
830 gtk_box_pack_start(GTK_BOX(box), b->label, TRUE, TRUE, 1);
|
|
831 gtk_box_pack_start(GTK_BOX(box), b->idletime, FALSE, FALSE, 1);
|
|
832
|
|
833 gtk_widget_show(b->label);
|
|
834 gtk_widget_show(box);
|
|
835
|
|
836 gtk_object_set_user_data(GTK_OBJECT(b->item), b);
|
|
837
|
|
838 gtk_signal_connect(GTK_OBJECT(b->item), "button_press_event",
|
|
839 GTK_SIGNAL_FUNC(handle_click_buddy), b);
|
|
840
|
|
841 return b;
|
|
842 }
|
|
843
|
|
844
|
|
845 struct group *add_group(char *group)
|
|
846 {
|
|
847 struct group *g;
|
|
848 g = (struct group *)g_new0(struct group, 1);
|
|
849 if (!g)
|
|
850 return NULL;
|
|
851
|
|
852 strncpy(g->name, group, sizeof(g->name));
|
|
853 groups = g_list_append(groups, g);
|
|
854
|
|
855 if (blist == NULL)
|
|
856 return g;
|
|
857
|
|
858 g->item = gtk_tree_item_new();
|
|
859 g->label = gtk_label_new(g->name);
|
|
860 gtk_misc_set_alignment(GTK_MISC(g->label), 0.0, 0.5);
|
|
861 gtk_widget_show(g->label);
|
|
862 gtk_container_add(GTK_CONTAINER(g->item), g->label);
|
|
863 g->tree = gtk_tree_new();
|
|
864 gtk_widget_show(g->item);
|
|
865 gtk_widget_show(g->tree);
|
|
866 gtk_tree_append(GTK_TREE(buddies), g->item);
|
|
867 gtk_tree_item_set_subtree(GTK_TREE_ITEM(g->item), g->tree);
|
|
868 gtk_tree_item_expand(GTK_TREE_ITEM(g->item));
|
|
869 gtk_signal_connect(GTK_OBJECT(g->item), "button_press_event",
|
|
870 GTK_SIGNAL_FUNC(handle_click_group),
|
|
871 NULL);
|
|
872 gtk_object_set_user_data(GTK_OBJECT(g->item), NULL);
|
|
873 g->members = NULL;
|
|
874
|
|
875
|
|
876 build_edit_tree();
|
|
877
|
|
878 return g;
|
|
879
|
|
880 }
|
|
881
|
|
882
|
|
883 static void do_del_buddy(GtkWidget *w, GtkCTree *ctree)
|
|
884 {
|
|
885 GtkCTreeNode *node;
|
|
886 char *bud, *grp;
|
|
887 struct buddy *b;
|
|
888 struct group *g;
|
|
889 GList *i;
|
|
890
|
|
891 i = GTK_CLIST(edittree)->selection;
|
|
892 if (i) {
|
|
893 node = i->data;
|
|
894
|
|
895 if (GTK_CTREE_ROW(node)->is_leaf) {
|
|
896 gtk_ctree_get_node_info (GTK_CTREE(edittree), node, &bud,
|
|
897 NULL, NULL, NULL, NULL, NULL, NULL, NULL);
|
|
898
|
|
899 b = find_buddy(bud);
|
|
900 g = find_group_by_buddy(bud);
|
|
901 remove_buddy(g, b);
|
|
902 } else {
|
|
903 gtk_ctree_get_node_info (ctree, node, &grp,
|
|
904 NULL, NULL, NULL, NULL, NULL, NULL, NULL);
|
|
905 g = find_group(grp);
|
|
906 remove_group(g);
|
|
907 }
|
|
908
|
|
909 build_edit_tree();
|
|
910 serv_save_config();
|
|
911 } else {
|
|
912 /* Nothing selected. */
|
|
913 }
|
|
914 update_num_groups();
|
|
915 }
|
|
916
|
|
917 static void do_del_perm(GtkWidget *w, GtkTree *permtree)
|
|
918 {
|
|
919 GtkLabel *label, *plabel;
|
|
920 GtkWidget *item, *pitem;
|
|
921 char *c, *d;
|
|
922 GList *i;
|
|
923
|
|
924 GList *plist;
|
|
925 GList *dlist;
|
|
926 int level;
|
|
927
|
|
928 plist = permit;
|
|
929 dlist = deny;
|
|
930
|
|
931 i = GTK_TREE_SELECTION(permtree);
|
|
932 if (i) {
|
|
933 item = GTK_WIDGET(i->data);
|
|
934 gtk_tree_unselect_child(GTK_TREE(permtree), item);
|
|
935 label = GTK_LABEL(GTK_BIN(item)->child);
|
|
936 gtk_label_get(label, &c);
|
|
937 level = GTK_TREE(item->parent)->level;
|
|
938 if (level > 0) {
|
|
939 pitem = GTK_WIDGET(GTK_TREE(item->parent)->tree_owner);
|
|
940 plabel = GTK_LABEL(GTK_BIN(pitem)->child);
|
|
941 gtk_label_get(plabel, &d);
|
|
942 if (!strcasecmp(d, "Permit")) {
|
|
943 while(plist) {
|
|
944 if (!strcasecmp((char *)(plist->data), c)) {
|
|
945 permit = g_list_remove(permit, plist->data);
|
|
946 break;
|
|
947 }
|
|
948
|
|
949 plist = plist->next;
|
|
950 }
|
|
951
|
|
952 } else {
|
|
953 while(dlist) {
|
|
954 if (!strcasecmp((char *)(dlist->data), c)) {
|
|
955 deny = g_list_remove(deny, dlist->data);
|
|
956
|
|
957 break;
|
|
958 }
|
|
959 dlist = dlist->next;
|
|
960 }
|
|
961
|
|
962 }
|
|
963
|
|
964
|
|
965 } else {
|
|
966 /* Can't delete groups here! :) */
|
|
967 return;
|
|
968 }
|
|
969 serv_set_permit_deny();
|
|
970 gtk_tree_clear_items(GTK_TREE(permtree), 0, -1);
|
|
971 build_permit_tree();
|
|
972 serv_save_config();
|
|
973 }
|
|
974 }
|
|
975
|
|
976
|
|
977
|
|
978 void gaimreg_callback(GtkWidget *widget)
|
|
979 {
|
|
980 show_register_dialog();
|
|
981 }
|
|
982
|
|
983 void import_callback(GtkWidget *widget, void *null)
|
|
984 {
|
|
985 show_import_dialog();
|
|
986 }
|
|
987
|
|
988 void export_callback(GtkWidget *widget, void *null)
|
|
989 {
|
|
990 show_export_dialog();
|
|
991 }
|
|
992
|
|
993
|
|
994
|
|
995 void do_quit()
|
|
996 {
|
|
997 exit(0);
|
|
998 }
|
|
999
|
|
1000 void add_buddy_callback(GtkWidget *widget, void *dummy)
|
|
1001 {
|
|
1002 char *grp = NULL;
|
|
1003 GtkCTreeNode *node;
|
|
1004 GList *i;
|
|
1005
|
|
1006 i = GTK_CLIST(edittree)->selection;
|
|
1007 if (i) {
|
|
1008 node = i->data;
|
|
1009
|
|
1010 if (GTK_CTREE_ROW(node)->is_leaf) {
|
|
1011 node = GTK_CTREE_ROW(node)->parent;
|
|
1012 }
|
|
1013
|
|
1014 gtk_ctree_get_node_info (GTK_CTREE(edittree), node, &grp,
|
|
1015 NULL, NULL, NULL, NULL, NULL, NULL, NULL);
|
|
1016 }
|
|
1017 show_add_buddy(NULL, grp);
|
|
1018
|
|
1019 }
|
|
1020
|
|
1021 void add_perm_callback(GtkWidget *widget, void *dummy)
|
|
1022 {
|
|
1023 show_add_perm(NULL);
|
|
1024 }
|
|
1025
|
|
1026
|
|
1027 static void info_callback(GtkWidget *widget, GtkTree *tree)
|
|
1028 {
|
|
1029 GList *i;
|
|
1030 struct buddy *b = NULL;
|
|
1031 i = GTK_TREE_SELECTION(tree);
|
|
1032 if (i) {
|
|
1033 b = gtk_object_get_user_data(GTK_OBJECT(i->data));
|
|
1034 } else {
|
|
1035 return;
|
|
1036 }
|
|
1037 if (!b->name)
|
|
1038 return;
|
|
1039 serv_get_info(b->name);
|
|
1040 }
|
|
1041
|
|
1042
|
|
1043 void chat_callback(GtkWidget *widget, GtkTree *tree)
|
|
1044 {
|
|
1045 join_chat();
|
|
1046 }
|
|
1047
|
|
1048 struct group *find_group(char *group)
|
|
1049 {
|
|
1050 struct group *g;
|
|
1051 GList *grp = groups;
|
|
1052 char *grpname = g_malloc(strlen(group) + 1);
|
|
1053
|
|
1054 strcpy(grpname, normalize(group));
|
|
1055 while (grp) {
|
|
1056 g = (struct group *)grp->data;
|
|
1057 if (!strcasecmp(normalize(g->name), grpname)) {
|
|
1058 g_free(grpname);
|
|
1059 return g;
|
|
1060 }
|
|
1061 grp = grp->next;
|
|
1062 }
|
|
1063
|
|
1064 g_free(grpname);
|
|
1065 return NULL;
|
|
1066
|
|
1067 }
|
|
1068
|
|
1069
|
|
1070 struct group *find_group_by_buddy(char *who)
|
|
1071 {
|
|
1072 struct group *g;
|
|
1073 struct buddy *b;
|
|
1074 GList *grp = groups;
|
|
1075 GList *mem;
|
|
1076 char *whoname = g_malloc(strlen(who) + 1);
|
|
1077
|
|
1078 strcpy(whoname, normalize(who));
|
|
1079
|
|
1080 while(grp) {
|
|
1081 g = (struct group *)grp->data;
|
|
1082
|
|
1083 mem = g->members;
|
|
1084 while(mem) {
|
|
1085 b = (struct buddy *)mem->data;
|
|
1086 if (!strcasecmp(normalize(b->name), whoname)) {
|
|
1087 g_free(whoname);
|
|
1088 return g;
|
|
1089 }
|
|
1090 mem = mem->next;
|
|
1091 }
|
|
1092 grp = grp->next;
|
|
1093 }
|
|
1094 g_free(whoname);
|
|
1095 return NULL;
|
|
1096 }
|
|
1097
|
|
1098
|
|
1099 struct buddy *find_buddy(char *who)
|
|
1100 {
|
|
1101 struct group *g;
|
|
1102 struct buddy *b;
|
|
1103 GList *grp = groups;
|
|
1104 GList *mem;
|
|
1105 char *whoname = g_malloc(strlen(who) + 1);
|
|
1106
|
|
1107 strcpy(whoname, normalize(who));
|
|
1108
|
|
1109 while(grp) {
|
|
1110 g = (struct group *)grp->data;
|
|
1111
|
|
1112 mem = g->members;
|
|
1113 while(mem) {
|
|
1114 b = (struct buddy *)mem->data;
|
|
1115 if (!strcasecmp(normalize(b->name), whoname)) {
|
|
1116 g_free(whoname);
|
|
1117 return b;
|
|
1118 }
|
|
1119 mem = mem->next;
|
|
1120 }
|
|
1121 grp = grp->next;
|
|
1122 }
|
|
1123 g_free(whoname);
|
|
1124 return NULL;
|
|
1125 }
|
|
1126
|
|
1127
|
|
1128 void rem_bp(GtkWidget *w, struct buddy_pounce *b)
|
|
1129 {
|
|
1130 buddy_pounces = g_list_remove(buddy_pounces, b);
|
|
1131 }
|
|
1132
|
|
1133 void do_pounce(char *name)
|
|
1134 {
|
26
|
1135 char *who;
|
1
|
1136
|
|
1137 struct buddy_pounce *b;
|
|
1138 struct conversation *c;
|
|
1139
|
|
1140 GList *bp = buddy_pounces;
|
|
1141
|
26
|
1142 who = g_strdup(normalize(name));
|
1
|
1143
|
|
1144 while(bp) {
|
|
1145 b = (struct buddy_pounce *)bp->data;;
|
26
|
1146 bp = bp->next; /* increment the list here because rem_bp can make our handle bad */
|
|
1147
|
1
|
1148 if (!strcasecmp(who, normalize(b->name))) {
|
|
1149 if (b->popup == 1)
|
|
1150 {
|
|
1151 c = find_conversation(name);
|
|
1152 if (c == NULL)
|
|
1153 c = new_conversation(name);
|
|
1154 }
|
|
1155 if (b->sendim == 1)
|
|
1156 {
|
|
1157 c = find_conversation(name);
|
|
1158 if (c == NULL)
|
|
1159 c = new_conversation(name);
|
|
1160
|
|
1161 write_to_conv(c, b->message, WFLAG_SEND);
|
|
1162
|
|
1163 escape_text(b->message);
|
|
1164
|
|
1165 serv_send_im(name, b->message, 0);
|
|
1166 }
|
|
1167
|
|
1168 rem_bp(NULL, b);
|
|
1169
|
|
1170 }
|
|
1171 }
|
|
1172 g_free(who);
|
|
1173 }
|
|
1174
|
|
1175 static void new_bp_callback(GtkWidget *w, char *name)
|
|
1176 {
|
|
1177 show_new_bp(name);
|
|
1178 }
|
|
1179
|
|
1180 static void log_callback(GtkWidget *w, char *name)
|
|
1181 {
|
|
1182 struct conversation *c = find_conversation(name);
|
|
1183
|
|
1184 if (find_log_info(name))
|
|
1185 {
|
|
1186 if (c) {
|
|
1187 set_state_lock(1);
|
|
1188 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(c->log_button), FALSE);
|
|
1189 set_state_lock(0);
|
|
1190 }
|
|
1191 rm_log(find_log_info(name));
|
|
1192 }
|
|
1193 else
|
|
1194 {
|
|
1195 show_log_dialog(name);
|
|
1196 if (c) {
|
|
1197 set_state_lock(1);
|
|
1198 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(c->log_button), TRUE);
|
|
1199 set_state_lock(0);
|
|
1200 }
|
|
1201 }
|
|
1202 }
|
|
1203
|
|
1204 void do_bp_menu()
|
|
1205 {
|
|
1206 GtkWidget *menuitem, *mess, *messmenu;
|
|
1207 static GtkWidget *remmenu;
|
|
1208 GtkWidget *remitem;
|
|
1209 GtkWidget *sep;
|
|
1210 GList *l;
|
|
1211 struct buddy_pounce *b;
|
|
1212 GList *bp = buddy_pounces;
|
|
1213
|
|
1214 l = gtk_container_children(GTK_CONTAINER(bpmenu));
|
|
1215
|
|
1216 while(l) {
|
|
1217 gtk_widget_destroy(GTK_WIDGET(l->data));
|
|
1218 l = l->next;
|
|
1219 }
|
|
1220
|
|
1221 remmenu = gtk_menu_new();
|
|
1222
|
|
1223 menuitem = gtk_menu_item_new_with_label("New Buddy Pounce");
|
|
1224 gtk_menu_append(GTK_MENU(bpmenu), menuitem);
|
|
1225 gtk_widget_show(menuitem);
|
|
1226 gtk_signal_connect(GTK_OBJECT(menuitem), "activate", GTK_SIGNAL_FUNC(new_bp_callback), NULL);
|
|
1227
|
|
1228
|
|
1229 while(bp) {
|
|
1230
|
|
1231 b = (struct buddy_pounce *)bp->data;
|
|
1232 remitem = gtk_menu_item_new_with_label(b->name);
|
|
1233 gtk_menu_append(GTK_MENU(remmenu), remitem);
|
|
1234 gtk_widget_show(remitem);
|
|
1235 gtk_signal_connect(GTK_OBJECT(remitem), "activate", GTK_SIGNAL_FUNC(rem_bp), b);
|
|
1236
|
|
1237 bp = bp->next;
|
|
1238
|
|
1239 }
|
|
1240
|
|
1241 menuitem = gtk_menu_item_new_with_label("Remove Buddy Pounce");
|
|
1242 gtk_menu_append(GTK_MENU(bpmenu), menuitem);
|
|
1243 gtk_widget_show(menuitem);
|
|
1244 gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), remmenu);
|
|
1245 gtk_widget_show(remmenu);
|
|
1246
|
|
1247
|
|
1248 sep = gtk_hseparator_new();
|
|
1249 menuitem = gtk_menu_item_new();
|
|
1250 gtk_menu_append(GTK_MENU(bpmenu), menuitem);
|
|
1251 gtk_container_add(GTK_CONTAINER(menuitem), sep);
|
|
1252 gtk_widget_set_sensitive(menuitem, FALSE);
|
|
1253 gtk_widget_show(menuitem);
|
|
1254 gtk_widget_show(sep);
|
|
1255
|
|
1256 bp = buddy_pounces;;
|
|
1257
|
|
1258 while(bp) {
|
|
1259
|
|
1260 b = (struct buddy_pounce *)bp->data;
|
|
1261
|
|
1262 menuitem = gtk_menu_item_new_with_label(b->name);
|
|
1263 gtk_menu_append(GTK_MENU(bpmenu), menuitem);
|
|
1264 messmenu = gtk_menu_new();
|
|
1265 gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), messmenu);
|
|
1266 gtk_widget_show(menuitem);
|
|
1267
|
|
1268
|
|
1269
|
|
1270 mess = gtk_menu_item_new_with_label(b->message);
|
|
1271 gtk_menu_append(GTK_MENU(messmenu), mess);
|
|
1272 gtk_widget_show(mess);
|
|
1273
|
|
1274 bp = bp->next;
|
|
1275
|
|
1276 }
|
|
1277
|
|
1278 }
|
|
1279
|
|
1280
|
|
1281 gint log_timeout(char *name)
|
|
1282 {
|
|
1283 struct buddy *b;
|
|
1284
|
|
1285 b = find_buddy(name);
|
|
1286
|
|
1287 if(!b)
|
|
1288 return FALSE;
|
|
1289
|
|
1290 b->log_timer = 0;
|
|
1291
|
|
1292 if (!b->present)
|
|
1293 gtk_widget_hide(b->item);
|
|
1294 else
|
|
1295 set_buddy(b);
|
|
1296
|
|
1297 return FALSE;
|
|
1298 }
|
|
1299
|
|
1300
|
|
1301 void set_buddy(struct buddy *b)
|
|
1302 {
|
|
1303 char infotip[256];
|
|
1304 char idlet[16];
|
|
1305 char warn[256];
|
|
1306 int i;
|
|
1307 int ihrs, imin;
|
|
1308 time_t t;
|
|
1309 GdkPixmap *pm;
|
|
1310 GdkBitmap *bm;
|
|
1311 char *itime, *sotime;
|
|
1312
|
|
1313 if (b->present) {
|
|
1314 time(&t);
|
|
1315
|
|
1316 ihrs = (t - b->idle) / 3600;
|
|
1317 imin = ((t - b->idle) / 60) % 60;
|
|
1318
|
|
1319 if (ihrs)
|
|
1320 g_snprintf(idlet, sizeof(idlet), "(%d:%02d)", ihrs, imin);
|
|
1321 else
|
|
1322 g_snprintf(idlet, sizeof(idlet), "(%02d)", imin);
|
|
1323
|
|
1324 gtk_widget_hide(b->idletime);
|
|
1325
|
|
1326 if (b->idle)
|
|
1327 gtk_label_set(GTK_LABEL(b->idletime), idlet);
|
|
1328 else
|
|
1329 gtk_label_set(GTK_LABEL(b->idletime), "");
|
|
1330 if (display_options & OPT_DISP_SHOW_IDLETIME)
|
|
1331 gtk_widget_show(b->idletime);
|
|
1332
|
|
1333
|
|
1334 sotime = sec_to_text(t - b->signon + correction_time);
|
|
1335 if (b->idle) {
|
|
1336 itime = sec_to_text(t - b->idle);
|
|
1337 } else {
|
|
1338 itime = g_malloc(1);
|
|
1339 itime[0] = 0;
|
|
1340 }
|
|
1341
|
|
1342 if (b->evil) {
|
|
1343 g_snprintf(warn, sizeof(warn), "Warnings: %d%%\n", b->evil);
|
|
1344
|
|
1345 } else
|
|
1346 warn[0] = '\0';
|
|
1347
|
|
1348 i = g_snprintf(infotip, sizeof(infotip), "Name: %s \nLogged in: %s\n%s%s%s", b->name, sotime, warn, ((b->idle) ? "Idle: " : ""), itime);
|
|
1349
|
|
1350 gtk_tooltips_set_tip(tips, GTK_WIDGET(b->item), infotip, "");
|
|
1351
|
|
1352 g_free(sotime);
|
|
1353 g_free(itime);
|
|
1354
|
|
1355
|
|
1356
|
|
1357 if (!GTK_WIDGET_VISIBLE(b->item)) {
|
|
1358
|
|
1359 play_sound(BUDDY_ARRIVE);
|
|
1360
|
|
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);
|
58
|
1387 b->log_timer = gtk_timeout_add(10000, (GtkFunction) log_timeout, b->name);
|
1
|
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 {
|
59
|
1430 if (GTK_WIDGET_VISIBLE(b->item)) {
|
1
|
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 }
|
58
|
1453 b->log_timer = gtk_timeout_add(10000, (GtkFunction)log_timeout, b->name);
|
1
|
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
|