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;
|
|
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
|