?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Replace various network options with universal login method option
[rofl0r-ixchat.git] / src / fe-gtk / servlistgui.c
blobcc86a2fd9af51dd664151f0aa590b945eac9e5a5
1 /* X-Chat
2 * Copyright (C) 2004-2008 Peter Zelezny.
3 */
4
5 #include <stdlib.h>
6 #include <stdio.h>
7 #include <string.h>
8 #include <ctype.h>
9
10 #include <gtk/gtkversion.h>
11 #include <gtk/gtkcheckbutton.h>
12 #include <gtk/gtkcellrenderertext.h>
13 #include <gtk/gtkcomboboxentry.h>
14 #include <gtk/gtkentry.h>
15 #include <gtk/gtkhbox.h>
16 #include <gtk/gtkhbbox.h>
17 #include <gtk/gtkhseparator.h>
18 #include <gtk/gtkimage.h>
19 #include <gtk/gtklabel.h>
20 #include <gtk/gtkliststore.h>
21 #include <gtk/gtkmenuitem.h>
22 #include <gtk/gtkmessagedialog.h>
23 #include <gtk/gtkscrolledwindow.h>
24 #include <gtk/gtkstock.h>
25 #include <gtk/gtktable.h>
26 #include <gtk/gtktogglebutton.h>
27 #include <gtk/gtktree.h>
28 #include <gtk/gtktreeselection.h>
29 #include <gtk/gtktreeview.h>
30 #include <gtk/gtkvbbox.h>
31 #include <gtk/gtkvbox.h>
32 #include <gtk/gtkwindow.h>
33 #include <gdk/gdkkeysyms.h>
34
35 #include "../common/xchat.h"
36 #include "../common/xchatc.h"
37 #include "../common/servlist.h"
38 #include "../common/cfgfiles.h"
39 #include "../common/fe.h"
40
41 #include "fe-gtk.h"
42 #include "gtkutil.h"
43 #include "menu.h"
44 #include "pixmaps.h"
45
46
47 /* servlistgui.c globals */
48 static GtkWidget *serverlist_win = NULL;
49 static GtkWidget *networks_tree; /* network TreeView */
50 static int ignore_changed = FALSE;
51 static int win_width = 364;
52 static int win_height = 478;
53
54 /* global user info */
55 static GtkWidget *entry_nick1;
56 static GtkWidget *entry_nick2;
57 static GtkWidget *entry_nick3;
58 static GtkWidget *entry_guser;
59 static GtkWidget *entry_greal;
60
61 /* edit area */
62 static GtkWidget *edit_win;
63 static GtkWidget *edit_entry_nick;
64 static GtkWidget *edit_entry_nick2;
65 static GtkWidget *edit_entry_user;
66 static GtkWidget *edit_entry_real;
67 static GtkWidget *edit_entry_join;
68 static GtkWidget *edit_entry_pass;
69 static GtkWidget *edit_entry_cmd;
70 static GtkWidget *edit_entry_nickserv;
71 static GtkWidget *edit_label_nick;
72 static GtkWidget *edit_label_nick2;
73 static GtkWidget *edit_label_real;
74 static GtkWidget *edit_label_user;
75 static GtkWidget *edit_tree;
76
77 static ircnet *selected_net = NULL;
78 static ircserver *selected_serv = NULL;
79 static ircnet *fav_add_net = NULL; /* used in Add/Remove fav context menus */
80 static session *servlist_sess;
81
82 static void servlist_network_row_cb (GtkTreeSelection *sel, gpointer user_data);
83 static GtkWidget *servlist_open_edit (GtkWidget *parent, ircnet *net);
84
85
86 static const char *pages[]=
87 {
88 "UTF-8 (Unicode)",
89 "IRC (Latin/Unicode Hybrid)",
90 "ISO-8859-15 (Western Europe)",
91 "ISO-8859-2 (Central Europe)",
92 "ISO-8859-7 (Greek)",
93 "ISO-8859-8 (Hebrew)",
94 "ISO-8859-9 (Turkish)",
95 "ISO-2022-JP (Japanese)",
96 "SJIS (Japanese)",
97 "CP949 (Korean)",
98 "KOI8-R (Cyrillic)",
99 "CP1251 (Cyrillic)",
100 "CP1256 (Arabic)",
101 "CP1257 (Baltic)",
102 "GB18030 (Chinese)",
103 "TIS-620 (Thai)",
104 NULL
105 };
106
107 /* This is our dictionary for authentication types. Keep these in sync with
108 * login_types[]! This allows us to re-order the login type dropdown in the
109 * network list without breaking config compatibility.
110 */
111 static int login_types_conf[] =
112 {
113 0, /* default - we don't use this but it makes indexing consistent with login_types[] so it's nice */
114 6, /* SASL */
115 7, /* /pass */
116 1, /* /msg NickServ */
117 2, /* /NickServ */
118 3, /* /NS */
119 4, /* /msg NS */
120 5, /* /auth */
121 };
122
123 static const char *login_types[]=
124 {
125 "Default",
126 "SASL",
127 "/pass",
128 "/msg NickServ",
129 "/NickServ",
130 "/NS",
131 "/msg NS",
132 "/auth",
133 NULL
134 };
135
136 /* poor man's IndexOf() - find the dropdown string index that belongs to the given config value */
137 static int
138 servlist_get_login_desc_index (int conf_value)
139 {
140 int i;
141 int length = sizeof (login_types_conf) / sizeof (login_types_conf[0]); /* the number of elements in the conf array */
142
143 for (i = 0; i < length; i++)
144 {
145 if (login_types_conf[i] == conf_value)
146 {
147 return i;
148 }
149 }
150
151 return 0; /* make the compiler happy */
152 }
153
154 static void
155 servlist_select_and_show (GtkTreeView *treeview, GtkTreeIter *iter,
156 GtkListStore *store)
157 {
158 GtkTreePath *path;
159 GtkTreeSelection *sel;
160
161 sel = gtk_tree_view_get_selection (treeview);
162
163 /* select this network */
164 gtk_tree_selection_select_iter (sel, iter);
165 /* and make sure it's visible */
166 path = gtk_tree_model_get_path (GTK_TREE_MODEL (store), iter);
167 if (path)
168 {
169 gtk_tree_view_scroll_to_cell (treeview, path, NULL, TRUE, 0.5, 0.5);
170 gtk_tree_view_set_cursor (treeview, path, NULL, FALSE);
171 gtk_tree_path_free (path);
172 }
173 }
174
175 static void
176 servlist_servers_populate (ircnet *net, GtkWidget *treeview)
177 {
178 GtkListStore *store;
179 GtkTreeIter iter;
180 int i;
181 ircserver *serv;
182 GSList *list = net->servlist;
183
184 store = (GtkListStore *)gtk_tree_view_get_model (GTK_TREE_VIEW (treeview));
185 gtk_list_store_clear (store);
186
187 i = 0;
188 while (list)
189 {
190 serv = list->data;
191 gtk_list_store_append (store, &iter);
192 gtk_list_store_set (store, &iter, 0, serv->hostname, 1, 1, -1);
193
194 if (net->selected == i)
195 /* select this server */
196 servlist_select_and_show (GTK_TREE_VIEW (treeview), &iter, store);
197
198 i++;
199 list = list->next;
200 }
201 }
202
203 static void
204 servlist_networks_populate_ (GtkWidget *treeview, GSList *netlist, gboolean favorites)
205 {
206 GtkListStore *store;
207 GtkTreeIter iter;
208 int i;
209 ircnet *net;
210
211 if (!netlist)
212 {
213 net = servlist_net_add (_("New Network"), "", FALSE);
214 servlist_server_add (net, "newserver/6667");
215 netlist = network_list;
216 }
217 store = (GtkListStore *)gtk_tree_view_get_model (GTK_TREE_VIEW (treeview));
218 gtk_list_store_clear (store);
219
220 i = 0;
221 while (netlist)
222 {
223 net = netlist->data;
224 if (!favorites || (net->flags & FLAG_FAVORITE))
225 {
226 if (favorites)
227 gtk_list_store_insert_with_values (store, &iter, 0x7fffffff, 0, net->name, 1, 1, 2, 400, -1);
228 else
229 gtk_list_store_insert_with_values (store, &iter, 0x7fffffff, 0, net->name, 1, 1, 2, (net->flags & FLAG_FAVORITE) ? 800 : 400, -1);
230 if (i == prefs.slist_select)
231 {
232 /* select this network */
233 servlist_select_and_show (GTK_TREE_VIEW (treeview), &iter, store);
234 selected_net = net;
235 }
236 }
237 i++;
238 netlist = netlist->next;
239 }
240 }
241
242 static void
243 servlist_networks_populate (GtkWidget *treeview, GSList *netlist)
244 {
245 servlist_networks_populate_ (treeview, netlist, prefs.slist_fav);
246 }
247
248 static void
249 servlist_server_row_cb (GtkTreeSelection *sel, gpointer user_data)
250 {
251 GtkTreeModel *model;
252 GtkTreeIter iter;
253 ircserver *serv;
254 char *servname;
255 int pos;
256
257 if (!selected_net)
258 return;
259
260 if (gtk_tree_selection_get_selected (sel, &model, &iter))
261 {
262 gtk_tree_model_get (model, &iter, 0, &servname, -1);
263 serv = servlist_server_find (selected_net, servname, &pos);
264 g_free (servname);
265 if (serv)
266 selected_net->selected = pos;
267 selected_serv = serv;
268 }
269 }
270
271 static void
272 servlist_start_editing (GtkTreeView *tree)
273 {
274 GtkTreeSelection *sel;
275 GtkTreeModel *model;
276 GtkTreeIter iter;
277 GtkTreePath *path;
278
279 sel = gtk_tree_view_get_selection (tree);
280
281 if (gtk_tree_selection_get_selected (sel, &model, &iter))
282 {
283 path = gtk_tree_model_get_path (GTK_TREE_MODEL (model), &iter);
284 if (path)
285 {
286 gtk_tree_view_set_cursor (tree, path,
287 gtk_tree_view_get_column (tree, 0), TRUE);
288 gtk_tree_path_free (path);
289 }
290 }
291 }
292
293 static void
294 servlist_addserver_cb (GtkWidget *item, GtkWidget *treeview)
295 {
296 GtkTreeIter iter;
297 GtkListStore *store;
298
299 if (!selected_net)
300 return;
301
302 store = (GtkListStore *)gtk_tree_view_get_model (GTK_TREE_VIEW (treeview));
303 servlist_server_add (selected_net, "newserver/6667");
304
305 gtk_list_store_append (store, &iter);
306 gtk_list_store_set (store, &iter, 0, "newserver/6667", 1, 1, -1);
307
308 /* select this server */
309 servlist_select_and_show (GTK_TREE_VIEW (treeview), &iter, store);
310 /*servlist_start_editing (GTK_TREE_VIEW (treeview));*/
311
312 servlist_server_row_cb (gtk_tree_view_get_selection (GTK_TREE_VIEW (networks_tree)), NULL);
313 }
314
315 static void
316 servlist_addnet_cb (GtkWidget *item, GtkTreeView *treeview)
317 {
318 GtkTreeIter iter;
319 GtkListStore *store;
320 ircnet *net;
321
322 net = servlist_net_add (_("New Network"), "", TRUE);
323 net->encoding = strdup ("IRC (Latin/Unicode Hybrid)");
324 servlist_server_add (net, "newserver/6667");
325
326 store = (GtkListStore *)gtk_tree_view_get_model (treeview);
327 gtk_list_store_prepend (store, &iter);
328 gtk_list_store_set (store, &iter, 0, net->name, 1, 1, -1);
329
330 /* select this network */
331 servlist_select_and_show (GTK_TREE_VIEW (networks_tree), &iter, store);
332 servlist_start_editing (GTK_TREE_VIEW (networks_tree));
333
334 servlist_network_row_cb (gtk_tree_view_get_selection (GTK_TREE_VIEW (networks_tree)), NULL);
335 }
336
337 static void
338 servlist_deletenetwork (ircnet *net)
339 {
340 GtkTreeSelection *sel;
341 GtkTreeModel *model;
342 GtkTreeIter iter;
343
344 /* remove from GUI */
345 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (networks_tree));
346 if (gtk_tree_selection_get_selected (sel, &model, &iter))
347 gtk_list_store_remove (GTK_LIST_STORE (model), &iter);
348
349 /* remove from list */
350 servlist_net_remove (net);
351
352 /* force something to be selected */
353 gtk_tree_model_get_iter_first (model, &iter);
354 servlist_select_and_show (GTK_TREE_VIEW (networks_tree), &iter,
355 GTK_LIST_STORE (model));
356 servlist_network_row_cb (sel, NULL);
357 }
358
359 static void
360 servlist_deletenetdialog_cb (GtkDialog *dialog, gint arg1, ircnet *net)
361 {
362 gtk_widget_destroy (GTK_WIDGET (dialog));
363 if (arg1 == GTK_RESPONSE_OK)
364 servlist_deletenetwork (net);
365 }
366
367 static void
368 servlist_move_server (ircserver *serv, int delta)
369 {
370 int pos;
371
372 pos = g_slist_index (selected_net->servlist, serv);
373 if (pos >= 0)
374 {
375 pos += delta;
376 if (pos >= 0)
377 {
378 selected_net->servlist = g_slist_remove (selected_net->servlist, serv);
379 selected_net->servlist = g_slist_insert (selected_net->servlist, serv, pos);
380 servlist_servers_populate (selected_net, edit_tree);
381 }
382 }
383 }
384
385 static void
386 servlist_move_network (ircnet *net, int delta)
387 {
388 int pos;
389
390 pos = g_slist_index (network_list, net);
391 if (pos >= 0)
392 {
393 pos += delta;
394 if (pos >= 0)
395 {
396 /*prefs.slist_select += delta;*/
397 network_list = g_slist_remove (network_list, net);
398 network_list = g_slist_insert (network_list, net, pos);
399 servlist_networks_populate (networks_tree, network_list);
400 }
401 }
402 }
403
404 static gboolean
405 servlist_net_keypress_cb (GtkWidget *wid, GdkEventKey *evt, gpointer tree)
406 {
407 if (!selected_net)
408 return FALSE;
409
410 if (evt->state & GDK_SHIFT_MASK)
411 {
412 if (evt->keyval == GDK_Up)
413 {
414 servlist_move_network (selected_net, -1);
415 }
416 else if (evt->keyval == GDK_Down)
417 {
418 servlist_move_network (selected_net, +1);
419 }
420 }
421
422 return FALSE;
423 }
424
425 static gboolean
426 servlist_serv_keypress_cb (GtkWidget *wid, GdkEventKey *evt, gpointer userdata)
427 {
428 if (!selected_net || !selected_serv)
429 return FALSE;
430
431 if (evt->state & GDK_SHIFT_MASK)
432 {
433 if (evt->keyval == GDK_Up)
434 {
435 servlist_move_server (selected_serv, -1);
436 }
437 else if (evt->keyval == GDK_Down)
438 {
439 servlist_move_server (selected_serv, +1);
440 }
441 }
442
443 return FALSE;
444 }
445
446 static gint
447 servlist_compare (ircnet *net1, ircnet *net2)
448 {
449 gchar *net1_casefolded, *net2_casefolded;
450 int result=0;
451
452 net1_casefolded=g_utf8_casefold(net1->name,-1),
453 net2_casefolded=g_utf8_casefold(net2->name,-1),
454
455 result=g_utf8_collate(net1_casefolded,net2_casefolded);
456
457 g_free(net1_casefolded);
458 g_free(net2_casefolded);
459
460 return result;
461
462 }
463
464 static void
465 servlist_sort (GtkWidget *button, gpointer none)
466 {
467 network_list=g_slist_sort(network_list,(GCompareFunc)servlist_compare);
468 servlist_networks_populate (networks_tree, network_list);
469 }
470
471 static gboolean
472 servlist_has_selection (GtkTreeView *tree)
473 {
474 GtkTreeSelection *sel;
475 GtkTreeModel *model;
476 GtkTreeIter iter;
477
478 /* make sure something is selected */
479 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree));
480 return gtk_tree_selection_get_selected (sel, &model, &iter);
481 }
482
483 static void
484 servlist_favor (GtkWidget *button, gpointer none)
485 {
486 GtkTreeSelection *sel;
487 GtkTreeModel *model;
488 GtkTreeIter iter;
489
490 if (!selected_net)
491 return;
492
493 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (networks_tree));
494 if (gtk_tree_selection_get_selected (sel, &model, &iter))
495 {
496 if (selected_net->flags & FLAG_FAVORITE)
497 {
498 gtk_list_store_set (GTK_LIST_STORE (model), &iter, 2, 400, -1);
499 selected_net->flags &= ~FLAG_FAVORITE;
500 }
501 else
502 {
503 gtk_list_store_set (GTK_LIST_STORE (model), &iter, 2, 800, -1);
504 selected_net->flags |= FLAG_FAVORITE;
505 }
506 }
507 }
508
509 static void
510 servlist_update_from_entry (char **str, GtkWidget *entry)
511 {
512 if (*str)
513 free (*str);
514
515 if (GTK_ENTRY (entry)->text[0] == 0)
516 *str = NULL;
517 else
518 *str = strdup (GTK_ENTRY (entry)->text);
519 }
520
521 static void
522 servlist_edit_update (ircnet *net)
523 {
524 servlist_update_from_entry (&net->nick, edit_entry_nick);
525 servlist_update_from_entry (&net->nick2, edit_entry_nick2);
526 servlist_update_from_entry (&net->user, edit_entry_user);
527 servlist_update_from_entry (&net->real, edit_entry_real);
528
529 servlist_update_from_entry (&net->autojoin, edit_entry_join);
530 servlist_update_from_entry (&net->command, edit_entry_cmd);
531 servlist_update_from_entry (&net->nickserv, edit_entry_nickserv);
532 servlist_update_from_entry (&net->pass, edit_entry_pass);
533 }
534
535 static void
536 servlist_edit_close_cb (GtkWidget *button, gpointer userdata)
537 {
538 if (selected_net)
539 servlist_edit_update (selected_net);
540
541 gtk_widget_destroy (edit_win);
542 edit_win = NULL;
543 }
544
545 static gint
546 servlist_editwin_delete_cb (GtkWidget *win, GdkEventAny *event, gpointer none)
547 {
548 servlist_edit_close_cb (NULL, NULL);
549 return FALSE;
550 }
551
552 static gboolean
553 servlist_configure_cb (GtkWindow *win, GdkEventConfigure *event, gpointer none)
554 {
555 /* remember the window size */
556 gtk_window_get_size (win, &win_width, &win_height);
557 return FALSE;
558 }
559
560 static void
561 servlist_edit_cb (GtkWidget *but, gpointer none)
562 {
563 if (!servlist_has_selection (GTK_TREE_VIEW (networks_tree)))
564 return;
565
566 edit_win = servlist_open_edit (serverlist_win, selected_net);
567 gtkutil_set_icon (edit_win);
568 servlist_servers_populate (selected_net, edit_tree);
569 g_signal_connect (G_OBJECT (gtk_tree_view_get_selection (GTK_TREE_VIEW (edit_tree))),
570 "changed", G_CALLBACK (servlist_server_row_cb), NULL);
571 g_signal_connect (G_OBJECT (edit_win), "delete_event",
572 G_CALLBACK (servlist_editwin_delete_cb), 0);
573 g_signal_connect (G_OBJECT (edit_tree), "key_press_event",
574 G_CALLBACK (servlist_serv_keypress_cb), 0);
575 gtk_widget_show (edit_win);
576 }
577
578 static void
579 servlist_deletenet_cb (GtkWidget *item, ircnet *net)
580 {
581 GtkWidget *dialog;
582
583 if (!servlist_has_selection (GTK_TREE_VIEW (networks_tree)))
584 return;
585
586 net = selected_net;
587 if (!net)
588 return;
589 dialog = gtk_message_dialog_new (GTK_WINDOW (serverlist_win),
590 GTK_DIALOG_DESTROY_WITH_PARENT |
591 GTK_DIALOG_MODAL,
592 GTK_MESSAGE_QUESTION,
593 GTK_BUTTONS_OK_CANCEL,
594 _("Really remove network \"%s\" and all its servers?"),
595 net->name);
596 g_signal_connect (dialog, "response",
597 G_CALLBACK (servlist_deletenetdialog_cb), net);
598 gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);
599 gtk_widget_show (dialog);
600 }
601
602 static void
603 servlist_deleteserver (ircserver *serv, GtkTreeModel *model)
604 {
605 GtkTreeSelection *sel;
606 GtkTreeIter iter;
607
608 /* don't remove the last server */
609 if (selected_net && g_slist_length (selected_net->servlist) < 2)
610 return;
611
612 /* remove from GUI */
613 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (edit_tree));
614 if (gtk_tree_selection_get_selected (sel, &model, &iter))
615 gtk_list_store_remove (GTK_LIST_STORE (model), &iter);
616
617 /* remove from list */
618 if (selected_net)
619 servlist_server_remove (selected_net, serv);
620 }
621
622 static void
623 servlist_editserverbutton_cb (GtkWidget *item, gpointer none)
624 {
625 servlist_start_editing (GTK_TREE_VIEW (edit_tree));
626 }
627
628 static void
629 servlist_deleteserver_cb (GtkWidget *item, gpointer none)
630 {
631 GtkTreeSelection *sel;
632 GtkTreeModel *model;
633 GtkTreeIter iter;
634 char *servname;
635 ircserver *serv;
636 int pos;
637
638 /* find the selected item in the GUI */
639 model = gtk_tree_view_get_model (GTK_TREE_VIEW (edit_tree));
640 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (edit_tree));
641
642 if (gtk_tree_selection_get_selected (sel, &model, &iter))
643 {
644 gtk_tree_model_get (model, &iter, 0, &servname, -1);
645 serv = servlist_server_find (selected_net, servname, &pos);
646 g_free (servname);
647 if (serv)
648 servlist_deleteserver (serv, model);
649 }
650 }
651
652 static ircnet *
653 servlist_find_selected_net (GtkTreeSelection *sel)
654 {
655 GtkTreeModel *model;
656 GtkTreeIter iter;
657 char *netname;
658 int pos;
659 ircnet *net = NULL;
660
661 if (gtk_tree_selection_get_selected (sel, &model, &iter))
662 {
663 gtk_tree_model_get (model, &iter, 0, &netname, -1);
664 net = servlist_net_find (netname, &pos, strcmp);
665 g_free (netname);
666 if (net)
667 prefs.slist_select = pos;
668 }
669
670 return net;
671 }
672
673 static void
674 servlist_network_row_cb (GtkTreeSelection *sel, gpointer user_data)
675 {
676 ircnet *net;
677
678 selected_net = NULL;
679
680 net = servlist_find_selected_net (sel);
681 if (net)
682 selected_net = net;
683 }
684
685 static int
686 servlist_savegui (void)
687 {
688 char *sp;
689
690 /* check for blank username, ircd will not allow this */
691 if (GTK_ENTRY (entry_guser)->text[0] == 0)
692 return 1;
693
694 if (GTK_ENTRY (entry_greal)->text[0] == 0)
695 return 1;
696
697 strcpy (prefs.nick1, GTK_ENTRY (entry_nick1)->text);
698 strcpy (prefs.nick2, GTK_ENTRY (entry_nick2)->text);
699 strcpy (prefs.nick3, GTK_ENTRY (entry_nick3)->text);
700 strcpy (prefs.username, GTK_ENTRY (entry_guser)->text);
701 sp = strchr (prefs.username, ' ');
702 if (sp)
703 sp[0] = 0; /* spaces will break the login */
704 strcpy (prefs.realname, GTK_ENTRY (entry_greal)->text);
705 servlist_save ();
706
707 return 0;
708 }
709
710 static gboolean
711 servlist_get_iter_from_name (GtkTreeModel *model, gchar *name, GtkTreeIter *iter)
712 {
713 GtkTreePath *path = gtk_tree_path_new_from_string (name);
714
715 if (!gtk_tree_model_get_iter (model, iter, path))
716 {
717 gtk_tree_path_free (path);
718 return FALSE;
719 }
720
721 gtk_tree_path_free (path);
722 return TRUE;
723 }
724
725 static void
726 servlist_editchannel_cb (GtkCellRendererText *cell, gchar *name, gchar *newval, GtkTreeModel *model)
727 {
728 GtkTreeIter iter;
729 static int loop_guard = FALSE;
730
731 if (loop_guard)
732 return;
733
734 if (!servlist_get_iter_from_name (model, name, &iter))
735 return;
736
737 loop_guard = TRUE;
738 /* delete empty item */
739 if (newval[0] == 0)
740 gtk_list_store_remove (GTK_LIST_STORE (model), &iter);
741 else
742 gtk_list_store_set (GTK_LIST_STORE (model), &iter, 0, newval, -1);
743 loop_guard = FALSE;
744 }
745
746 static void
747 servlist_editkey_cb (GtkCellRendererText *cell, gchar *name, gchar *newval, GtkTreeModel *model)
748 {
749 GtkTreeIter iter;
750
751 if (!servlist_get_iter_from_name (model, name, &iter))
752 return;
753
754 gtk_list_store_set (GTK_LIST_STORE (model), &iter, 1, newval, -1);
755 }
756
757 static void
758 servlist_addchannel (GtkWidget *tree, char *channel)
759 {
760 GtkTreeIter iter;
761 GtkListStore *store;
762
763 store = (GtkListStore *)gtk_tree_view_get_model (GTK_TREE_VIEW (tree));
764
765 gtk_list_store_append (store, &iter);
766 gtk_list_store_set (store, &iter, 0, channel, 1, "", 2, TRUE, -1);
767
768 /* select this server */
769 servlist_select_and_show (GTK_TREE_VIEW (tree), &iter, store);
770 servlist_start_editing (GTK_TREE_VIEW (tree));
771 }
772
773 static void
774 servlist_addchannel_cb (GtkWidget *item, GtkWidget *tree)
775 {
776 servlist_addchannel (tree, _("#channel"));
777 }
778
779 static void
780 servlist_deletechannel_cb (GtkWidget *item, GtkWidget *tree)
781 {
782 GtkTreeSelection *sel;
783 GtkTreeModel *model;
784 GtkTreeIter iter;
785
786 /* find the selected item in the GUI */
787 model = gtk_tree_view_get_model (GTK_TREE_VIEW (tree));
788 sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree));
789
790 if (gtk_tree_selection_get_selected (sel, &model, &iter))
791 gtk_list_store_remove (GTK_LIST_STORE (model), &iter);
792 }
793
794 static void
795 servlist_editchannelbutton_cb (GtkWidget *item, GtkWidget *tree)
796 {
797 servlist_start_editing (GTK_TREE_VIEW (tree));
798 }
799
800 /* save everything from the GUI to the GtkEntry */
801
802 static void
803 servlist_autojoineditok_cb (GtkWidget *button, GtkWidget *tree)
804 {
805 GtkTreeModel *model;
806 GtkTreeIter iter;
807 char *channel, *key;
808 char *autojoin;
809 GSList *channels = NULL, *keys = NULL;
810
811 model = gtk_tree_view_get_model (GTK_TREE_VIEW (tree));
812
813 if (gtk_tree_model_get_iter_first (model, &iter))
814 {
815 do
816 {
817 gtk_tree_model_get (model, &iter, 0, &channel, 1, &key, -1);
818 channels = g_slist_append (channels, channel);
819 if (key && key[0] == 0)
820 {
821 /* NULL out empty keys */
822 g_free (key);
823 keys = g_slist_append (keys, NULL);
824 }
825 else
826 keys = g_slist_append (keys, key);
827 }
828 while (gtk_tree_model_iter_next (model, &iter));
829 }
830
831 gtk_widget_destroy (gtk_widget_get_toplevel (button));
832
833 autojoin = joinlist_merge (channels, keys);
834 if (autojoin)
835 {
836 if (edit_win && selected_net)
837 gtk_entry_set_text (GTK_ENTRY (edit_entry_join), autojoin);
838 else
839 {
840 if (fav_add_net->autojoin)
841 free (fav_add_net->autojoin);
842 fav_add_net->autojoin = strdup (autojoin);
843 }
844 g_free (autojoin);
845 }
846
847 /* this does g_free too */
848 joinlist_free (channels, keys);
849
850 if (fav_add_net)
851 servlist_save ();
852 }
853
854 void
855 servlist_autojoinedit (ircnet *net, char *channel, gboolean add)
856 {
857 GtkWidget *win;
858 GtkWidget *scrolledwindow;
859 GtkTreeModel *model;
860 GtkListStore *store;
861 GtkCellRenderer *renderer;
862 GtkWidget *tree;
863 GtkWidget *table;
864 GtkWidget *label;
865 GtkWidget *label2;
866 GtkWidget *bbox;
867 GtkWidget *wid;
868
869 GtkWidget *vbuttonbox1;
870 GtkWidget *buttonadd;
871 GtkWidget *buttonremove;
872 GtkWidget *buttonedit;
873
874 char buf[128];
875 char lab[128];
876 GSList *channels, *keys;
877 GSList *clist, *klist;
878 GtkTreeIter iter;
879
880 if (edit_win && selected_net)
881 /* update net->autojoin */
882 servlist_edit_update (selected_net);
883
884 win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
885 gtk_container_set_border_width (GTK_CONTAINER (win), 4);
886 gtk_window_set_title (GTK_WINDOW (win), _("XChat: Favorite Channels (Auto-Join List)"));
887 gtk_window_set_default_size (GTK_WINDOW (win), 354, 256);
888 gtk_window_set_position (GTK_WINDOW (win), GTK_WIN_POS_MOUSE);
889 if (edit_win)
890 gtk_window_set_transient_for (GTK_WINDOW (win), GTK_WINDOW (edit_win));
891 gtk_window_set_modal (GTK_WINDOW (win), TRUE);
892 gtk_window_set_type_hint (GTK_WINDOW (win), GDK_WINDOW_TYPE_HINT_DIALOG);
893 gtk_window_set_role (GTK_WINDOW (win), "editserv");
894
895 table = gtk_table_new (1, 1, FALSE);
896 gtk_container_add (GTK_CONTAINER (win), table);
897 gtk_widget_show (table);
898
899 snprintf (buf, sizeof (buf), _("These channels will be joined whenever you connect to %s."), net->name);
900 label = gtk_label_new (buf);
901 gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_CENTER);
902 gtk_table_attach (GTK_TABLE (table), label, 0, 2, 0, 1, GTK_FILL|GTK_EXPAND, GTK_FILL, 3, 3);
903 gtk_widget_show (label);
904
905 label2 = gtk_label_new ("");
906 gtk_label_set_justify (GTK_LABEL (label2), GTK_JUSTIFY_CENTER);
907 gtk_table_attach (GTK_TABLE (table), label2, 0, 2, 1, 2, GTK_FILL, 0, 3, 3);
908 gtk_widget_show (label2);
909
910 scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
911 gtk_table_attach (GTK_TABLE (table), scrolledwindow, 0, 1, 2, 3, GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 0, 0);
912 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow),
913 GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
914 gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow),
915 GTK_SHADOW_IN);
916 gtk_widget_show (scrolledwindow);
917
918 store = gtk_list_store_new (3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN);
919 model = GTK_TREE_MODEL (store);
920
921 tree = gtk_tree_view_new_with_model (model);
922 g_object_unref (model);
923 gtk_container_add (GTK_CONTAINER (scrolledwindow), tree);
924 gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tree), TRUE);
925 gtk_widget_show (tree);
926
927 renderer = gtk_cell_renderer_text_new ();
928 g_signal_connect (G_OBJECT (renderer), "edited",
929 G_CALLBACK (servlist_editchannel_cb), model);
930 gtk_tree_view_insert_column_with_attributes (
931 GTK_TREE_VIEW (tree), -1,
932 _("Channel"), renderer,
933 "text", 0,
934 "editable", 2,
935 NULL);
936
937 renderer = gtk_cell_renderer_text_new ();
938 g_signal_connect (G_OBJECT (renderer), "edited",
939 G_CALLBACK (servlist_editkey_cb), model);
940 gtk_tree_view_insert_column_with_attributes (
941 GTK_TREE_VIEW (tree), -1,
942 _("Key (Password)"), renderer,
943 "text", 1,
944 "editable", 2,
945 NULL);
946
947 gtk_tree_view_column_set_expand (gtk_tree_view_get_column (GTK_TREE_VIEW (tree), 0), TRUE);
948 gtk_tree_view_column_set_expand (gtk_tree_view_get_column (GTK_TREE_VIEW (tree), 1), TRUE);
949
950 gtk_tree_sortable_set_sort_column_id ((GtkTreeSortable *)model, 0, GTK_SORT_ASCENDING);
951
952 /* ===BUTTONS=== */
953 vbuttonbox1 = gtk_vbutton_box_new ();
954 gtk_box_set_spacing (GTK_BOX (vbuttonbox1), 3);
955 gtk_button_box_set_layout (GTK_BUTTON_BOX (vbuttonbox1), GTK_BUTTONBOX_START);
956 gtk_widget_show (vbuttonbox1);
957 gtk_table_attach (GTK_TABLE (table), vbuttonbox1, 1, 2, 2, 3, GTK_FILL, GTK_FILL, 3, 0);
958
959 buttonadd = gtk_button_new_from_stock ("gtk-add");
960 g_signal_connect (G_OBJECT (buttonadd), "clicked",
961 G_CALLBACK (servlist_addchannel_cb), tree);
962 gtk_widget_show (buttonadd);
963 gtk_container_add (GTK_CONTAINER (vbuttonbox1), buttonadd);
964 GTK_WIDGET_SET_FLAGS (buttonadd, GTK_CAN_DEFAULT);
965
966 buttonremove = gtk_button_new_from_stock ("gtk-remove");
967 g_signal_connect (G_OBJECT (buttonremove), "clicked",
968 G_CALLBACK (servlist_deletechannel_cb), tree);
969 gtk_widget_show (buttonremove);
970 gtk_container_add (GTK_CONTAINER (vbuttonbox1), buttonremove);
971 GTK_WIDGET_SET_FLAGS (buttonremove, GTK_CAN_DEFAULT);
972
973 buttonedit = gtk_button_new_with_mnemonic (_("_Edit"));
974 g_signal_connect (G_OBJECT (buttonedit), "clicked",
975 G_CALLBACK (servlist_editchannelbutton_cb), tree);
976 gtk_widget_show (buttonedit);
977 gtk_container_add (GTK_CONTAINER (vbuttonbox1), buttonedit);
978 GTK_WIDGET_SET_FLAGS (buttonedit, GTK_CAN_DEFAULT);
979
980 bbox = gtk_hbutton_box_new ();
981 gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_END);
982 gtk_box_set_spacing (GTK_BOX (bbox), 4);
983 gtk_table_attach (GTK_TABLE (table), bbox, 0, 1, 3, 4, GTK_FILL|GTK_EXPAND, GTK_FILL, 0, 4);
984 gtk_widget_show (bbox);
985
986 wid = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
987 g_signal_connect (G_OBJECT (wid), "clicked", G_CALLBACK (gtkutil_destroy), win);
988 gtk_container_add (GTK_CONTAINER (bbox), wid);
989 gtk_widget_show (wid);
990
991 wid = gtk_button_new_from_stock (GTK_STOCK_OK);
992 g_signal_connect (G_OBJECT (wid), "clicked", G_CALLBACK (servlist_autojoineditok_cb), tree);
993 gtk_container_add (GTK_CONTAINER (bbox), wid);
994 gtk_widget_show (wid);
995 gtk_widget_grab_focus (wid);
996 /* =========== */
997
998 if (net->autojoin)
999 {
1000 joinlist_split (net->autojoin, &channels, &keys);
1001
1002 clist = channels;
1003 klist = keys;
1004
1005 while (clist)
1006 {
1007 if (channel && !add && !rfc_casecmp (channel, clist->data))
1008 {
1009 snprintf (buf, sizeof (buf), _("%s has been removed."), channel);
1010 snprintf (lab, sizeof (lab), "<span foreground=\"#2222DD\">%s</span>", buf);
1011 gtk_label_set_markup (GTK_LABEL (label2), lab);
1012 }
1013 else
1014 {
1015 gtk_list_store_append (store, &iter);
1016 gtk_list_store_set (store, &iter, 0, clist->data, 1, klist->data, 2, TRUE, -1);
1017 }
1018
1019 klist = klist->next;
1020 clist = clist->next;
1021 }
1022
1023 joinlist_free (channels, keys);
1024 }
1025
1026 if (channel && add)
1027 {
1028 servlist_addchannel (tree, channel);
1029 snprintf (buf, sizeof (buf), _("%s has been added."), channel);
1030 snprintf (lab, sizeof (lab), "<span foreground=\"#2222DD\">%s</span>", buf);
1031 gtk_label_set_markup (GTK_LABEL (label2), lab);
1032 }
1033
1034 fav_add_net = net;
1035
1036 gtk_widget_show (win);
1037 }
1038
1039 static void
1040 servlist_autojoinedit_cb (GtkWidget *button, ircnet *net)
1041 {
1042 servlist_autojoinedit (net, NULL, FALSE);
1043 }
1044
1045 static void
1046 servlist_connect_cb (GtkWidget *button, gpointer userdata)
1047 {
1048 if (!selected_net)
1049 return;
1050
1051 if (servlist_savegui () != 0)
1052 {
1053 fe_message (_("User name and Real name cannot be left blank."), FE_MSG_ERROR);
1054 return;
1055 }
1056
1057 if (!is_session (servlist_sess))
1058 servlist_sess = NULL; /* open a new one */
1059
1060 {
1061 GSList *list;
1062 session *sess;
1063 session *chosen = servlist_sess;
1064
1065 servlist_sess = NULL; /* open a new one */
1066
1067 for (list = sess_list; list; list = list->next)
1068 {
1069 sess = list->data;
1070 if (sess->server->network == selected_net)
1071 {
1072 servlist_sess = sess;
1073 if (sess->server->connected)
1074 servlist_sess = NULL; /* open a new one */
1075 break;
1076 }
1077 }
1078
1079 /* use the chosen one, if it's empty */
1080 if (!servlist_sess &&
1081 chosen &&
1082 !chosen->server->connected &&
1083 chosen->server->server_session->channel[0] == 0)
1084 {
1085 servlist_sess = chosen;
1086 }
1087 }
1088
1089 servlist_connect (servlist_sess, selected_net, TRUE);
1090
1091 gtk_widget_destroy (serverlist_win);
1092 serverlist_win = NULL;
1093 selected_net = NULL;
1094 }
1095
1096 static void
1097 servlist_celledit_cb (GtkCellRendererText *cell, gchar *arg1, gchar *arg2,
1098 gpointer user_data)
1099 {
1100 GtkTreeModel *model = (GtkTreeModel *)user_data;
1101 GtkTreeIter iter;
1102 GtkTreePath *path;
1103 char *netname;
1104 ircnet *net;
1105
1106 if (!arg1 || !arg2)
1107 return;
1108
1109 path = gtk_tree_path_new_from_string (arg1);
1110 if (!path)
1111 return;
1112
1113 if (!gtk_tree_model_get_iter (model, &iter, path))
1114 {
1115 gtk_tree_path_free (path);
1116 return;
1117 }
1118 gtk_tree_model_get (model, &iter, 0, &netname, -1);
1119
1120 net = servlist_net_find (netname, NULL, strcmp);
1121 g_free (netname);
1122 if (net)
1123 {
1124 /* delete empty item */
1125 if (arg2[0] == 0)
1126 {
1127 servlist_deletenetwork (net);
1128 gtk_tree_path_free (path);
1129 return;
1130 }
1131
1132 netname = net->name;
1133 net->name = strdup (arg2);
1134 gtk_list_store_set (GTK_LIST_STORE (model), &iter, 0, net->name, -1);
1135 free (netname);
1136 }
1137
1138 gtk_tree_path_free (path);
1139 }
1140
1141 static void
1142 servlist_check_cb (GtkWidget *but, gpointer num_p)
1143 {
1144 int num = GPOINTER_TO_INT (num_p);
1145
1146 if (!selected_net)
1147 return;
1148
1149 if ((1 << num) == FLAG_CYCLE || (1 << num) == FLAG_USE_PROXY)
1150 {
1151 /* these ones are reversed, so it's compat with 2.0.x */
1152 if (GTK_TOGGLE_BUTTON (but)->active)
1153 selected_net->flags &= ~(1 << num);
1154 else
1155 selected_net->flags |= (1 << num);
1156 } else
1157 {
1158 if (GTK_TOGGLE_BUTTON (but)->active)
1159 selected_net->flags |= (1 << num);
1160 else
1161 selected_net->flags &= ~(1 << num);
1162 }
1163
1164 if ((1 << num) == FLAG_USE_GLOBAL)
1165 {
1166 if (GTK_TOGGLE_BUTTON (but)->active)
1167 {
1168 gtk_widget_hide (edit_label_nick);
1169 gtk_widget_hide (edit_entry_nick);
1170
1171 gtk_widget_hide (edit_label_nick2);
1172 gtk_widget_hide (edit_entry_nick2);
1173
1174 gtk_widget_hide (edit_label_user);
1175 gtk_widget_hide (edit_entry_user);
1176
1177 gtk_widget_hide (edit_label_real);
1178 gtk_widget_hide (edit_entry_real);
1179 } else
1180 {
1181 gtk_widget_show (edit_label_nick);
1182 gtk_widget_show (edit_entry_nick);
1183
1184 gtk_widget_show (edit_label_nick2);
1185 gtk_widget_show (edit_entry_nick2);
1186
1187 gtk_widget_show (edit_label_user);
1188 gtk_widget_show (edit_entry_user);
1189
1190 gtk_widget_show (edit_label_real);
1191 gtk_widget_show (edit_entry_real);
1192 }
1193 }
1194 }
1195
1196 static GtkWidget *
1197 servlist_create_check (int num, int state, GtkWidget *table, int row, int col, char *labeltext)
1198 {
1199 GtkWidget *but;
1200
1201 but = gtk_check_button_new_with_label (labeltext);
1202 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (but), state);
1203 g_signal_connect (G_OBJECT (but), "toggled",
1204 G_CALLBACK (servlist_check_cb), GINT_TO_POINTER (num));
1205 gtk_table_attach (GTK_TABLE (table), but, col, col+2, row, row+1,
1206 GTK_FILL|GTK_EXPAND, 0, 0, 0);
1207 gtk_widget_show (but);
1208
1209 return but;
1210 }
1211
1212 static GtkWidget *
1213 servlist_create_entry (GtkWidget *table, char *labeltext, int row,
1214 char *def, GtkWidget **label_ret, char *tip)
1215 {
1216 GtkWidget *label, *entry;
1217
1218 label = gtk_label_new_with_mnemonic (labeltext);
1219 if (label_ret)
1220 *label_ret = label;
1221 gtk_widget_show (label);
1222 gtk_table_attach (GTK_TABLE (table), label, 1, 2, row, row+1,
1223 GTK_FILL, 0, 0, 0);
1224 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
1225
1226 entry = gtk_entry_new ();
1227 add_tip (entry, tip);
1228 gtk_widget_show (entry);
1229 gtk_entry_set_text (GTK_ENTRY (entry), def ? def : "");
1230 gtk_label_set_mnemonic_widget (GTK_LABEL (label), entry);
1231
1232 if (row == 15) /* for "Channels to Join:" */
1233 {
1234 GtkWidget *button, *box;
1235
1236 box = gtk_hbox_new (0, 0);
1237 button = gtk_button_new_with_label ("...");
1238 g_signal_connect (G_OBJECT (button), "clicked",
1239 G_CALLBACK (servlist_autojoinedit_cb), selected_net);
1240
1241 gtk_box_pack_start (GTK_BOX (box), entry, TRUE, TRUE, 0);
1242 gtk_box_pack_end (GTK_BOX (box), button, 0, 0, 0);
1243 gtk_widget_show_all (box);
1244
1245 gtk_table_attach (GTK_TABLE (table), box, 2, 3, row, row+1,
1246 GTK_FILL|GTK_EXPAND, 0, 0, 0);
1247 }
1248 else
1249 {
1250 gtk_table_attach (GTK_TABLE (table), entry, 2, 3, row, row+1,
1251 GTK_FILL|GTK_EXPAND, 0, 0, 0);
1252 }
1253
1254 return entry;
1255 }
1256
1257 static gint
1258 servlist_delete_cb (GtkWidget *win, GdkEventAny *event, gpointer userdata)
1259 {
1260 servlist_savegui ();
1261 serverlist_win = NULL;
1262 selected_net = NULL;
1263
1264 if (sess_list == NULL)
1265 xchat_exit ();
1266
1267 return FALSE;
1268 }
1269
1270 static void
1271 servlist_close_cb (GtkWidget *button, gpointer userdata)
1272 {
1273 servlist_savegui ();
1274 gtk_widget_destroy (serverlist_win);
1275 serverlist_win = NULL;
1276 selected_net = NULL;
1277
1278 if (sess_list == NULL)
1279 xchat_exit ();
1280 }
1281
1282 /* convert "host:port" format to "host/port" */
1283
1284 static char *
1285 servlist_sanitize_hostname (char *host)
1286 {
1287 char *ret, *c, *e;
1288
1289 ret = strdup (host);
1290
1291 c = strchr (ret, ':');
1292 e = strrchr (ret, ':');
1293
1294 /* if only one colon exists it's probably not IPv6 */
1295 if (c && c == e)
1296 *c = '/';
1297
1298 return ret;
1299 }
1300
1301 static void
1302 servlist_editserver_cb (GtkCellRendererText *cell, gchar *arg1, gchar *arg2,
1303 gpointer user_data)
1304 {
1305 GtkTreeModel *model = (GtkTreeModel *)user_data;
1306 GtkTreeIter iter;
1307 GtkTreePath *path;
1308 char *servname;
1309 ircserver *serv;
1310
1311 if (!selected_net)
1312 return;
1313
1314 path = gtk_tree_path_new_from_string (arg1);
1315
1316 if (!gtk_tree_model_get_iter (model, &iter, path))
1317 {
1318 gtk_tree_path_free (path);
1319 return;
1320 }
1321
1322 gtk_tree_model_get (model, &iter, 0, &servname, -1);
1323 serv = servlist_server_find (selected_net, servname, NULL);
1324 g_free (servname);
1325
1326 if (serv)
1327 {
1328 /* delete empty item */
1329 if (arg2[0] == 0)
1330 {
1331 servlist_deleteserver (serv, model);
1332 gtk_tree_path_free (path);
1333 return;
1334 }
1335
1336 servname = serv->hostname;
1337 serv->hostname = servlist_sanitize_hostname (arg2);
1338 gtk_list_store_set (GTK_LIST_STORE (model), &iter, 0, serv->hostname, -1);
1339 free (servname);
1340 }
1341
1342 gtk_tree_path_free (path);
1343 }
1344
1345 static void
1346 servlist_combo_cb (GtkEntry *entry, gpointer userdata)
1347 {
1348 if (!selected_net)
1349 return;
1350
1351 if (!ignore_changed)
1352 {
1353 if (selected_net->encoding)
1354 free (selected_net->encoding);
1355 selected_net->encoding = strdup (entry->text);
1356 }
1357 }
1358
1359 /* Fills up the network's authentication type so that it's guaranteed to be either NULL or a valid value. */
1360 static void
1361 servlist_logintypecombo_cb (GtkEntry *entry, gpointer userdata)
1362 {
1363 int index;
1364
1365 if (!selected_net)
1366 {
1367 return;
1368 }
1369
1370 if (!ignore_changed)
1371 {
1372 index = gtk_combo_box_get_active (GTK_COMBO_BOX (entry)); /* starts at 0, returns -1 for invalid selections */
1373
1374 if (index != -1)
1375 {
1376 /* The selection is valid. It can be 0, which is the default type, but we need to allow
1377 * that so that you can revert from other types. servlist_save() will dump 0 anyway.
1378 */
1379 selected_net->logintype = login_types_conf[index];
1380 }
1381 }
1382 }
1383
1384
1385 static GtkWidget *
1386 servlist_create_charsetcombo (void)
1387 {
1388 GtkWidget *cb;
1389 int i;
1390
1391 cb = gtk_combo_box_entry_new_text ();
1392 gtk_combo_box_append_text (GTK_COMBO_BOX (cb), "System default");
1393 i = 0;
1394 while (pages[i])
1395 {
1396 gtk_combo_box_append_text (GTK_COMBO_BOX (cb), (char *)pages[i]);
1397 i++;
1398 }
1399 g_signal_connect (G_OBJECT (GTK_BIN (cb)->child), "changed",
1400 G_CALLBACK (servlist_combo_cb), NULL);
1401
1402 return cb;
1403 }
1404
1405 static GtkWidget *
1406 servlist_create_logintypecombo (void)
1407 {
1408 GtkWidget *cb;
1409 int i;
1410
1411 cb = gtk_combo_box_entry_new_text ();
1412
1413 i = 0;
1414
1415 while (login_types[i])
1416 {
1417 gtk_combo_box_append_text (GTK_COMBO_BOX (cb), (char *)login_types[i]);
1418 i++;
1419 }
1420
1421 g_signal_connect (G_OBJECT (GTK_BIN (cb)), "changed", G_CALLBACK (servlist_logintypecombo_cb), NULL);
1422
1423 return cb;
1424 }
1425
1426 static void
1427 no_servlist (GtkWidget * igad, gpointer serv)
1428 {
1429 if (GTK_TOGGLE_BUTTON (igad)->active)
1430 prefs.slist_skip = TRUE;
1431 else
1432 prefs.slist_skip = FALSE;
1433 }
1434
1435 static void
1436 fav_servlist (GtkWidget * igad, gpointer serv)
1437 {
1438 if (GTK_TOGGLE_BUTTON (igad)->active)
1439 prefs.slist_fav = TRUE;
1440 else
1441 prefs.slist_fav = FALSE;
1442
1443 servlist_networks_populate (networks_tree, network_list);
1444 }
1445
1446 static GtkWidget *
1447 bold_label (char *text)
1448 {
1449 char buf[128];
1450 GtkWidget *label;
1451
1452 snprintf (buf, sizeof (buf), "<b>%s</b>", text);
1453 label = gtk_label_new (buf);
1454 gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
1455 gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
1456 gtk_widget_show (label);
1457
1458 return label;
1459 }
1460
1461 static GtkWidget *
1462 servlist_open_edit (GtkWidget *parent, ircnet *net)
1463 {
1464 GtkWidget *editwindow;
1465 GtkWidget *vbox5;
1466 GtkWidget *table3;
1467 GtkWidget *label17;
1468 GtkWidget *label16;
1469 GtkWidget *label21;
1470 GtkWidget *label34;
1471 GtkWidget *label_logintype;
1472 GtkWidget *comboboxentry_charset;
1473 GtkWidget *comboboxentry_logintypes;
1474 GtkWidget *hbox1;
1475 GtkWidget *scrolledwindow2;
1476 GtkWidget *treeview_servers;
1477 GtkWidget *vbuttonbox1;
1478 GtkWidget *buttonadd;
1479 GtkWidget *buttonremove;
1480 GtkWidget *buttonedit;
1481 GtkWidget *hseparator2;
1482 GtkWidget *hbuttonbox4;
1483 GtkWidget *button10;
1484 GtkWidget *check;
1485 GtkTreeModel *model;
1486 GtkListStore *store;
1487 GtkCellRenderer *renderer;
1488 char buf[128];
1489 char buf2[128 + 8];
1490
1491 editwindow = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1492 gtk_container_set_border_width (GTK_CONTAINER (editwindow), 4);
1493 snprintf (buf, sizeof (buf), _("XChat: Edit %s"), net->name);
1494 gtk_window_set_title (GTK_WINDOW (editwindow), buf);
1495 gtk_window_set_default_size (GTK_WINDOW (editwindow), 354, 0);
1496 gtk_window_set_position (GTK_WINDOW (editwindow), GTK_WIN_POS_MOUSE);
1497 gtk_window_set_transient_for (GTK_WINDOW (editwindow), GTK_WINDOW (parent));
1498 gtk_window_set_modal (GTK_WINDOW (editwindow), TRUE);
1499 gtk_window_set_type_hint (GTK_WINDOW (editwindow), GDK_WINDOW_TYPE_HINT_DIALOG);
1500 gtk_window_set_role (GTK_WINDOW (editwindow), "editserv");
1501
1502 vbox5 = gtk_vbox_new (FALSE, 0);
1503 gtk_widget_show (vbox5);
1504 gtk_container_add (GTK_CONTAINER (editwindow), vbox5);
1505
1506 table3 = gtk_table_new (17, 3, FALSE);
1507 gtk_widget_show (table3);
1508 gtk_box_pack_start (GTK_BOX (vbox5), table3, TRUE, TRUE, 0);
1509 gtk_table_set_row_spacings (GTK_TABLE (table3), 2);
1510 gtk_table_set_col_spacings (GTK_TABLE (table3), 8);
1511
1512 snprintf (buf, sizeof (buf), _("Servers for %s"), net->name);
1513 snprintf (buf2, sizeof (buf2), "<b>%s</b>", buf);
1514 label16 = gtk_label_new (buf2);
1515 gtk_widget_show (label16);
1516 gtk_table_attach (GTK_TABLE (table3), label16, 0, 3, 0, 1,
1517 (GtkAttachOptions) (GTK_FILL),
1518 (GtkAttachOptions) (0), 0, 3);
1519 gtk_label_set_use_markup (GTK_LABEL (label16), TRUE);
1520 gtk_misc_set_alignment (GTK_MISC (label16), 0, 0.5);
1521
1522 check = servlist_create_check (0, !(net->flags & FLAG_CYCLE), table3,
1523 2, 1, _("Connect to selected server only"));
1524 add_tip (check, _("Don't cycle through all the servers when the connection fails."));
1525
1526 label17 = bold_label (_("Your Details"));
1527 gtk_table_attach (GTK_TABLE (table3), label17, 0, 3, 3, 4,
1528 (GtkAttachOptions) (GTK_FILL),
1529 (GtkAttachOptions) (0), 0, 3);
1530
1531 servlist_create_check (1, net->flags & FLAG_USE_GLOBAL, table3,
1532 4, 1, _("Use global user information"));
1533
1534 edit_entry_nick =
1535 servlist_create_entry (table3, _("_Nick name:"), 5, net->nick,
1536 &edit_label_nick, 0);
1537
1538 edit_entry_nick2 =
1539 servlist_create_entry (table3, _("Second choice:"), 6, net->nick2,
1540 &edit_label_nick2, 0);
1541
1542 edit_entry_user =
1543 servlist_create_entry (table3, _("_User name:"), 7, net->user,
1544 &edit_label_user, 0);
1545
1546 edit_entry_real =
1547 servlist_create_entry (table3, _("Rea_l name:"), 8, net->real,
1548 &edit_label_real, 0);
1549
1550 label21 = bold_label (_("Connecting"));
1551 gtk_table_attach (GTK_TABLE (table3), label21, 0, 3, 9, 10,
1552 (GtkAttachOptions) (GTK_FILL),
1553 (GtkAttachOptions) (0), 0, 3);
1554
1555 servlist_create_check (3, net->flags & FLAG_AUTO_CONNECT, table3,
1556 11, 1, _("Auto connect to this network at startup"));
1557 servlist_create_check (4, !(net->flags & FLAG_USE_PROXY), table3,
1558 12, 1, _("Bypass proxy server"));
1559 check = servlist_create_check (2, net->flags & FLAG_USE_SSL, table3,
1560 13, 1, _("Use SSL for all the servers on this network"));
1561 #ifndef USE_OPENSSL
1562 gtk_widget_set_sensitive (check, FALSE);
1563 #endif
1564 check = servlist_create_check (5, net->flags & FLAG_ALLOW_INVALID, table3,
1565 14, 1, _("Accept invalid SSL certificate"));
1566 #ifndef USE_OPENSSL
1567 gtk_widget_set_sensitive (check, FALSE);
1568 #endif
1569
1570 edit_entry_join =
1571 servlist_create_entry (table3, _("_Favorite channels:"), 15,
1572 net->autojoin, 0,
1573 _("Channels to join, separated by commas, but not spaces!"));
1574
1575 edit_entry_cmd =
1576 servlist_create_entry (table3, _("Connect command:"), 16,
1577 net->command, 0,
1578 _("Extra command to execute after connecting. If you need more than one, set this to LOAD -e <filename>, where <filename> is a text-file full of commands to execute."));
1579
1580 edit_entry_nickserv =
1581 servlist_create_entry (table3, _("NickServ password:"), 17,
1582 net->nickserv, 0,
1583 _("If your nickname requires a password, enter it here. Not all IRC networks support this."));
1584 gtk_entry_set_visibility (GTK_ENTRY (edit_entry_nickserv), FALSE);
1585
1586 label_logintype = gtk_label_new (_("Login method:"));
1587 gtk_widget_show (label_logintype);
1588 gtk_table_attach (GTK_TABLE (table3), label_logintype, 1, 2, 18, 19,
1589 (GtkAttachOptions) (GTK_FILL),
1590 (GtkAttachOptions) (0), 0, 0);
1591 gtk_misc_set_alignment (GTK_MISC (label_logintype), 0, 0.5);
1592
1593 comboboxentry_logintypes = servlist_create_logintypecombo ();
1594 ignore_changed = TRUE;
1595 gtk_entry_set_text (GTK_ENTRY (GTK_BIN (comboboxentry_logintypes)->child), net->logintype ? login_types[servlist_get_login_desc_index (net->logintype)] : login_types[0]);
1596 ignore_changed = FALSE;
1597 gtk_widget_show (comboboxentry_logintypes);
1598 gtk_table_attach (GTK_TABLE (table3), comboboxentry_logintypes, 2, 3, 18, 19,
1599 (GtkAttachOptions) (GTK_FILL),
1600 (GtkAttachOptions) (GTK_FILL), 0, 0);
1601
1602 edit_entry_pass =
1603 servlist_create_entry (table3, _("Password:"), 20,
1604 net->pass, 0,
1605 _("Password used for login. If in doubt, leave blank."));
1606 gtk_entry_set_visibility (GTK_ENTRY (edit_entry_pass), FALSE);
1607
1608
1609 label34 = gtk_label_new (_("Character set:"));
1610 gtk_widget_show (label34);
1611 gtk_table_attach (GTK_TABLE (table3), label34, 1, 2, 21, 22,
1612 (GtkAttachOptions) (GTK_FILL),
1613 (GtkAttachOptions) (0), 0, 0);
1614 gtk_misc_set_alignment (GTK_MISC (label34), 0, 0.5);
1615
1616 comboboxentry_charset = servlist_create_charsetcombo ();
1617 ignore_changed = TRUE;
1618 gtk_entry_set_text (GTK_ENTRY (GTK_BIN (comboboxentry_charset)->child), net->encoding ? net->encoding : "System default");
1619 ignore_changed = FALSE;
1620 gtk_widget_show (comboboxentry_charset);
1621 gtk_table_attach (GTK_TABLE (table3), comboboxentry_charset, 2, 3, 21, 22,
1622 (GtkAttachOptions) (GTK_FILL),
1623 (GtkAttachOptions) (GTK_FILL), 0, 0);
1624
1625 hbox1 = gtk_hbox_new (FALSE, 0);
1626 gtk_widget_show (hbox1);
1627 gtk_table_attach (GTK_TABLE (table3), hbox1, 1, 3, 1, 2,
1628 (GtkAttachOptions) (GTK_FILL),
1629 (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
1630
1631 scrolledwindow2 = gtk_scrolled_window_new (NULL, NULL);
1632 gtk_widget_show (scrolledwindow2);
1633 gtk_box_pack_start (GTK_BOX (hbox1), scrolledwindow2, TRUE, TRUE, 0);
1634 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow2),
1635 GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
1636 gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow2),
1637 GTK_SHADOW_IN);
1638
1639 store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_BOOLEAN);
1640 model = GTK_TREE_MODEL (store);
1641
1642 edit_tree = treeview_servers = gtk_tree_view_new_with_model (model);
1643 g_object_unref (model);
1644 gtk_widget_show (treeview_servers);
1645 gtk_container_add (GTK_CONTAINER (scrolledwindow2), treeview_servers);
1646 gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview_servers),
1647 FALSE);
1648
1649 renderer = gtk_cell_renderer_text_new ();
1650 g_signal_connect (G_OBJECT (renderer), "edited",
1651 G_CALLBACK (servlist_editserver_cb), model);
1652 gtk_tree_view_insert_column_with_attributes (
1653 GTK_TREE_VIEW (treeview_servers), -1,
1654 0, renderer,
1655 "text", 0,
1656 "editable", 1,
1657 NULL);
1658
1659 vbuttonbox1 = gtk_vbutton_box_new ();
1660 gtk_box_set_spacing (GTK_BOX (vbuttonbox1), 3);
1661 gtk_button_box_set_layout (GTK_BUTTON_BOX (vbuttonbox1), GTK_BUTTONBOX_START);
1662 gtk_widget_show (vbuttonbox1);
1663 gtk_box_pack_start (GTK_BOX (hbox1), vbuttonbox1, FALSE, FALSE, 3);
1664
1665 buttonadd = gtk_button_new_from_stock ("gtk-add");
1666 g_signal_connect (G_OBJECT (buttonadd), "clicked",
1667 G_CALLBACK (servlist_addserver_cb), edit_tree);
1668 gtk_widget_show (buttonadd);
1669 gtk_container_add (GTK_CONTAINER (vbuttonbox1), buttonadd);
1670 GTK_WIDGET_SET_FLAGS (buttonadd, GTK_CAN_DEFAULT);
1671
1672 buttonremove = gtk_button_new_from_stock ("gtk-remove");
1673 g_signal_connect (G_OBJECT (buttonremove), "clicked",
1674 G_CALLBACK (servlist_deleteserver_cb), NULL);
1675 gtk_widget_show (buttonremove);
1676 gtk_container_add (GTK_CONTAINER (vbuttonbox1), buttonremove);
1677 GTK_WIDGET_SET_FLAGS (buttonremove, GTK_CAN_DEFAULT);
1678
1679 buttonedit = gtk_button_new_with_mnemonic (_("_Edit"));
1680 g_signal_connect (G_OBJECT (buttonedit), "clicked",
1681 G_CALLBACK (servlist_editserverbutton_cb), NULL);
1682 gtk_widget_show (buttonedit);
1683 gtk_container_add (GTK_CONTAINER (vbuttonbox1), buttonedit);
1684 GTK_WIDGET_SET_FLAGS (buttonedit, GTK_CAN_DEFAULT);
1685
1686 hseparator2 = gtk_hseparator_new ();
1687 gtk_widget_show (hseparator2);
1688 gtk_box_pack_start (GTK_BOX (vbox5), hseparator2, FALSE, FALSE, 8);
1689
1690 hbuttonbox4 = gtk_hbutton_box_new ();
1691 gtk_widget_show (hbuttonbox4);
1692 gtk_box_pack_start (GTK_BOX (vbox5), hbuttonbox4, FALSE, FALSE, 0);
1693 gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox4),
1694 GTK_BUTTONBOX_END);
1695
1696 button10 = gtk_button_new_from_stock ("gtk-close");
1697 g_signal_connect (G_OBJECT (button10), "clicked",
1698 G_CALLBACK (servlist_edit_close_cb), 0);
1699 gtk_widget_show (button10);
1700 gtk_container_add (GTK_CONTAINER (hbuttonbox4), button10);
1701 GTK_WIDGET_SET_FLAGS (button10, GTK_CAN_DEFAULT);
1702
1703 if (net->flags & FLAG_USE_GLOBAL)
1704 {
1705 gtk_widget_hide (edit_label_nick);
1706 gtk_widget_hide (edit_entry_nick);
1707
1708 gtk_widget_hide (edit_label_nick2);
1709 gtk_widget_hide (edit_entry_nick2);
1710
1711 gtk_widget_hide (edit_label_user);
1712 gtk_widget_hide (edit_entry_user);
1713
1714 gtk_widget_hide (edit_label_real);
1715 gtk_widget_hide (edit_entry_real);
1716 }
1717
1718 gtk_widget_grab_focus (button10);
1719 gtk_widget_grab_default (button10);
1720
1721 return editwindow;
1722 }
1723
1724 static GtkWidget *
1725 servlist_open_networks (void)
1726 {
1727 GtkWidget *servlist;
1728 GtkWidget *vbox1;
1729 GtkWidget *label2;
1730 GtkWidget *table1;
1731 GtkWidget *label3;
1732 GtkWidget *label4;
1733 GtkWidget *label5;
1734 GtkWidget *label6;
1735 GtkWidget *label7;
1736 GtkWidget *entry1;
1737 GtkWidget *entry2;
1738 GtkWidget *entry3;
1739 GtkWidget *entry4;
1740 GtkWidget *entry5;
1741 GtkWidget *vbox2;
1742 GtkWidget *label1;
1743 GtkWidget *table4;
1744 GtkWidget *scrolledwindow3;
1745 GtkWidget *treeview_networks;
1746 GtkWidget *checkbutton_skip;
1747 GtkWidget *checkbutton_fav;
1748 GtkWidget *hbox;
1749 GtkWidget *vbuttonbox2;
1750 GtkWidget *button_add;
1751 GtkWidget *button_remove;
1752 GtkWidget *button_edit;
1753 GtkWidget *button_sort;
1754 GtkWidget *hseparator1;
1755 GtkWidget *hbuttonbox1;
1756 GtkWidget *button_connect;
1757 GtkWidget *button_close;
1758 GtkTreeModel *model;
1759 GtkListStore *store;
1760 GtkCellRenderer *renderer;
1761
1762 servlist = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1763 gtk_container_set_border_width (GTK_CONTAINER (servlist), 4);
1764 gtk_window_set_title (GTK_WINDOW (servlist), _("XChat: Network List"));
1765 gtk_window_set_default_size (GTK_WINDOW (servlist), win_width, win_height);
1766 gtk_window_set_position (GTK_WINDOW (servlist), GTK_WIN_POS_MOUSE);
1767 gtk_window_set_role (GTK_WINDOW (servlist), "servlist");
1768 gtk_window_set_type_hint (GTK_WINDOW (servlist), GDK_WINDOW_TYPE_HINT_DIALOG);
1769 if (current_sess)
1770 gtk_window_set_transient_for (GTK_WINDOW (servlist), GTK_WINDOW (current_sess->gui->window));
1771
1772 vbox1 = gtk_vbox_new (FALSE, 0);
1773 gtk_widget_show (vbox1);
1774 gtk_container_add (GTK_CONTAINER (servlist), vbox1);
1775
1776 label2 = bold_label (_("User Information"));
1777 gtk_box_pack_start (GTK_BOX (vbox1), label2, FALSE, FALSE, 0);
1778
1779 table1 = gtk_table_new (5, 2, FALSE);
1780 gtk_widget_show (table1);
1781 gtk_box_pack_start (GTK_BOX (vbox1), table1, FALSE, FALSE, 0);
1782 gtk_container_set_border_width (GTK_CONTAINER (table1), 8);
1783 gtk_table_set_row_spacings (GTK_TABLE (table1), 2);
1784 gtk_table_set_col_spacings (GTK_TABLE (table1), 4);
1785
1786 label3 = gtk_label_new_with_mnemonic (_("_Nick name:"));
1787 gtk_widget_show (label3);
1788 gtk_table_attach (GTK_TABLE (table1), label3, 0, 1, 0, 1,
1789 (GtkAttachOptions) (GTK_FILL),
1790 (GtkAttachOptions) (0), 0, 0);
1791 gtk_misc_set_alignment (GTK_MISC (label3), 0, 0.5);
1792
1793 label4 = gtk_label_new (_("Second choice:"));
1794 gtk_widget_show (label4);
1795 gtk_table_attach (GTK_TABLE (table1), label4, 0, 1, 1, 2,
1796 (GtkAttachOptions) (GTK_FILL),
1797 (GtkAttachOptions) (0), 0, 0);
1798 gtk_misc_set_alignment (GTK_MISC (label4), 0, 0.5);
1799
1800 label5 = gtk_label_new (_("Third choice:"));
1801 gtk_widget_show (label5);
1802 gtk_table_attach (GTK_TABLE (table1), label5, 0, 1, 2, 3,
1803 (GtkAttachOptions) (GTK_FILL),
1804 (GtkAttachOptions) (0), 0, 0);
1805 gtk_misc_set_alignment (GTK_MISC (label5), 0, 0.5);
1806
1807 label6 = gtk_label_new_with_mnemonic (_("_User name:"));
1808 gtk_widget_show (label6);
1809 gtk_table_attach (GTK_TABLE (table1), label6, 0, 1, 3, 4,
1810 (GtkAttachOptions) (GTK_FILL),
1811 (GtkAttachOptions) (0), 0, 0);
1812 gtk_misc_set_alignment (GTK_MISC (label6), 0, 0.5);
1813
1814 label7 = gtk_label_new_with_mnemonic (_("Rea_l name:"));
1815 gtk_widget_show (label7);
1816 gtk_table_attach (GTK_TABLE (table1), label7, 0, 1, 4, 5,
1817 (GtkAttachOptions) (GTK_FILL),
1818 (GtkAttachOptions) (0), 0, 0);
1819 gtk_misc_set_alignment (GTK_MISC (label7), 0, 0.5);
1820
1821 entry_nick1 = entry1 = gtk_entry_new ();
1822 gtk_entry_set_text (GTK_ENTRY (entry1), prefs.nick1);
1823 gtk_widget_show (entry1);
1824 gtk_table_attach (GTK_TABLE (table1), entry1, 1, 2, 0, 1,
1825 (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
1826 (GtkAttachOptions) (0), 0, 0);
1827
1828 entry_nick2 = entry2 = gtk_entry_new ();
1829 gtk_entry_set_text (GTK_ENTRY (entry2), prefs.nick2);
1830 gtk_widget_show (entry2);
1831 gtk_table_attach (GTK_TABLE (table1), entry2, 1, 2, 1, 2,
1832 (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
1833 (GtkAttachOptions) (0), 0, 0);
1834
1835 entry_nick3 = entry3 = gtk_entry_new ();
1836 gtk_entry_set_text (GTK_ENTRY (entry3), prefs.nick3);
1837 gtk_widget_show (entry3);
1838 gtk_table_attach (GTK_TABLE (table1), entry3, 1, 2, 2, 3,
1839 (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
1840 (GtkAttachOptions) (0), 0, 0);
1841
1842 entry_guser = entry4 = gtk_entry_new ();
1843 gtk_entry_set_text (GTK_ENTRY (entry4), prefs.username);
1844 gtk_widget_show (entry4);
1845 gtk_table_attach (GTK_TABLE (table1), entry4, 1, 2, 3, 4,
1846 (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
1847 (GtkAttachOptions) (0), 0, 0);
1848
1849 entry_greal = entry5 = gtk_entry_new ();
1850 gtk_entry_set_text (GTK_ENTRY (entry5), prefs.realname);
1851 gtk_widget_show (entry5);
1852 gtk_table_attach (GTK_TABLE (table1), entry5, 1, 2, 4, 5,
1853 (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
1854 (GtkAttachOptions) (0), 0, 0);
1855
1856 vbox2 = gtk_vbox_new (FALSE, 0);
1857 gtk_widget_show (vbox2);
1858 gtk_box_pack_start (GTK_BOX (vbox1), vbox2, TRUE, TRUE, 0);
1859
1860 label1 = bold_label (_("Networks"));
1861 gtk_box_pack_start (GTK_BOX (vbox2), label1, FALSE, FALSE, 0);
1862
1863 table4 = gtk_table_new (2, 2, FALSE);
1864 gtk_widget_show (table4);
1865 gtk_box_pack_start (GTK_BOX (vbox2), table4, TRUE, TRUE, 0);
1866 gtk_container_set_border_width (GTK_CONTAINER (table4), 8);
1867 gtk_table_set_row_spacings (GTK_TABLE (table4), 2);
1868 gtk_table_set_col_spacings (GTK_TABLE (table4), 3);
1869
1870 scrolledwindow3 = gtk_scrolled_window_new (NULL, NULL);
1871 gtk_widget_show (scrolledwindow3);
1872 gtk_table_attach (GTK_TABLE (table4), scrolledwindow3, 0, 1, 0, 1,
1873 (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
1874 (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
1875 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow3),
1876 GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
1877 gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow3),
1878 GTK_SHADOW_IN);
1879
1880 store = gtk_list_store_new (3, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_INT);
1881 model = GTK_TREE_MODEL (store);
1882
1883 networks_tree = treeview_networks = gtk_tree_view_new_with_model (model);
1884 g_object_unref (model);
1885 gtk_widget_show (treeview_networks);
1886 gtk_container_add (GTK_CONTAINER (scrolledwindow3), treeview_networks);
1887 gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview_networks),
1888 FALSE);
1889
1890 renderer = gtk_cell_renderer_text_new ();
1891 g_signal_connect (G_OBJECT (renderer), "edited",
1892 G_CALLBACK (servlist_celledit_cb), model);
1893 gtk_tree_view_insert_column_with_attributes (
1894 GTK_TREE_VIEW (treeview_networks), -1,
1895 0, renderer,
1896 "text", 0,
1897 "editable", 1,
1898 "weight", 2,
1899 NULL);
1900
1901 hbox = gtk_hbox_new (0, FALSE);
1902 gtk_table_attach (GTK_TABLE (table4), hbox, 0, 2, 1, 2,
1903 (GtkAttachOptions) (GTK_FILL),
1904 (GtkAttachOptions) (0), 0, 0);
1905 gtk_widget_show (hbox);
1906
1907 checkbutton_skip =
1908 gtk_check_button_new_with_mnemonic (_("Skip network list on startup"));
1909 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbutton_skip),
1910 prefs.slist_skip);
1911 gtk_container_add (GTK_CONTAINER (hbox), checkbutton_skip);
1912 g_signal_connect (G_OBJECT (checkbutton_skip), "toggled",
1913 G_CALLBACK (no_servlist), 0);
1914 gtk_widget_show (checkbutton_skip);
1915
1916 checkbutton_fav =
1917 gtk_check_button_new_with_mnemonic (_("Show favorites only"));
1918 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbutton_fav),
1919 prefs.slist_fav);
1920 gtk_container_add (GTK_CONTAINER (hbox), checkbutton_fav);
1921 g_signal_connect (G_OBJECT (checkbutton_fav), "toggled",
1922 G_CALLBACK (fav_servlist), 0);
1923 gtk_widget_show (checkbutton_fav);
1924
1925 vbuttonbox2 = gtk_vbutton_box_new ();
1926 gtk_box_set_spacing (GTK_BOX (vbuttonbox2), 3);
1927 gtk_button_box_set_layout (GTK_BUTTON_BOX (vbuttonbox2), GTK_BUTTONBOX_START);
1928 gtk_widget_show (vbuttonbox2);
1929 gtk_table_attach (GTK_TABLE (table4), vbuttonbox2, 1, 2, 0, 1,
1930 (GtkAttachOptions) (GTK_FILL),
1931 (GtkAttachOptions) (GTK_FILL), 0, 0);
1932
1933 button_add = gtk_button_new_from_stock ("gtk-add");
1934 g_signal_connect (G_OBJECT (button_add), "clicked",
1935 G_CALLBACK (servlist_addnet_cb), networks_tree);
1936 gtk_widget_show (button_add);
1937 gtk_container_add (GTK_CONTAINER (vbuttonbox2), button_add);
1938 GTK_WIDGET_SET_FLAGS (button_add, GTK_CAN_DEFAULT);
1939
1940 button_remove = gtk_button_new_from_stock ("gtk-remove");
1941 g_signal_connect (G_OBJECT (button_remove), "clicked",
1942 G_CALLBACK (servlist_deletenet_cb), 0);
1943 gtk_widget_show (button_remove);
1944 gtk_container_add (GTK_CONTAINER (vbuttonbox2), button_remove);
1945 GTK_WIDGET_SET_FLAGS (button_remove, GTK_CAN_DEFAULT);
1946
1947 button_edit = gtk_button_new_with_mnemonic (_("_Edit..."));
1948 g_signal_connect (G_OBJECT (button_edit), "clicked",
1949 G_CALLBACK (servlist_edit_cb), 0);
1950 gtk_widget_show (button_edit);
1951 gtk_container_add (GTK_CONTAINER (vbuttonbox2), button_edit);
1952 GTK_WIDGET_SET_FLAGS (button_edit, GTK_CAN_DEFAULT);
1953
1954 button_sort = gtk_button_new_with_mnemonic (_("_Sort"));
1955 add_tip (button_sort, _("Sorts the network list in alphabetical order. "
1956 "Use SHIFT-UP and SHIFT-DOWN keys to move a row."));
1957 g_signal_connect (G_OBJECT (button_sort), "clicked",
1958 G_CALLBACK (servlist_sort), 0);
1959 gtk_widget_show (button_sort);
1960 gtk_container_add (GTK_CONTAINER (vbuttonbox2), button_sort);
1961 GTK_WIDGET_SET_FLAGS (button_sort, GTK_CAN_DEFAULT);
1962
1963 button_sort = gtk_button_new_with_mnemonic (_("_Favor"));
1964 add_tip (button_sort, _("Mark or unmark this network as a favorite."));
1965 g_signal_connect (G_OBJECT (button_sort), "clicked",
1966 G_CALLBACK (servlist_favor), 0);
1967 gtk_widget_show (button_sort);
1968 gtk_container_add (GTK_CONTAINER (vbuttonbox2), button_sort);
1969 GTK_WIDGET_SET_FLAGS (button_sort, GTK_CAN_DEFAULT);
1970
1971 hseparator1 = gtk_hseparator_new ();
1972 gtk_widget_show (hseparator1);
1973 gtk_box_pack_start (GTK_BOX (vbox1), hseparator1, FALSE, TRUE, 4);
1974
1975 hbuttonbox1 = gtk_hbutton_box_new ();
1976 gtk_widget_show (hbuttonbox1);
1977 gtk_box_pack_start (GTK_BOX (vbox1), hbuttonbox1, FALSE, TRUE, 0);
1978 gtk_container_set_border_width (GTK_CONTAINER (hbuttonbox1), 8);
1979
1980 button_close = gtk_button_new_from_stock ("gtk-close");
1981 gtk_widget_show (button_close);
1982 g_signal_connect (G_OBJECT (button_close), "clicked",
1983 G_CALLBACK (servlist_close_cb), 0);
1984 gtk_container_add (GTK_CONTAINER (hbuttonbox1), button_close);
1985 GTK_WIDGET_SET_FLAGS (button_close, GTK_CAN_DEFAULT);
1986
1987 button_connect = gtkutil_button (hbuttonbox1, GTK_STOCK_CONNECT, NULL,
1988 servlist_connect_cb, NULL, _("C_onnect"));
1989 GTK_WIDGET_SET_FLAGS (button_connect, GTK_CAN_DEFAULT);
1990
1991 gtk_label_set_mnemonic_widget (GTK_LABEL (label3), entry1);
1992 gtk_label_set_mnemonic_widget (GTK_LABEL (label6), entry4);
1993 gtk_label_set_mnemonic_widget (GTK_LABEL (label7), entry5);
1994
1995 gtk_widget_grab_focus (networks_tree);
1996 gtk_widget_grab_default (button_close);
1997 return servlist;
1998 }
1999
2000 void
2001 fe_serverlist_open (session *sess)
2002 {
2003 if (serverlist_win)
2004 {
2005 gtk_window_present (GTK_WINDOW (serverlist_win));
2006 return;
2007 }
2008
2009 servlist_sess = sess;
2010
2011 serverlist_win = servlist_open_networks ();
2012 gtkutil_set_icon (serverlist_win);
2013
2014 servlist_networks_populate (networks_tree, network_list);
2015
2016 g_signal_connect (G_OBJECT (serverlist_win), "delete_event",
2017 G_CALLBACK (servlist_delete_cb), 0);
2018 g_signal_connect (G_OBJECT (serverlist_win), "configure_event",
2019 G_CALLBACK (servlist_configure_cb), 0);
2020 g_signal_connect (G_OBJECT (gtk_tree_view_get_selection (GTK_TREE_VIEW (networks_tree))),
2021 "changed", G_CALLBACK (servlist_network_row_cb), NULL);
2022 g_signal_connect (G_OBJECT (networks_tree), "key_press_event",
2023 G_CALLBACK (servlist_net_keypress_cb), networks_tree);
2024
2025 gtk_widget_show (serverlist_win);
2026 }