← Back to branch summary

~ubuntu-branches/ubuntu/maverick/xchat/maverick

« back to all changes in this revision

Viewing changes to .pc/37_lpi.patch/src/fe-gtk/menu.c

  • Committer: Bazaar Package Importer
  • Author(s): Lorenzo De Liso
  • Date: 2010-06-21 22:47:10 UTC
  • mfrom: (2.1.7 sid)
  • Revision ID: james.westby@ubuntu.com-20100621224710-9t1iyiglri330pss
Tags: 2.8.8-1ubuntu1
https://launchpad.net/bugs/597042
* Merge from debian unstable (LP: #597042), remaining changes:
  - debian/patches:
    + series: Refreshed.
    + 01_serverlist.patch: Numerous changes to default serverlist.
    + 02_ubuntu_default_server.patch: select "Ubuntu servers" by default.
    + 37_lpi.patch: Add launchpad integration.
    + 38_autoconf.patch: Autoconf modifications for launchpad integration.
    + 45_brand_ctcp_version.patch: Add Ubuntu brand to CTCP version response.
    + 70_notification_strings_shorten.patch: Shorten notification strings.
  - debian/control:
    + Build-depend on libgtk2.0-dev (>= 2.10.0).
    + Build-depend on liblaunchpad-integration-dev.
    + Remove conflict/replaces on xchat-gnome.
    + Updated Maintainer field to match Ubuntu Developers.
  - debian/rules:
    + Make build independent of the python version.
  - debian/patches/45_ctcp_version_less_information.dpatch: 
    + Renamed to debian/patches/45_brand_ctcp_version.patch
    + Added short description.
* Converted all patches to quilt, as in debian quilt has been
  adopted, all old dpatch patches have been renamed with the 
  *.patch extension.
* Dropped changes:
  - 71_notification_icon_change.patch: can't be applied

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/37_lpi.patch/src/fe-gtk/menu.c
 
1
/* X-Chat
 
2
 * Copyright (C) 1998-2007 Peter Zelezny.
 
3
 *
 
4
 * This program is free software; you can redistribute it and/or modify
 
5
 * it under the terms of the GNU General Public License as published by
 
6
 * the Free Software Foundation; either version 2 of the License, or
 
7
 * (at your option) any later version.
 
8
 *
 
9
 * This program is distributed in the hope that it will be useful,
 
10
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
12
 * GNU General Public License for more details.
 
13
 *
 
14
 * You should have received a copy of the GNU General Public License
 
15
 * along with this program; if not, write to the Free Software
 
16
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 
17
 */
 
18
 
 
19
#include <stdio.h>
 
20
#include <stdlib.h>
 
21
#include <fcntl.h>
 
22
#include <string.h>
 
23
#include <unistd.h>
 
24
 
 
25
#ifdef WIN32
 
26
#include <windows.h>
 
27
#endif
 
28
 
 
29
#include "fe-gtk.h"
 
30
 
 
31
#include <gtk/gtkhbox.h>
 
32
#include <gtk/gtkcheckmenuitem.h>
 
33
#include <gtk/gtkentry.h>
 
34
#include <gtk/gtkimage.h>
 
35
#include <gtk/gtkimagemenuitem.h>
 
36
#include <gtk/gtkradiomenuitem.h>
 
37
#include <gtk/gtklabel.h>
 
38
#include <gtk/gtkmessagedialog.h>
 
39
#include <gtk/gtkmenu.h>
 
40
#include <gtk/gtkmenubar.h>
 
41
#include <gtk/gtkstock.h>
 
42
#include <gtk/gtkversion.h>
 
43
#include <gdk/gdkkeysyms.h>
 
44
 
 
45
#include "../common/xchat.h"
 
46
#include "../common/xchatc.h"
 
47
#include "../common/cfgfiles.h"
 
48
#include "../common/outbound.h"
 
49
#include "../common/ignore.h"
 
50
#include "../common/fe.h"
 
51
#include "../common/server.h"
 
52
#include "../common/servlist.h"
 
53
#include "../common/notify.h"
 
54
#include "../common/util.h"
 
55
#include "xtext.h"
 
56
#include "about.h"
 
57
#include "ascii.h"
 
58
#include "banlist.h"
 
59
#include "chanlist.h"
 
60
#include "editlist.h"
 
61
#include "fkeys.h"
 
62
#include "gtkutil.h"
 
63
#include "maingui.h"
 
64
#include "notifygui.h"
 
65
#include "pixmaps.h"
 
66
#include "rawlog.h"
 
67
#include "palette.h"
 
68
#include "plugingui.h"
 
69
#include "search.h"
 
70
#include "textgui.h"
 
71
#include "urlgrab.h"
 
72
#include "userlistgui.h"
 
73
#include "menu.h"
 
74
 
 
75
static GSList *submenu_list;
 
76
 
 
77
enum
 
78
{
 
79
        M_MENUITEM,
 
80
        M_NEWMENU,
 
81
        M_END,
 
82
        M_SEP,
 
83
        M_MENUTOG,
 
84
        M_MENURADIO,
 
85
        M_MENUSTOCK,
 
86
        M_MENUPIX,
 
87
        M_MENUSUB
 
88
};
 
89
 
 
90
struct mymenu
 
91
{
 
92
        char *text;
 
93
        void *callback;
 
94
        char *image;
 
95
        unsigned char type;     /* M_XXX */
 
96
        unsigned char id;               /* MENU_ID_XXX (menu.h) */
 
97
        unsigned char state;    /* ticked or not? */
 
98
        unsigned char sensitive;        /* shaded out? */
 
99
        guint key;                              /* GDK_x */
 
100
};
 
101
 
 
102
#define XCMENU_DOLIST 1
 
103
#define XCMENU_SHADED 1
 
104
#define XCMENU_MARKUP 2
 
105
#define XCMENU_MNEMONIC 4
 
106
 
 
107
/* execute a userlistbutton/popupmenu command */
 
108
 
 
109
static void
 
110
nick_command (session * sess, char *cmd)
 
111
{
 
112
        if (*cmd == '!')
 
113
                xchat_exec (cmd + 1);
 
114
        else
 
115
                handle_command (sess, cmd, TRUE);
 
116
}
 
117
 
 
118
/* fill in the %a %s %n etc and execute the command */
 
119
 
 
120
void
 
121
nick_command_parse (session *sess, char *cmd, char *nick, char *allnick)
 
122
{
 
123
        char *buf;
 
124
        char *host = _("Host unknown");
 
125
        struct User *user;
 
126
        int len;
 
127
 
 
128
/*      if (sess->type == SESS_DIALOG)
 
129
        {
 
130
                buf = (char *)(GTK_ENTRY (sess->gui->topic_entry)->text);
 
131
                buf = strrchr (buf, '@');
 
132
                if (buf)
 
133
                        host = buf + 1;
 
134
        } else*/
 
135
        {
 
136
                user = userlist_find (sess, nick);
 
137
                if (user && user->hostname)
 
138
                        host = strchr (user->hostname, '@') + 1;
 
139
        }
 
140
 
 
141
        /* this can't overflow, since popup->cmd is only 256 */
 
142
        len = strlen (cmd) + strlen (nick) + strlen (allnick) + 512;
 
143
        buf = malloc (len);
 
144
 
 
145
        auto_insert (buf, len, cmd, 0, 0, allnick, sess->channel, "",
 
146
                                         server_get_network (sess->server, TRUE), host,
 
147
                                         sess->server->nick, nick);
 
148
 
 
149
        nick_command (sess, buf);
 
150
 
 
151
        free (buf);
 
152
}
 
153
 
 
154
/* userlist button has been clicked */
 
155
 
 
156
void
 
157
userlist_button_cb (GtkWidget * button, char *cmd)
 
158
{
 
159
        int i, num_sel, using_allnicks = FALSE;
 
160
        char **nicks, *allnicks;
 
161
        char *nick = NULL;
 
162
        session *sess;
 
163
 
 
164
        sess = current_sess;
 
165
 
 
166
        if (strstr (cmd, "%a"))
 
167
                using_allnicks = TRUE;
 
168
 
 
169
        if (sess->type == SESS_DIALOG)
 
170
        {
 
171
                /* fake a selection */
 
172
                nicks = malloc (sizeof (char *) * 2);
 
173
                nicks[0] = g_strdup (sess->channel);
 
174
                nicks[1] = NULL;
 
175
                num_sel = 1;
 
176
        } else
 
177
        {
 
178
                /* find number of selected rows */
 
179
                nicks = userlist_selection_list (sess->gui->user_tree, &num_sel);
 
180
                if (num_sel < 1)
 
181
                {
 
182
                        nick_command_parse (sess, cmd, "", "");
 
183
                        return;
 
184
                }
 
185
        }
 
186
 
 
187
        /* create "allnicks" string */
 
188
        allnicks = malloc (((NICKLEN + 1) * num_sel) + 1);
 
189
        *allnicks = 0;
 
190
 
 
191
        i = 0;
 
192
        while (nicks[i])
 
193
        {
 
194
                if (i > 0)
 
195
                        strcat (allnicks, " ");
 
196
                strcat (allnicks, nicks[i]);
 
197
 
 
198
                if (!nick)
 
199
                        nick = nicks[0];
 
200
 
 
201
                /* if not using "%a", execute the command once for each nickname */
 
202
                if (!using_allnicks)
 
203
                        nick_command_parse (sess, cmd, nicks[i], "");
 
204
 
 
205
                i++;
 
206
        }
 
207
 
 
208
        if (using_allnicks)
 
209
        {
 
210
                if (!nick)
 
211
                        nick = "";
 
212
                nick_command_parse (sess, cmd, nick, allnicks);
 
213
        }
 
214
 
 
215
        while (num_sel)
 
216
        {
 
217
                num_sel--;
 
218
                g_free (nicks[num_sel]);
 
219
        }
 
220
 
 
221
        free (nicks);
 
222
        free (allnicks);
 
223
}
 
224
 
 
225
/* a popup-menu-item has been selected */
 
226
 
 
227
static void
 
228
popup_menu_cb (GtkWidget * item, char *cmd)
 
229
{
 
230
        char *nick;
 
231
 
 
232
        /* the userdata is set in menu_quick_item() */
 
233
        nick = g_object_get_data (G_OBJECT (item), "u");
 
234
 
 
235
        if (!nick)      /* userlist popup menu */
 
236
        {
 
237
                /* treat it just like a userlist button */
 
238
                userlist_button_cb (NULL, cmd);
 
239
                return;
 
240
        }
 
241
 
 
242
        if (!current_sess)      /* for url grabber window */
 
243
                nick_command_parse (sess_list->data, cmd, nick, nick);
 
244
        else
 
245
                nick_command_parse (current_sess, cmd, nick, nick);
 
246
}
 
247
 
 
248
GtkWidget *
 
249
menu_toggle_item (char *label, GtkWidget *menu, void *callback, void *userdata,
 
250
                                                int state)
 
251
{
 
252
        GtkWidget *item;
 
253
 
 
254
        item = gtk_check_menu_item_new_with_mnemonic (label);
 
255
        gtk_check_menu_item_set_active ((GtkCheckMenuItem*)item, state);
 
256
        gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
 
257
        g_signal_connect (G_OBJECT (item), "activate",
 
258
                                                        G_CALLBACK (callback), userdata);
 
259
        gtk_widget_show (item);
 
260
 
 
261
        return item;
 
262
}
 
263
 
 
264
GtkWidget *
 
265
menu_quick_item (char *cmd, char *label, GtkWidget * menu, int flags,
 
266
                                          gpointer userdata, char *icon)
 
267
{
 
268
        GtkWidget *img, *item;
 
269
        char *path;
 
270
 
 
271
        if (!label)
 
272
                item = gtk_menu_item_new ();
 
273
        else
 
274
        {
 
275
                if (icon)
 
276
                {
 
277
                        /*if (flags & XCMENU_MARKUP)
 
278
                                item = gtk_image_menu_item_new_with_markup (label);
 
279
                        else*/
 
280
                                item = gtk_image_menu_item_new_with_mnemonic (label);
 
281
                        img = NULL;
 
282
                        if (access (icon, R_OK) == 0)   /* try fullpath */
 
283
                                img = gtk_image_new_from_file (icon);
 
284
                        else
 
285
                        {
 
286
                                /* try relative to ~/.xchat2 */
 
287
                                path = g_strdup_printf ("%s/%s", get_xdir_fs (), icon);
 
288
                                if (access (path, R_OK) == 0)
 
289
                                        img = gtk_image_new_from_file (path);
 
290
                                else
 
291
                                        img = gtk_image_new_from_stock (icon, GTK_ICON_SIZE_MENU);
 
292
                                g_free (path);
 
293
                        }
 
294
 
 
295
                        if (img)
 
296
                                gtk_image_menu_item_set_image ((GtkImageMenuItem *)item, img);
 
297
                }
 
298
                else
 
299
                {
 
300
                        if (flags & XCMENU_MARKUP)
 
301
                        {
 
302
                                item = gtk_menu_item_new_with_label ("");
 
303
                                if (flags & XCMENU_MNEMONIC)
 
304
                                        gtk_label_set_markup_with_mnemonic (GTK_LABEL (GTK_BIN (item)->child), label);
 
305
                                else
 
306
                                        gtk_label_set_markup (GTK_LABEL (GTK_BIN (item)->child), label);
 
307
                        } else
 
308
                        {
 
309
                                if (flags & XCMENU_MNEMONIC)
 
310
                                        item = gtk_menu_item_new_with_mnemonic (label);
 
311
                                else
 
312
                                        item = gtk_menu_item_new_with_label (label);
 
313
                        }
 
314
                }
 
315
        }
 
316
        gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
 
317
        g_object_set_data (G_OBJECT (item), "u", userdata);
 
318
        if (cmd)
 
319
                g_signal_connect (G_OBJECT (item), "activate",
 
320
                                                                G_CALLBACK (popup_menu_cb), cmd);
 
321
        if (flags & XCMENU_SHADED)
 
322
                gtk_widget_set_sensitive (GTK_WIDGET (item), FALSE);
 
323
        gtk_widget_show_all (item);
 
324
 
 
325
        return item;
 
326
}
 
327
 
 
328
static void
 
329
menu_quick_item_with_callback (void *callback, char *label, GtkWidget * menu,
 
330
                                                                                 void *arg)
 
331
{
 
332
        GtkWidget *item;
 
333
 
 
334
        item = gtk_menu_item_new_with_label (label);
 
335
        gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
 
336
        g_signal_connect (G_OBJECT (item), "activate",
 
337
                                                        G_CALLBACK (callback), arg);
 
338
        gtk_widget_show (item);
 
339
}
 
340
 
 
341
GtkWidget *
 
342
menu_quick_sub (char *name, GtkWidget *menu, GtkWidget **sub_item_ret, int flags, int pos)
 
343
{
 
344
        GtkWidget *sub_menu;
 
345
        GtkWidget *sub_item;
 
346
 
 
347
        if (!name)
 
348
                return menu;
 
349
 
 
350
        /* Code to add a submenu */
 
351
        sub_menu = gtk_menu_new ();
 
352
        if (flags & XCMENU_MARKUP)
 
353
        {
 
354
                sub_item = gtk_menu_item_new_with_label ("");
 
355
                gtk_label_set_markup (GTK_LABEL (GTK_BIN (sub_item)->child), name);
 
356
        }
 
357
        else
 
358
        {
 
359
                if (flags & XCMENU_MNEMONIC)
 
360
                        sub_item = gtk_menu_item_new_with_mnemonic (name);
 
361
                else
 
362
                        sub_item = gtk_menu_item_new_with_label (name);
 
363
        }
 
364
        gtk_menu_shell_insert (GTK_MENU_SHELL (menu), sub_item, pos);
 
365
        gtk_widget_show (sub_item);
 
366
        gtk_menu_item_set_submenu (GTK_MENU_ITEM (sub_item), sub_menu);
 
367
 
 
368
        if (sub_item_ret)
 
369
                *sub_item_ret = sub_item;
 
370
 
 
371
        if (flags & XCMENU_DOLIST)
 
372
                /* We create a new element in the list */
 
373
                submenu_list = g_slist_prepend (submenu_list, sub_menu);
 
374
        return sub_menu;
 
375
}
 
376
 
 
377
static GtkWidget *
 
378
menu_quick_endsub ()
 
379
{
 
380
        /* Just delete the first element in the linked list pointed to by first */
 
381
        if (submenu_list)
 
382
                submenu_list = g_slist_remove (submenu_list, submenu_list->data);
 
383
 
 
384
        if (submenu_list)
 
385
                return (submenu_list->data);
 
386
        else
 
387
                return NULL;
 
388
}
 
389
 
 
390
static void
 
391
toggle_cb (GtkWidget *item, char *pref_name)
 
392
{
 
393
        char buf[256];
 
394
 
 
395
        if (GTK_CHECK_MENU_ITEM (item)->active)
 
396
                snprintf (buf, sizeof (buf), "set %s 1", pref_name);
 
397
        else
 
398
                snprintf (buf, sizeof (buf), "set %s 0", pref_name);
 
399
 
 
400
        handle_command (current_sess, buf, FALSE);
 
401
}
 
402
 
 
403
static int
 
404
is_in_path (char *cmd)
 
405
{
 
406
        char *prog = strdup (cmd + 1);  /* 1st char is "!" */
 
407
        char *space, *path, *orig;
 
408
 
 
409
        orig = prog; /* save for free()ing */
 
410
        /* special-case these default entries. */
 
411
        /*                  123456789012345678 */
 
412
        if (strncmp (prog, "gnome-terminal -x ", 18) == 0)
 
413
        /* don't check for gnome-terminal, but the thing it's executing! */
 
414
                prog += 18;
 
415
 
 
416
        space = strchr (prog, ' ');     /* this isn't 100% but good enuf */
 
417
        if (space)
 
418
                *space = 0;
 
419
 
 
420
        path = g_find_program_in_path (prog);
 
421
        if (path)
 
422
        {
 
423
                g_free (path);
 
424
                g_free (orig);
 
425
                return 1;
 
426
        }
 
427
 
 
428
        g_free (orig);
 
429
        return 0;
 
430
}
 
431
 
 
432
/* syntax: "LABEL~ICON~STUFF~ADDED~LATER~" */
 
433
 
 
434
static void
 
435
menu_extract_icon (char *name, char **label, char **icon)
 
436
{
 
437
        char *p = name;
 
438
        char *start = NULL;
 
439
        char *end = NULL;
 
440
 
 
441
        while (*p)
 
442
        {
 
443
                if (*p == '~')
 
444
                {
 
445
                        /* escape \~ */
 
446
                        if (p == name || p[-1] != '\\')
 
447
                        {
 
448
                                if (!start)
 
449
                                        start = p + 1;
 
450
                                else if (!end)
 
451
                                        end = p + 1;
 
452
                        }
 
453
                }
 
454
                p++;
 
455
        }
 
456
 
 
457
        if (!end)
 
458
                end = p;
 
459
 
 
460
        if (start && start != end)
 
461
        {
 
462
                *label = g_strndup (name, (start - name) - 1);
 
463
                *icon = g_strndup (start, (end - start) - 1);
 
464
        }
 
465
        else
 
466
        {
 
467
                *label = g_strdup (name);
 
468
                *icon = NULL;
 
469
        }
 
470
}
 
471
 
 
472
/* append items to "menu" using the (struct popup*) list provided */
 
473
 
 
474
void
 
475
menu_create (GtkWidget *menu, GSList *list, char *target, int check_path)
 
476
{
 
477
        struct popup *pop;
 
478
        GtkWidget *tempmenu = menu, *subitem = NULL;
 
479
        int childcount = 0;
 
480
 
 
481
        submenu_list = g_slist_prepend (0, menu);
 
482
        while (list)
 
483
        {
 
484
                pop = (struct popup *) list->data;
 
485
 
 
486
                if (!strncasecmp (pop->name, "SUB", 3))
 
487
                {
 
488
                        childcount = 0;
 
489
                        tempmenu = menu_quick_sub (pop->cmd, tempmenu, &subitem, XCMENU_DOLIST|XCMENU_MNEMONIC, -1);
 
490
 
 
491
                } else if (!strncasecmp (pop->name, "TOGGLE", 6))
 
492
                {
 
493
                        childcount++;
 
494
                        menu_toggle_item (pop->name + 7, tempmenu, toggle_cb, pop->cmd,
 
495
                                                                        cfg_get_bool (pop->cmd));
 
496
 
 
497
                } else if (!strncasecmp (pop->name, "ENDSUB", 6))
 
498
                {
 
499
                        /* empty sub menu due to no programs in PATH? */
 
500
                        if (check_path && childcount < 1)
 
501
                                gtk_widget_destroy (subitem);
 
502
                        subitem = NULL;
 
503
 
 
504
                        if (tempmenu != menu)
 
505
                                tempmenu = menu_quick_endsub ();
 
506
                        /* If we get here and tempmenu equals menu that means we havent got any submenus to exit from */
 
507
 
 
508
                } else if (!strncasecmp (pop->name, "SEP", 3))
 
509
                {
 
510
                        menu_quick_item (0, 0, tempmenu, XCMENU_SHADED, 0, 0);
 
511
 
 
512
                } else
 
513
                {
 
514
                        char *icon, *label;
 
515
 
 
516
                        /* default command in xchat.c */
 
517
                        if (pop->cmd[0] == 'n' && !strcmp (pop->cmd, "notify -n ASK %s"))
 
518
                        {
 
519
                                /* don't create this item if already in notify list */
 
520
                                if (!target || notify_is_in_list (current_sess->server, target))
 
521
                                {
 
522
                                        list = list->next;
 
523
                                        continue;
 
524
                                }
 
525
                        }
 
526
 
 
527
                        menu_extract_icon (pop->name, &label, &icon);
 
528
 
 
529
                        if (!check_path || pop->cmd[0] != '!')
 
530
                        {
 
531
                                menu_quick_item (pop->cmd, label, tempmenu, 0, target, icon);
 
532
                        /* check if the program is in path, if not, leave it out! */
 
533
                        } else if (is_in_path (pop->cmd))
 
534
                        {
 
535
                                childcount++;
 
536
                                menu_quick_item (pop->cmd, label, tempmenu, 0, target, icon);
 
537
                        }
 
538
 
 
539
                        g_free (label);
 
540
                        g_free (icon);
 
541
                }
 
542
 
 
543
                list = list->next;
 
544
        }
 
545
 
 
546
        /* Let's clean up the linked list from mem */
 
547
        while (submenu_list)
 
548
                submenu_list = g_slist_remove (submenu_list, submenu_list->data);
 
549
}
 
550
 
 
551
static char *str_copy = NULL;           /* for all pop-up menus */
 
552
static GtkWidget *nick_submenu = NULL;  /* user info submenu */
 
553
 
 
554
static void
 
555
menu_destroy (GtkWidget *menu, gpointer objtounref)
 
556
{
 
557
        gtk_widget_destroy (menu);
 
558
        g_object_unref (menu);
 
559
        if (objtounref)
 
560
                g_object_unref (G_OBJECT (objtounref));
 
561
        nick_submenu = NULL;
 
562
}
 
563
 
 
564
static void
 
565
menu_popup (GtkWidget *menu, GdkEventButton *event, gpointer objtounref)
 
566
{
 
567
#if (GTK_MAJOR_VERSION != 2) || (GTK_MINOR_VERSION != 0)
 
568
        if (event && event->window)
 
569
                gtk_menu_set_screen (GTK_MENU (menu), gdk_drawable_get_screen (event->window));
 
570
#endif
 
571
 
 
572
        g_object_ref (menu);
 
573
        g_object_ref_sink (menu);
 
574
        g_object_unref (menu);
 
575
        g_signal_connect (G_OBJECT (menu), "selection-done",
 
576
                                                        G_CALLBACK (menu_destroy), objtounref);
 
577
        gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL,
 
578
                                                 0, event ? event->time : 0);
 
579
}
 
580
 
 
581
static void
 
582
menu_nickinfo_cb (GtkWidget *menu, session *sess)
 
583
{
 
584
        char buf[512];
 
585
 
 
586
        if (!is_session (sess))
 
587
                return;
 
588
 
 
589
        /* issue a /WHOIS */
 
590
        snprintf (buf, sizeof (buf), "WHOIS %s %s", str_copy, str_copy);
 
591
        handle_command (sess, buf, FALSE);
 
592
        /* and hide the output */
 
593
        sess->server->skip_next_whois = 1;
 
594
}
 
595
 
 
596
static void
 
597
copy_to_clipboard_cb (GtkWidget *item, char *url)
 
598
{
 
599
        gtkutil_copy_to_clipboard (item, NULL, url);
 
600
}
 
601
 
 
602
/* returns boolean: Some data is missing */
 
603
 
 
604
static gboolean
 
605
menu_create_nickinfo_menu (struct User *user, GtkWidget *submenu)
 
606
{
 
607
        char buf[512];
 
608
        char unknown[96];
 
609
        char *real, *fmt;
 
610
        struct away_msg *away;
 
611
        gboolean missing = FALSE;
 
612
        GtkWidget *item;
 
613
 
 
614
        /* let the translators tweak this if need be */
 
615
        fmt = _("<tt><b>%-11s</b></tt> %s");
 
616
        snprintf (unknown, sizeof (unknown), "<i>%s</i>", _("Unknown"));
 
617
 
 
618
        if (user->realname)
 
619
        {
 
620
                real = strip_color (user->realname, -1, STRIP_ALL|STRIP_ESCMARKUP);
 
621
                snprintf (buf, sizeof (buf), fmt, _("Real Name:"), real);
 
622
                g_free (real);
 
623
        } else
 
624
        {
 
625
                snprintf (buf, sizeof (buf), fmt, _("Real Name:"), unknown);
 
626
        }
 
627
        item = menu_quick_item (0, buf, submenu, XCMENU_MARKUP, 0, 0);
 
628
        g_signal_connect (G_OBJECT (item), "activate",
 
629
                                                        G_CALLBACK (copy_to_clipboard_cb), 
 
630
                                                        user->realname ? user->realname : unknown);
 
631
 
 
632
        snprintf (buf, sizeof (buf), fmt, _("User:"),
 
633
                                 user->hostname ? user->hostname : unknown);
 
634
        item = menu_quick_item (0, buf, submenu, XCMENU_MARKUP, 0, 0);
 
635
        g_signal_connect (G_OBJECT (item), "activate",
 
636
                                                        G_CALLBACK (copy_to_clipboard_cb), 
 
637
                                                        user->hostname ? user->hostname : unknown);
 
638
 
 
639
        snprintf (buf, sizeof (buf), fmt, _("Country:"),
 
640
                                 user->hostname ? country(user->hostname) : unknown);
 
641
        item = menu_quick_item (0, buf, submenu, XCMENU_MARKUP, 0, 0);
 
642
        g_signal_connect (G_OBJECT (item), "activate",
 
643
                                                        G_CALLBACK (copy_to_clipboard_cb), 
 
644
                                                        user->hostname ? country(user->hostname) : unknown);
 
645
 
 
646
        snprintf (buf, sizeof (buf), fmt, _("Server:"),
 
647
                                 user->servername ? user->servername : unknown);
 
648
        item = menu_quick_item (0, buf, submenu, XCMENU_MARKUP, 0, 0);
 
649
        g_signal_connect (G_OBJECT (item), "activate",
 
650
                                                        G_CALLBACK (copy_to_clipboard_cb), 
 
651
                                                        user->servername ? user->servername : unknown);
 
652
 
 
653
        if (user->lasttalk)
 
654
        {
 
655
                char min[96];
 
656
 
 
657
                snprintf (min, sizeof (min), _("%u minutes ago"),
 
658
                                        (unsigned int) ((time (0) - user->lasttalk) / 60));
 
659
                snprintf (buf, sizeof (buf), fmt, _("Last Msg:"), min);
 
660
        } else
 
661
        {
 
662
                snprintf (buf, sizeof (buf), fmt, _("Last Msg:"), unknown);
 
663
        }
 
664
        menu_quick_item (0, buf, submenu, XCMENU_MARKUP, 0, 0);
 
665
 
 
666
        if (user->away)
 
667
        {
 
668
                away = server_away_find_message (current_sess->server, user->nick);
 
669
                if (away)
 
670
                {
 
671
                        char *msg = strip_color (away->message ? away->message : unknown, -1, STRIP_ALL|STRIP_ESCMARKUP);
 
672
                        snprintf (buf, sizeof (buf), fmt, _("Away Msg:"), msg);
 
673
                        g_free (msg);
 
674
                        item = menu_quick_item (0, buf, submenu, XCMENU_MARKUP, 0, 0);
 
675
                        g_signal_connect (G_OBJECT (item), "activate",
 
676
                                                                        G_CALLBACK (copy_to_clipboard_cb), 
 
677
                                                                        away->message ? away->message : unknown);
 
678
                }
 
679
                else
 
680
                        missing = TRUE;
 
681
        }
 
682
 
 
683
        return missing;
 
684
}
 
685
 
 
686
void
 
687
fe_userlist_update (session *sess, struct User *user)
 
688
{
 
689
        GList *items, *next;
 
690
 
 
691
        if (!nick_submenu || !str_copy)
 
692
                return;
 
693
 
 
694
        /* not the same nick as the menu? */
 
695
        if (sess->server->p_cmp (user->nick, str_copy))
 
696
                return;
 
697
 
 
698
        /* get rid of the "show" signal */
 
699
        g_signal_handlers_disconnect_by_func (nick_submenu, menu_nickinfo_cb, sess);
 
700
 
 
701
        /* destroy all the old items */
 
702
        items = ((GtkMenuShell *) nick_submenu)->children;
 
703
        while (items)
 
704
        {
 
705
                next = items->next;
 
706
                gtk_widget_destroy (items->data);
 
707
                items = next;
 
708
        }
 
709
 
 
710
        /* and re-create them with new info */
 
711
        menu_create_nickinfo_menu (user, nick_submenu);
 
712
}
 
713
 
 
714
void
 
715
menu_nickmenu (session *sess, GdkEventButton *event, char *nick, int num_sel)
 
716
{
 
717
        char buf[512];
 
718
        struct User *user;
 
719
        GtkWidget *submenu, *menu = gtk_menu_new ();
 
720
 
 
721
        if (str_copy)
 
722
                free (str_copy);
 
723
        str_copy = strdup (nick);
 
724
 
 
725
        submenu_list = 0;       /* first time through, might not be 0 */
 
726
 
 
727
        /* more than 1 nick selected? */
 
728
        if (num_sel > 1)
 
729
        {
 
730
                snprintf (buf, sizeof (buf), _("%d nicks selected."), num_sel);
 
731
                menu_quick_item (0, buf, menu, 0, 0, 0);
 
732
                menu_quick_item (0, 0, menu, XCMENU_SHADED, 0, 0);
 
733
        } else
 
734
        {
 
735
                user = userlist_find (sess, nick);      /* lasttalk is channel specific */
 
736
                if (!user)
 
737
                        user = userlist_find_global (current_sess->server, nick);
 
738
                if (user)
 
739
                {
 
740
                        nick_submenu = submenu = menu_quick_sub (nick, menu, NULL, XCMENU_DOLIST, -1);
 
741
 
 
742
                        if (menu_create_nickinfo_menu (user, submenu) ||
 
743
                                 !user->hostname || !user->realname || !user->servername)
 
744
                        {
 
745
                                g_signal_connect (G_OBJECT (submenu), "show", G_CALLBACK (menu_nickinfo_cb), sess);
 
746
                        }
 
747
 
 
748
                        menu_quick_endsub ();
 
749
                        menu_quick_item (0, 0, menu, XCMENU_SHADED, 0, 0);
 
750
                }
 
751
        }
 
752
 
 
753
        if (num_sel > 1)
 
754
                menu_create (menu, popup_list, NULL, FALSE);
 
755
        else
 
756
                menu_create (menu, popup_list, str_copy, FALSE);
 
757
 
 
758
        if (num_sel == 0)       /* xtext click */
 
759
                menu_add_plugin_items (menu, "\x5$NICK", str_copy);
 
760
        else    /* userlist treeview click */
 
761
                menu_add_plugin_items (menu, "\x5$NICK", NULL);
 
762
 
 
763
        menu_popup (menu, event, NULL);
 
764
}
 
765
 
 
766
/* stuff for the View menu */
 
767
 
 
768
static void
 
769
menu_showhide_cb (session *sess)
 
770
{
 
771
        if (prefs.hidemenu)
 
772
                gtk_widget_hide (sess->gui->menu);
 
773
        else
 
774
                gtk_widget_show (sess->gui->menu);
 
775
}
 
776
 
 
777
static void
 
778
menu_topic_showhide_cb (session *sess)
 
779
{
 
780
        if (prefs.topicbar)
 
781
                gtk_widget_show (sess->gui->topic_bar);
 
782
        else
 
783
                gtk_widget_hide (sess->gui->topic_bar);
 
784
}
 
785
 
 
786
static void
 
787
menu_userlist_showhide_cb (session *sess)
 
788
{
 
789
        mg_decide_userlist (sess, TRUE);
 
790
}
 
791
 
 
792
static void
 
793
menu_ulbuttons_showhide_cb (session *sess)
 
794
{
 
795
        if (prefs.userlistbuttons)
 
796
                gtk_widget_show (sess->gui->button_box);
 
797
        else
 
798
                gtk_widget_hide (sess->gui->button_box);
 
799
}
 
800
 
 
801
static void
 
802
menu_cmbuttons_showhide_cb (session *sess)
 
803
{
 
804
        switch (sess->type)
 
805
        {
 
806
        case SESS_CHANNEL:
 
807
                if (prefs.chanmodebuttons)
 
808
                        gtk_widget_show (sess->gui->topicbutton_box);
 
809
                else
 
810
                        gtk_widget_hide (sess->gui->topicbutton_box);
 
811
                break;
 
812
        default:
 
813
                gtk_widget_hide (sess->gui->topicbutton_box);
 
814
        }
 
815
}
 
816
 
 
817
static void
 
818
menu_setting_foreach (void (*callback) (session *), int id, guint state)
 
819
{
 
820
        session *sess;
 
821
        GSList *list;
 
822
        int maindone = FALSE;   /* do it only once for EVERY tab */
 
823
 
 
824
        list = sess_list;
 
825
        while (list)
 
826
        {
 
827
                sess = list->data;
 
828
 
 
829
                if (!sess->gui->is_tab || !maindone)
 
830
                {
 
831
                        if (sess->gui->is_tab)
 
832
                                maindone = TRUE;
 
833
                        if (id != -1)
 
834
                                GTK_CHECK_MENU_ITEM (sess->gui->menu_item[id])->active = state;
 
835
                        if (callback)
 
836
                                callback (sess);
 
837
                }
 
838
 
 
839
                list = list->next;
 
840
        }
 
841
}
 
842
 
 
843
void
 
844
menu_bar_toggle (void)
 
845
{
 
846
        prefs.hidemenu = !prefs.hidemenu;
 
847
        menu_setting_foreach (menu_showhide_cb, MENU_ID_MENUBAR, !prefs.hidemenu);
 
848
}
 
849
 
 
850
static void
 
851
menu_bar_toggle_cb (void)
 
852
{
 
853
        menu_bar_toggle ();
 
854
        if (prefs.hidemenu)
 
855
                fe_message (_("The Menubar is now hidden. You can show it again"
 
856
                                                  " by pressing F9 or right-clicking in a blank part of"
 
857
                                                  " the main text area."), FE_MSG_INFO);
 
858
}
 
859
 
 
860
static void
 
861
menu_topicbar_toggle (GtkWidget *wid, gpointer ud)
 
862
{
 
863
        prefs.topicbar = !prefs.topicbar;
 
864
        menu_setting_foreach (menu_topic_showhide_cb, MENU_ID_TOPICBAR,
 
865
                                                                 prefs.topicbar);
 
866
}
 
867
 
 
868
static void
 
869
menu_userlist_toggle (GtkWidget *wid, gpointer ud)
 
870
{
 
871
        prefs.hideuserlist = !prefs.hideuserlist;
 
872
        menu_setting_foreach (menu_userlist_showhide_cb, MENU_ID_USERLIST,
 
873
                                                                 !prefs.hideuserlist);
 
874
}
 
875
 
 
876
static void
 
877
menu_ulbuttons_toggle (GtkWidget *wid, gpointer ud)
 
878
{
 
879
        prefs.userlistbuttons = !prefs.userlistbuttons;
 
880
        menu_setting_foreach (menu_ulbuttons_showhide_cb, MENU_ID_ULBUTTONS,
 
881
                                                                 prefs.userlistbuttons);
 
882
}
 
883
 
 
884
static void
 
885
menu_cmbuttons_toggle (GtkWidget *wid, gpointer ud)
 
886
{
 
887
        prefs.chanmodebuttons = !prefs.chanmodebuttons;
 
888
        menu_setting_foreach (menu_cmbuttons_showhide_cb, MENU_ID_MODEBUTTONS,
 
889
                                                                 prefs.chanmodebuttons);
 
890
}
 
891
 
 
892
void
 
893
menu_middlemenu (session *sess, GdkEventButton *event)
 
894
{
 
895
        GtkWidget *menu;
 
896
        GtkAccelGroup *accel_group;
 
897
 
 
898
        accel_group = gtk_accel_group_new ();
 
899
        menu = menu_create_main (accel_group, FALSE, sess->server->is_away, !sess->gui->is_tab, NULL);
 
900
        menu_popup (menu, event, accel_group);
 
901
}
 
902
 
 
903
static void
 
904
open_url_cb (GtkWidget *item, char *url)
 
905
{
 
906
        char buf[512];
 
907
 
 
908
        /* pass this to /URL so it can handle irc:// */
 
909
        snprintf (buf, sizeof (buf), "URL %s", url);
 
910
        handle_command (current_sess, buf, FALSE);
 
911
}
 
912
 
 
913
void
 
914
menu_urlmenu (GdkEventButton *event, char *url)
 
915
{
 
916
        GtkWidget *menu;
 
917
        char *tmp, *chop;
 
918
 
 
919
        if (str_copy)
 
920
                free (str_copy);
 
921
        str_copy = strdup (url);
 
922
 
 
923
        menu = gtk_menu_new ();
 
924
        /* more than 51 chars? Chop it */
 
925
        if (g_utf8_strlen (str_copy, -1) >= 52)
 
926
        {
 
927
                tmp = strdup (str_copy);
 
928
                chop = g_utf8_offset_to_pointer (tmp, 48);
 
929
                chop[0] = chop[1] = chop[2] = '.';
 
930
                chop[3] = 0;
 
931
                menu_quick_item (0, tmp, menu, XCMENU_SHADED, 0, 0);
 
932
                free (tmp);
 
933
        } else
 
934
        {
 
935
                menu_quick_item (0, str_copy, menu, XCMENU_SHADED, 0, 0);
 
936
        }
 
937
        menu_quick_item (0, 0, menu, XCMENU_SHADED, 0, 0);
 
938
 
 
939
        /* Two hardcoded entries */
 
940
        if (strncmp (str_copy, "irc://", 6) == 0 ||
 
941
            strncmp (str_copy, "ircs://",7) == 0)
 
942
                menu_quick_item_with_callback (open_url_cb, _("Connect"), menu, str_copy);
 
943
        else
 
944
                menu_quick_item_with_callback (open_url_cb, _("Open Link in Browser"), menu, str_copy);
 
945
        menu_quick_item_with_callback (copy_to_clipboard_cb, _("Copy Selected Link"), menu, str_copy);
 
946
        /* custom ones from urlhandlers.conf */
 
947
        menu_create (menu, urlhandler_list, str_copy, TRUE);
 
948
        menu_add_plugin_items (menu, "\x4$URL", str_copy);
 
949
        menu_popup (menu, event, NULL);
 
950
}
 
951
 
 
952
static void
 
953
menu_chan_cycle (GtkWidget * menu, char *chan)
 
954
{
 
955
        char tbuf[256];
 
956
 
 
957
        if (current_sess)
 
958
        {
 
959
                snprintf (tbuf, sizeof tbuf, "CYCLE %s", chan);
 
960
                handle_command (current_sess, tbuf, FALSE);
 
961
        }
 
962
}
 
963
 
 
964
static void
 
965
menu_chan_part (GtkWidget * menu, char *chan)
 
966
{
 
967
        char tbuf[256];
 
968
 
 
969
        if (current_sess)
 
970
        {
 
971
                snprintf (tbuf, sizeof tbuf, "part %s", chan);
 
972
                handle_command (current_sess, tbuf, FALSE);
 
973
        }
 
974
}
 
975
 
 
976
static void
 
977
menu_chan_join (GtkWidget * menu, char *chan)
 
978
{
 
979
        char tbuf[256];
 
980
 
 
981
        if (current_sess)
 
982
        {
 
983
                snprintf (tbuf, sizeof tbuf, "join %s", chan);
 
984
                handle_command (current_sess, tbuf, FALSE);
 
985
        }
 
986
}
 
987
 
 
988
void
 
989
menu_chanmenu (struct session *sess, GdkEventButton * event, char *chan)
 
990
{
 
991
        GtkWidget *menu;
 
992
        int is_joined = FALSE;
 
993
 
 
994
        if (find_channel (sess->server, chan))
 
995
                is_joined = TRUE;
 
996
 
 
997
        if (str_copy)
 
998
                free (str_copy);
 
999
        str_copy = strdup (chan);
 
1000
 
 
1001
        menu = gtk_menu_new ();
 
1002
 
 
1003
        menu_quick_item (0, chan, menu, XCMENU_SHADED, str_copy, 0);
 
1004
        menu_quick_item (0, 0, menu, XCMENU_SHADED, str_copy, 0);
 
1005
 
 
1006
        if (!is_joined)
 
1007
                menu_quick_item_with_callback (menu_chan_join, _("Join Channel"), menu,
 
1008
                                                                                                 str_copy);
 
1009
        else
 
1010
        {
 
1011
                menu_quick_item_with_callback (menu_chan_part, _("Part Channel"), menu,
 
1012
                                                                                                 str_copy);
 
1013
                menu_quick_item_with_callback (menu_chan_cycle, _("Cycle Channel"), menu,
 
1014
                                                                                                 str_copy);
 
1015
        }
 
1016
 
 
1017
        menu_addfavoritemenu (sess->server, menu, str_copy);
 
1018
 
 
1019
        menu_add_plugin_items (menu, "\x5$CHAN", str_copy);
 
1020
        menu_popup (menu, event, NULL);
 
1021
}
 
1022
 
 
1023
static void
 
1024
menu_delfav_cb (GtkWidget *item, server *serv)
 
1025
{
 
1026
        servlist_autojoinedit (serv->network, str_copy, FALSE);
 
1027
}
 
1028
 
 
1029
static void
 
1030
menu_addfav_cb (GtkWidget *item, server *serv)
 
1031
{
 
1032
        servlist_autojoinedit (serv->network, str_copy, TRUE);
 
1033
}
 
1034
 
 
1035
void
 
1036
menu_addfavoritemenu (server *serv, GtkWidget *menu, char *channel)
 
1037
{
 
1038
        if (!serv->network)
 
1039
                return;
 
1040
 
 
1041
        if (channel != str_copy)
 
1042
        {
 
1043
                if (str_copy)
 
1044
                        free (str_copy);
 
1045
                str_copy = strdup (channel);
 
1046
        }
 
1047
 
 
1048
        if (joinlist_is_in_list (serv, channel))
 
1049
                mg_create_icon_item (_("_Remove from Favorites"), GTK_STOCK_REMOVE, menu, menu_delfav_cb, serv);
 
1050
        else
 
1051
                mg_create_icon_item (_("_Add to Favorites"), GTK_STOCK_ADD, menu, menu_addfav_cb, serv);
 
1052
}
 
1053
 
 
1054
static void
 
1055
menu_open_server_list (GtkWidget *wid, gpointer none)
 
1056
{
 
1057
        fe_serverlist_open (current_sess);
 
1058
}
 
1059
 
 
1060
static void
 
1061
menu_settings (GtkWidget * wid, gpointer none)
 
1062
{
 
1063
        extern void setup_open (void);
 
1064
        setup_open ();
 
1065
}
 
1066
 
 
1067
static void
 
1068
menu_usermenu (void)
 
1069
{
 
1070
        editlist_gui_open (NULL, NULL, usermenu_list, _("XChat: User menu"),
 
1071
                                                         "usermenu", "usermenu.conf", 0);
 
1072
}
 
1073
 
 
1074
static void
 
1075
usermenu_create (GtkWidget *menu)
 
1076
{
 
1077
        menu_create (menu, usermenu_list, "", FALSE);
 
1078
        menu_quick_item (0, 0, menu, XCMENU_SHADED, 0, 0);      /* sep */
 
1079
        menu_quick_item_with_callback (menu_usermenu, _("Edit This Menu..."), menu, 0);
 
1080
}
 
1081
 
 
1082
static void
 
1083
usermenu_destroy (GtkWidget * menu)
 
1084
{
 
1085
        GList *items = ((GtkMenuShell *) menu)->children;
 
1086
        GList *next;
 
1087
 
 
1088
        while (items)
 
1089
        {
 
1090
                next = items->next;
 
1091
                gtk_widget_destroy (items->data);
 
1092
                items = next;
 
1093
        }
 
1094
}
 
1095
 
 
1096
void
 
1097
usermenu_update (void)
 
1098
{
 
1099
        int done_main = FALSE;
 
1100
        GSList *list = sess_list;
 
1101
        session *sess;
 
1102
        GtkWidget *menu;
 
1103
 
 
1104
        while (list)
 
1105
        {
 
1106
                sess = list->data;
 
1107
                menu = sess->gui->menu_item[MENU_ID_USERMENU];
 
1108
                if (sess->gui->is_tab)
 
1109
                {
 
1110
                        if (!done_main && menu)
 
1111
                        {
 
1112
                                usermenu_destroy (menu);
 
1113
                                usermenu_create (menu);
 
1114
                                done_main = TRUE;
 
1115
                        }
 
1116
                } else if (menu)
 
1117
                {
 
1118
                        usermenu_destroy (menu);
 
1119
                        usermenu_create (menu);
 
1120
                }
 
1121
                list = list->next;
 
1122
        }
 
1123
}
 
1124
 
 
1125
static void
 
1126
menu_newserver_window (GtkWidget * wid, gpointer none)
 
1127
{
 
1128
        int old = prefs.tabchannels;
 
1129
 
 
1130
        prefs.tabchannels = 0;
 
1131
        new_ircwindow (NULL, NULL, SESS_SERVER, 0);
 
1132
        prefs.tabchannels = old;
 
1133
}
 
1134
 
 
1135
static void
 
1136
menu_newchannel_window (GtkWidget * wid, gpointer none)
 
1137
{
 
1138
        int old = prefs.tabchannels;
 
1139
 
 
1140
        prefs.tabchannels = 0;
 
1141
        new_ircwindow (current_sess->server, NULL, SESS_CHANNEL, 0);
 
1142
        prefs.tabchannels = old;
 
1143
}
 
1144
 
 
1145
static void
 
1146
menu_newserver_tab (GtkWidget * wid, gpointer none)
 
1147
{
 
1148
        int old = prefs.tabchannels;
 
1149
        int oldf = prefs.newtabstofront;
 
1150
 
 
1151
        prefs.tabchannels = 1;
 
1152
        /* force focus if setting is "only requested tabs" */
 
1153
        if (prefs.newtabstofront == 2)
 
1154
                prefs.newtabstofront = 1;
 
1155
        new_ircwindow (NULL, NULL, SESS_SERVER, 0);
 
1156
        prefs.tabchannels = old;
 
1157
        prefs.newtabstofront = oldf;
 
1158
}
 
1159
 
 
1160
static void
 
1161
menu_newchannel_tab (GtkWidget * wid, gpointer none)
 
1162
{
 
1163
        int old = prefs.tabchannels;
 
1164
 
 
1165
        prefs.tabchannels = 1;
 
1166
        new_ircwindow (current_sess->server, NULL, SESS_CHANNEL, 0);
 
1167
        prefs.tabchannels = old;
 
1168
}
 
1169
 
 
1170
static void
 
1171
menu_rawlog (GtkWidget * wid, gpointer none)
 
1172
{
 
1173
        open_rawlog (current_sess->server);
 
1174
}
 
1175
 
 
1176
static void
 
1177
menu_detach (GtkWidget * wid, gpointer none)
 
1178
{
 
1179
        mg_detach (current_sess, 0);
 
1180
}
 
1181
 
 
1182
static void
 
1183
menu_close (GtkWidget * wid, gpointer none)
 
1184
{
 
1185
        mg_close_sess (current_sess);
 
1186
}
 
1187
 
 
1188
static void
 
1189
menu_quit (GtkWidget * wid, gpointer none)
 
1190
{
 
1191
        mg_open_quit_dialog (FALSE);
 
1192
}
 
1193
 
 
1194
static void
 
1195
menu_search ()
 
1196
{
 
1197
        search_open (current_sess);
 
1198
}
 
1199
 
 
1200
static void
 
1201
menu_resetmarker (GtkWidget * wid, gpointer none)
 
1202
{
 
1203
        gtk_xtext_reset_marker_pos (GTK_XTEXT (current_sess->gui->xtext));
 
1204
}
 
1205
 
 
1206
static void
 
1207
menu_flushbuffer (GtkWidget * wid, gpointer none)
 
1208
{
 
1209
        fe_text_clear (current_sess, 0);
 
1210
}
 
1211
 
 
1212
static void
 
1213
savebuffer_req_done (session *sess, char *file)
 
1214
{
 
1215
        int fh;
 
1216
 
 
1217
        if (!file)
 
1218
                return;
 
1219
 
 
1220
        fh = open (file, O_TRUNC | O_WRONLY | O_CREAT, 0600);
 
1221
        if (fh != -1)
 
1222
        {
 
1223
                gtk_xtext_save (GTK_XTEXT (sess->gui->xtext), fh);
 
1224
                close (fh);
 
1225
        }
 
1226
}
 
1227
 
 
1228
static void
 
1229
menu_savebuffer (GtkWidget * wid, gpointer none)
 
1230
{
 
1231
        gtkutil_file_req (_("Select an output filename"), savebuffer_req_done,
 
1232
                                                        current_sess, NULL, FRF_WRITE);
 
1233
}
 
1234
 
 
1235
static void
 
1236
menu_disconnect (GtkWidget * wid, gpointer none)
 
1237
{
 
1238
        handle_command (current_sess, "DISCON", FALSE);
 
1239
}
 
1240
 
 
1241
static void
 
1242
menu_reconnect (GtkWidget * wid, gpointer none)
 
1243
{
 
1244
        if (current_sess->server->hostname[0])
 
1245
                handle_command (current_sess, "RECONNECT", FALSE);
 
1246
        else
 
1247
                fe_serverlist_open (current_sess);
 
1248
}
 
1249
 
 
1250
static void
 
1251
menu_join_cb (GtkWidget *dialog, gint response, GtkEntry *entry)
 
1252
{
 
1253
        switch (response)
 
1254
        {
 
1255
        case GTK_RESPONSE_ACCEPT:
 
1256
                menu_chan_join (NULL, entry->text);
 
1257
                break;
 
1258
 
 
1259
        case GTK_RESPONSE_HELP:
 
1260
                chanlist_opengui (current_sess->server, TRUE);
 
1261
                break;
 
1262
        }
 
1263
 
 
1264
        gtk_widget_destroy (dialog);
 
1265
}
 
1266
 
 
1267
static void
 
1268
menu_join_entry_cb (GtkWidget *entry, GtkDialog *dialog)
 
1269
{
 
1270
        gtk_dialog_response (dialog, GTK_RESPONSE_ACCEPT);
 
1271
}
 
1272
 
 
1273
static void
 
1274
menu_join (GtkWidget * wid, gpointer none)
 
1275
{
 
1276
        GtkWidget *hbox, *dialog, *entry, *label;
 
1277
 
 
1278
        dialog = gtk_dialog_new_with_buttons (_("Join Channel"),
 
1279
                                                                        GTK_WINDOW (parent_window), 0,
 
1280
                                                                        _("Retrieve channel list..."), GTK_RESPONSE_HELP,
 
1281
                                                                        GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
 
1282
                                                                        GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
 
1283
                                                                        NULL);
 
1284
        gtk_box_set_homogeneous (GTK_BOX (GTK_DIALOG (dialog)->vbox), TRUE);
 
1285
        gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);
 
1286
        hbox = gtk_hbox_new (TRUE, 0);
 
1287
 
 
1288
        entry = gtk_entry_new ();
 
1289
        GTK_ENTRY (entry)->editable = 0;        /* avoid auto-selection */
 
1290
        gtk_entry_set_text (GTK_ENTRY (entry), "#");
 
1291
        g_signal_connect (G_OBJECT (entry), "activate",
 
1292
                                                        G_CALLBACK (menu_join_entry_cb), dialog);
 
1293
        gtk_box_pack_end (GTK_BOX (hbox), entry, 0, 0, 0);
 
1294
 
 
1295
        label = gtk_label_new (_("Enter Channel to Join:"));
 
1296
        gtk_box_pack_end (GTK_BOX (hbox), label, 0, 0, 0);
 
1297
 
 
1298
        g_signal_connect (G_OBJECT (dialog), "response",
 
1299
                                                   G_CALLBACK (menu_join_cb), entry);
 
1300
 
 
1301
        gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), hbox);
 
1302
 
 
1303
        gtk_widget_show_all (dialog);
 
1304
 
 
1305
        gtk_editable_set_editable (GTK_EDITABLE (entry), TRUE);
 
1306
        gtk_editable_set_position (GTK_EDITABLE (entry), 1);
 
1307
}
 
1308
 
 
1309
static void
 
1310
menu_away (GtkCheckMenuItem *item, gpointer none)
 
1311
{
 
1312
        handle_command (current_sess, item->active ? "away" : "back", FALSE);
 
1313
}
 
1314
 
 
1315
static void
 
1316
menu_chanlist (GtkWidget * wid, gpointer none)
 
1317
{
 
1318
        chanlist_opengui (current_sess->server, FALSE);
 
1319
}
 
1320
 
 
1321
static void
 
1322
menu_banlist (GtkWidget * wid, gpointer none)
 
1323
{
 
1324
        banlist_opengui (current_sess);
 
1325
}
 
1326
 
 
1327
#ifdef USE_PLUGIN
 
1328
 
 
1329
static void
 
1330
menu_loadplugin (void)
 
1331
{
 
1332
        plugingui_load ();
 
1333
}
 
1334
 
 
1335
static void
 
1336
menu_pluginlist (void)
 
1337
{
 
1338
        plugingui_open ();
 
1339
}
 
1340
 
 
1341
#else
 
1342
 
 
1343
#define menu_pluginlist 0
 
1344
#define menu_loadplugin 0
 
1345
 
 
1346
#endif
 
1347
 
 
1348
#define usercommands_help  _("User Commands - Special codes:\n\n"\
 
1349
                           "%c  =  current channel\n"\
 
1350
                                                                        "%e  =  current network name\n"\
 
1351
                                                                        "%m  =  machine info\n"\
 
1352
                           "%n  =  your nick\n"\
 
1353
                                                                        "%t  =  time/date\n"\
 
1354
                           "%v  =  xchat version\n"\
 
1355
                           "%2  =  word 2\n"\
 
1356
                           "%3  =  word 3\n"\
 
1357
                           "&2  =  word 2 to the end of line\n"\
 
1358
                           "&3  =  word 3 to the end of line\n\n"\
 
1359
                           "eg:\n"\
 
1360
                           "/cmd john hello\n\n"\
 
1361
                           "%2 would be \042john\042\n"\
 
1362
                           "&2 would be \042john hello\042.")
 
1363
 
 
1364
#define ulbutton_help       _("Userlist Buttons - Special codes:\n\n"\
 
1365
                           "%a  =  all selected nicks\n"\
 
1366
                           "%c  =  current channel\n"\
 
1367
                                                                        "%e  =  current network name\n"\
 
1368
                           "%h  =  selected nick's hostname\n"\
 
1369
                                                                        "%m  =  machine info\n"\
 
1370
                           "%n  =  your nick\n"\
 
1371
                           "%s  =  selected nick\n"\
 
1372
                                                                        "%t  =  time/date\n")
 
1373
 
 
1374
#define dlgbutton_help      _("Dialog Buttons - Special codes:\n\n"\
 
1375
                           "%a  =  all selected nicks\n"\
 
1376
                           "%c  =  current channel\n"\
 
1377
                                                                        "%e  =  current network name\n"\
 
1378
                           "%h  =  selected nick's hostname\n"\
 
1379
                                                                        "%m  =  machine info\n"\
 
1380
                           "%n  =  your nick\n"\
 
1381
                           "%s  =  selected nick\n"\
 
1382
                                                                        "%t  =  time/date\n")
 
1383
 
 
1384
#define ctcp_help          _("CTCP Replies - Special codes:\n\n"\
 
1385
                           "%d  =  data (the whole ctcp)\n"\
 
1386
                                                                        "%e  =  current network name\n"\
 
1387
                                                                        "%m  =  machine info\n"\
 
1388
                           "%s  =  nick who sent the ctcp\n"\
 
1389
                           "%t  =  time/date\n"\
 
1390
                           "%2  =  word 2\n"\
 
1391
                           "%3  =  word 3\n"\
 
1392
                           "&2  =  word 2 to the end of line\n"\
 
1393
                           "&3  =  word 3 to the end of line\n\n")
 
1394
 
 
1395
#define url_help           _("URL Handlers - Special codes:\n\n"\
 
1396
                           "%s  =  the URL string\n\n"\
 
1397
                           "Putting a ! infront of the command\n"\
 
1398
                           "indicates it should be sent to a\n"\
 
1399
                           "shell instead of XChat")
 
1400
 
 
1401
static void
 
1402
menu_usercommands (void)
 
1403
{
 
1404
        editlist_gui_open (NULL, NULL, command_list, _("XChat: User Defined Commands"),
 
1405
                                                         "commands", "commands.conf", usercommands_help);
 
1406
}
 
1407
 
 
1408
static void
 
1409
menu_ulpopup (void)
 
1410
{
 
1411
        editlist_gui_open (NULL, NULL, popup_list, _("XChat: Userlist Popup menu"), "popup",
 
1412
                                                         "popup.conf", ulbutton_help);
 
1413
}
 
1414
 
 
1415
static void
 
1416
menu_rpopup (void)
 
1417
{
 
1418
        editlist_gui_open (_("Text"), _("Replace with"), replace_list, _("XChat: Replace"), "replace",
 
1419
                                                         "replace.conf", 0);
 
1420
}
 
1421
 
 
1422
static void
 
1423
menu_urlhandlers (void)
 
1424
{
 
1425
        editlist_gui_open (NULL, NULL, urlhandler_list, _("XChat: URL Handlers"), "urlhandlers",
 
1426
                                                         "urlhandlers.conf", url_help);
 
1427
}
 
1428
 
 
1429
static void
 
1430
menu_evtpopup (void)
 
1431
{
 
1432
        pevent_dialog_show ();
 
1433
}
 
1434
 
 
1435
static void
 
1436
menu_keypopup (void)
 
1437
{
 
1438
        key_dialog_show ();
 
1439
}
 
1440
 
 
1441
static void
 
1442
menu_ulbuttons (void)
 
1443
{
 
1444
        editlist_gui_open (NULL, NULL, button_list, _("XChat: Userlist buttons"), "buttons",
 
1445
                                                         "buttons.conf", ulbutton_help);
 
1446
}
 
1447
 
 
1448
static void
 
1449
menu_dlgbuttons (void)
 
1450
{
 
1451
        editlist_gui_open (NULL, NULL, dlgbutton_list, _("XChat: Dialog buttons"), "dlgbuttons",
 
1452
                                                         "dlgbuttons.conf", dlgbutton_help);
 
1453
}
 
1454
 
 
1455
static void
 
1456
menu_ctcpguiopen (void)
 
1457
{
 
1458
        editlist_gui_open (NULL, NULL, ctcp_list, _("XChat: CTCP Replies"), "ctcpreply",
 
1459
                                                         "ctcpreply.conf", ctcp_help);
 
1460
}
 
1461
 
 
1462
static void
 
1463
menu_docs (GtkWidget *wid, gpointer none)
 
1464
{
 
1465
        fe_open_url ("http://xchat.org/docs/");
 
1466
}
 
1467
 
 
1468
/*static void
 
1469
menu_webpage (GtkWidget *wid, gpointer none)
 
1470
{
 
1471
        fe_open_url ("http://xchat.org");
 
1472
}*/
 
1473
 
 
1474
static void
 
1475
menu_dcc_win (GtkWidget *wid, gpointer none)
 
1476
{
 
1477
        fe_dcc_open_recv_win (FALSE);
 
1478
        fe_dcc_open_send_win (FALSE);
 
1479
}
 
1480
 
 
1481
static void
 
1482
menu_dcc_chat_win (GtkWidget *wid, gpointer none)
 
1483
{
 
1484
        fe_dcc_open_chat_win (FALSE);
 
1485
}
 
1486
 
 
1487
void
 
1488
menu_change_layout (void)
 
1489
{
 
1490
        if (prefs.tab_layout == 0)
 
1491
        {
 
1492
                menu_setting_foreach (NULL, MENU_ID_LAYOUT_TABS, 1);
 
1493
                menu_setting_foreach (NULL, MENU_ID_LAYOUT_TREE, 0);
 
1494
                mg_change_layout (0);
 
1495
        } else
 
1496
        {
 
1497
                menu_setting_foreach (NULL, MENU_ID_LAYOUT_TABS, 0);
 
1498
                menu_setting_foreach (NULL, MENU_ID_LAYOUT_TREE, 1);
 
1499
                mg_change_layout (2);
 
1500
        }
 
1501
}
 
1502
 
 
1503
static void
 
1504
menu_layout_cb (GtkWidget *item, gpointer none)
 
1505
{
 
1506
        prefs.tab_layout = 2;
 
1507
        if (GTK_CHECK_MENU_ITEM (item)->active)
 
1508
                prefs.tab_layout = 0;
 
1509
 
 
1510
        menu_change_layout ();
 
1511
}
 
1512
 
 
1513
static void
 
1514
menu_apply_metres_cb (session *sess)
 
1515
{
 
1516
        mg_update_meters (sess->gui);
 
1517
}
 
1518
 
 
1519
static void
 
1520
menu_metres_off (GtkWidget *item, gpointer none)
 
1521
{
 
1522
        if (GTK_CHECK_MENU_ITEM (item)->active)
 
1523
        {
 
1524
                prefs.lagometer = 0;
 
1525
                prefs.throttlemeter = 0;
 
1526
                menu_setting_foreach (menu_apply_metres_cb, -1, 0);
 
1527
        }
 
1528
}
 
1529
 
 
1530
static void
 
1531
menu_metres_text (GtkWidget *item, gpointer none)
 
1532
{
 
1533
        if (GTK_CHECK_MENU_ITEM (item)->active)
 
1534
        {
 
1535
                prefs.lagometer = 2;
 
1536
                prefs.throttlemeter = 2;
 
1537
                menu_setting_foreach (menu_apply_metres_cb, -1, 0);
 
1538
        }
 
1539
}
 
1540
 
 
1541
static void
 
1542
menu_metres_graph (GtkWidget *item, gpointer none)
 
1543
{
 
1544
        if (GTK_CHECK_MENU_ITEM (item)->active)
 
1545
        {
 
1546
                prefs.lagometer = 1;
 
1547
                prefs.throttlemeter = 1;
 
1548
                menu_setting_foreach (menu_apply_metres_cb, -1, 0);
 
1549
        }
 
1550
}
 
1551
 
 
1552
static void
 
1553
menu_metres_both (GtkWidget *item, gpointer none)
 
1554
{
 
1555
        if (GTK_CHECK_MENU_ITEM (item)->active)
 
1556
        {
 
1557
                prefs.lagometer = 3;
 
1558
                prefs.throttlemeter = 3;
 
1559
                menu_setting_foreach (menu_apply_metres_cb, -1, 0);
 
1560
        }
 
1561
}
 
1562
 
 
1563
static struct mymenu mymenu[] = {
 
1564
        {N_("_XChat"), 0, 0, M_NEWMENU, 0, 0, 1},
 
1565
        {N_("Network Li_st..."), menu_open_server_list, (char *)&pix_book, M_MENUPIX, 0, 0, 1, GDK_s},
 
1566
        {0, 0, 0, M_SEP, 0, 0, 0},
 
1567
 
 
1568
        {N_("_New"), 0, GTK_STOCK_NEW, M_MENUSUB, 0, 0, 1},
 
1569
                {N_("Server Tab..."), menu_newserver_tab, 0, M_MENUITEM, 0, 0, 1, GDK_t},
 
1570
                {N_("Channel Tab..."), menu_newchannel_tab, 0, M_MENUITEM, 0, 0, 1},
 
1571
                {N_("Server Window..."), menu_newserver_window, 0, M_MENUITEM, 0, 0, 1},
 
1572
                {N_("Channel Window..."), menu_newchannel_window, 0, M_MENUITEM, 0, 0, 1},
 
1573
                {0, 0, 0, M_END, 0, 0, 0},
 
1574
        {0, 0, 0, M_SEP, 0, 0, 0},
 
1575
 
 
1576
#ifdef USE_PLUGIN
 
1577
        {N_("_Load Plugin or Script..."), menu_loadplugin, GTK_STOCK_REVERT_TO_SAVED, M_MENUSTOCK, 0, 0, 1},
 
1578
#else
 
1579
        {N_("_Load Plugin or Script..."), 0, GTK_STOCK_REVERT_TO_SAVED, M_MENUSTOCK, 0, 0, 0},
 
1580
#endif
 
1581
        {0, 0, 0, M_SEP, 0, 0, 0},      /* 11 */
 
1582
#define DETACH_OFFSET (12)
 
1583
        {0, menu_detach, GTK_STOCK_REDO, M_MENUSTOCK, 0, 0, 1, GDK_I},  /* 12 */
 
1584
#define CLOSE_OFFSET (13)
 
1585
        {0, menu_close, GTK_STOCK_CLOSE, M_MENUSTOCK, 0, 0, 1, GDK_w},
 
1586
        {0, 0, 0, M_SEP, 0, 0, 0},
 
1587
        {N_("_Quit"), menu_quit, GTK_STOCK_QUIT, M_MENUSTOCK, 0, 0, 1, GDK_q},  /* 15 */
 
1588
 
 
1589
        {N_("_View"), 0, 0, M_NEWMENU, 0, 0, 1},
 
1590
#define MENUBAR_OFFSET (17)
 
1591
        {N_("_Menu Bar"), menu_bar_toggle_cb, 0, M_MENUTOG, MENU_ID_MENUBAR, 0, 1, GDK_F9},
 
1592
        {N_("_Topic Bar"), menu_topicbar_toggle, 0, M_MENUTOG, MENU_ID_TOPICBAR, 0, 1},
 
1593
        {N_("_User List"), menu_userlist_toggle, 0, M_MENUTOG, MENU_ID_USERLIST, 0, 1, GDK_F7},
 
1594
        {N_("U_serlist Buttons"), menu_ulbuttons_toggle, 0, M_MENUTOG, MENU_ID_ULBUTTONS, 0, 1},
 
1595
        {N_("M_ode Buttons"), menu_cmbuttons_toggle, 0, M_MENUTOG, MENU_ID_MODEBUTTONS, 0, 1},
 
1596
        {0, 0, 0, M_SEP, 0, 0, 0},
 
1597
        {N_("_Channel Switcher"), 0, 0, M_MENUSUB, 0, 0, 1},    /* 23 */
 
1598
#define TABS_OFFSET (24)
 
1599
                {N_("_Tabs"), menu_layout_cb, 0, M_MENURADIO, MENU_ID_LAYOUT_TABS, 0, 1},
 
1600
                {N_("T_ree"), 0, 0, M_MENURADIO, MENU_ID_LAYOUT_TREE, 0, 1},
 
1601
                {0, 0, 0, M_END, 0, 0, 0},
 
1602
        {N_("_Network Meters"), 0, 0, M_MENUSUB, 0, 0, 1},      /* 27 */
 
1603
#define METRE_OFFSET (28)
 
1604
                {N_("Off"), menu_metres_off, 0, M_MENURADIO, 0, 0, 1},
 
1605
                {N_("Graph"), menu_metres_graph, 0, M_MENURADIO, 0, 0, 1},
 
1606
                {N_("Text"), menu_metres_text, 0, M_MENURADIO, 0, 0, 1},
 
1607
                {N_("Both"), menu_metres_both, 0, M_MENURADIO, 0, 0, 1},
 
1608
                {0, 0, 0, M_END, 0, 0, 0},      /* 32 */
 
1609
 
 
1610
        {N_("_Server"), 0, 0, M_NEWMENU, 0, 0, 1},
 
1611
        {N_("_Disconnect"), menu_disconnect, GTK_STOCK_DISCONNECT, M_MENUSTOCK, MENU_ID_DISCONNECT, 0, 1},
 
1612
        {N_("_Reconnect"), menu_reconnect, GTK_STOCK_CONNECT, M_MENUSTOCK, MENU_ID_RECONNECT, 0, 1},
 
1613
        {N_("Join a Channel..."), menu_join, GTK_STOCK_JUMP_TO, M_MENUSTOCK, MENU_ID_JOIN, 0, 1},
 
1614
        {N_("List of Channels..."), menu_chanlist, GTK_STOCK_INDEX, M_MENUITEM, 0, 0, 1},
 
1615
        {0, 0, 0, M_SEP, 0, 0, 0},
 
1616
#define AWAY_OFFSET (39)
 
1617
        {N_("Marked Away"), menu_away, 0, M_MENUTOG, MENU_ID_AWAY, 0, 1, GDK_a},
 
1618
 
 
1619
        {N_("_Usermenu"), 0, 0, M_NEWMENU, MENU_ID_USERMENU, 0, 1},     /* 40 */
 
1620
 
 
1621
        {N_("S_ettings"), 0, 0, M_NEWMENU, 0, 0, 1},
 
1622
        {N_("_Preferences"), menu_settings, GTK_STOCK_PREFERENCES, M_MENUSTOCK, 0, 0, 1},
 
1623
 
 
1624
        {N_("Advanced"), 0, GTK_STOCK_JUSTIFY_LEFT, M_MENUSUB, 0, 0, 1},
 
1625
                {N_("Auto Replace..."), menu_rpopup, 0, M_MENUITEM, 0, 0, 1},
 
1626
                {N_("CTCP Replies..."), menu_ctcpguiopen, 0, M_MENUITEM, 0, 0, 1},
 
1627
                {N_("Dialog Buttons..."), menu_dlgbuttons, 0, M_MENUITEM, 0, 0, 1},
 
1628
                {N_("Keyboard Shortcuts..."), menu_keypopup, 0, M_MENUITEM, 0, 0, 1},
 
1629
                {N_("Text Events..."), menu_evtpopup, 0, M_MENUITEM, 0, 0, 1},
 
1630
                {N_("URL Handlers..."), menu_urlhandlers, 0, M_MENUITEM, 0, 0, 1},
 
1631
                {N_("User Commands..."), menu_usercommands, 0, M_MENUITEM, 0, 0, 1},
 
1632
                {N_("Userlist Buttons..."), menu_ulbuttons, 0, M_MENUITEM, 0, 0, 1},
 
1633
                {N_("Userlist Popup..."), menu_ulpopup, 0, M_MENUITEM, 0, 0, 1},
 
1634
                {0, 0, 0, M_END, 0, 0, 0},              /* 53 */
 
1635
 
 
1636
        {N_("_Window"), 0, 0, M_NEWMENU, 0, 0, 1},
 
1637
        {N_("Ban List..."), menu_banlist, 0, M_MENUITEM, 0, 0, 1},
 
1638
        {N_("Character Chart..."), ascii_open, 0, M_MENUITEM, 0, 0, 1},
 
1639
        {N_("Direct Chat..."), menu_dcc_chat_win, 0, M_MENUITEM, 0, 0, 1},
 
1640
        {N_("File Transfers..."), menu_dcc_win, 0, M_MENUITEM, 0, 0, 1},
 
1641
        {N_("Friends List..."), notify_opengui, 0, M_MENUITEM, 0, 0, 1},
 
1642
        {N_("Ignore List..."), ignore_gui_open, 0, M_MENUITEM, 0, 0, 1},
 
1643
        {N_("Plugins and Scripts..."), menu_pluginlist, 0, M_MENUITEM, 0, 0, 1},
 
1644
        {N_("Raw Log..."), menu_rawlog, 0, M_MENUITEM, 0, 0, 1},        /* 62 */
 
1645
        {N_("URL Grabber..."), url_opengui, 0, M_MENUITEM, 0, 0, 1},
 
1646
        {0, 0, 0, M_SEP, 0, 0, 0},
 
1647
        {N_("Reset Marker Line"), menu_resetmarker, 0, M_MENUITEM, 0, 0, 1, GDK_m},
 
1648
        {N_("C_lear Text"), menu_flushbuffer, GTK_STOCK_CLEAR, M_MENUSTOCK, 0, 0, 1, GDK_l},
 
1649
#define SEARCH_OFFSET 67
 
1650
        {N_("Search Text..."), menu_search, GTK_STOCK_FIND, M_MENUSTOCK, 0, 0, 1, GDK_f},
 
1651
        {N_("Save Text..."), menu_savebuffer, GTK_STOCK_SAVE, M_MENUSTOCK, 0, 0, 1},
 
1652
 
 
1653
        {N_("_Help"), 0, 0, M_NEWMENU, 0, 0, 1},        /* 69 */
 
1654
        {N_("_Contents"), menu_docs, GTK_STOCK_HELP, M_MENUSTOCK, 0, 0, 1, GDK_F1},
 
1655
#if 0
 
1656
        {N_("Check for updates"), menu_update, 0, M_MENUITEM, 0, 1},
 
1657
#endif
 
1658
        {N_("_About"), menu_about, GTK_STOCK_ABOUT, M_MENUSTOCK, 0, 0, 1},
 
1659
 
 
1660
        {0, 0, 0, M_END, 0, 0, 0},
 
1661
};
 
1662
 
 
1663
GtkWidget *
 
1664
create_icon_menu (char *labeltext, void *stock_name, int is_stock)
 
1665
{
 
1666
        GtkWidget *item, *img;
 
1667
 
 
1668
        if (is_stock)
 
1669
                img = gtk_image_new_from_stock (stock_name, GTK_ICON_SIZE_MENU);
 
1670
        else
 
1671
                img = gtk_image_new_from_pixbuf (*((GdkPixbuf **)stock_name));
 
1672
        item = gtk_image_menu_item_new_with_mnemonic (labeltext);
 
1673
        gtk_image_menu_item_set_image ((GtkImageMenuItem *)item, img);
 
1674
        gtk_widget_show (img);
 
1675
 
 
1676
        return item;
 
1677
}
 
1678
 
 
1679
#if GTK_CHECK_VERSION(2,4,0)
 
1680
 
 
1681
/* Override the default GTK2.4 handler, which would make menu
 
1682
   bindings not work when the menu-bar is hidden. */
 
1683
static gboolean
 
1684
menu_canacaccel (GtkWidget *widget, guint signal_id, gpointer user_data)
 
1685
{
 
1686
        /* GTK2.2 behaviour */
 
1687
#if GTK_CHECK_VERSION(2,20,0)
 
1688
        return gtk_widget_is_sensitive (widget);
 
1689
#else
 
1690
        return GTK_WIDGET_IS_SENSITIVE (widget);
 
1691
#endif
 
1692
}
 
1693
 
 
1694
#endif
 
1695
 
 
1696
 
 
1697
/* === STUFF FOR /MENU === */
 
1698
 
 
1699
static GtkMenuItem *
 
1700
menu_find_item (GtkWidget *menu, char *name)
 
1701
{
 
1702
        GList *items = ((GtkMenuShell *) menu)->children;
 
1703
        GtkMenuItem *item;
 
1704
        GtkWidget *child;
 
1705
        const char *labeltext;
 
1706
 
 
1707
        while (items)
 
1708
        {
 
1709
                item = items->data;
 
1710
                child = GTK_BIN (item)->child;
 
1711
                if (child)      /* separators arn't labels, skip them */
 
1712
                {
 
1713
                        labeltext = g_object_get_data (G_OBJECT (item), "name");
 
1714
                        if (!labeltext)
 
1715
                                labeltext = gtk_label_get_text (GTK_LABEL (child));
 
1716
                        if (!menu_streq (labeltext, name, 1))
 
1717
                                return item;
 
1718
                } else if (name == NULL)
 
1719
                {
 
1720
                        return item;
 
1721
                }
 
1722
                items = items->next;
 
1723
        }
 
1724
 
 
1725
        return NULL;
 
1726
}
 
1727
 
 
1728
static GtkWidget *
 
1729
menu_find_path (GtkWidget *menu, char *path)
 
1730
{
 
1731
        GtkMenuItem *item;
 
1732
        char *s;
 
1733
        char name[128];
 
1734
        int len;
 
1735
 
 
1736
        /* grab the next part of the path */
 
1737
        s = strchr (path, '/');
 
1738
        len = s - path;
 
1739
        if (!s)
 
1740
                len = strlen (path);
 
1741
        len = MIN (len, sizeof (name) - 1);
 
1742
        memcpy (name, path, len);
 
1743
        name[len] = 0;
 
1744
 
 
1745
        item = menu_find_item (menu, name);
 
1746
        if (!item)
 
1747
                return NULL;
 
1748
 
 
1749
        menu = gtk_menu_item_get_submenu (item);
 
1750
        if (!menu)
 
1751
                return NULL;
 
1752
 
 
1753
        path += len;
 
1754
        if (*path == 0)
 
1755
                return menu;
 
1756
 
 
1757
        return menu_find_path (menu, path + 1);
 
1758
}
 
1759
 
 
1760
static GtkWidget *
 
1761
menu_find (GtkWidget *menu, char *path, char *label)
 
1762
{
 
1763
        GtkWidget *item = NULL;
 
1764
 
 
1765
        if (path[0] != 0)
 
1766
                menu = menu_find_path (menu, path);
 
1767
        if (menu)
 
1768
                item = (GtkWidget *)menu_find_item (menu, label);
 
1769
        return item;
 
1770
}
 
1771
 
 
1772
static void
 
1773
menu_foreach_gui (menu_entry *me, void (*callback) (GtkWidget *, menu_entry *, char *))
 
1774
{
 
1775
        GSList *list = sess_list;
 
1776
        int tabdone = FALSE;
 
1777
        session *sess;
 
1778
 
 
1779
        if (!me->is_main)
 
1780
                return; /* not main menu */
 
1781
 
 
1782
        while (list)
 
1783
        {
 
1784
                sess = list->data;
 
1785
                /* do it only once for tab sessions, since they share a GUI */
 
1786
                if (!sess->gui->is_tab || !tabdone)
 
1787
                {
 
1788
                        callback (sess->gui->menu, me, NULL);
 
1789
                        if (sess->gui->is_tab)
 
1790
                                tabdone = TRUE;
 
1791
                }
 
1792
                list = list->next;
 
1793
        }
 
1794
}
 
1795
 
 
1796
static void
 
1797
menu_update_cb (GtkWidget *menu, menu_entry *me, char *target)
 
1798
{
 
1799
        GtkWidget *item;
 
1800
 
 
1801
        item = menu_find (menu, me->path, me->label);
 
1802
        if (item)
 
1803
        {
 
1804
                gtk_widget_set_sensitive (item, me->enable);
 
1805
                /* must do it without triggering the callback */
 
1806
                if (GTK_IS_CHECK_MENU_ITEM (item))
 
1807
                        GTK_CHECK_MENU_ITEM (item)->active = me->state;
 
1808
        }
 
1809
}
 
1810
 
 
1811
/* radio state changed via mouse click */
 
1812
static void
 
1813
menu_radio_cb (GtkCheckMenuItem *item, menu_entry *me)
 
1814
{
 
1815
        me->state = 0;
 
1816
        if (item->active)
 
1817
                me->state = 1;
 
1818
 
 
1819
        /* update the state, incase this was changed via right-click. */
 
1820
        /* This will update all other windows and menu bars */
 
1821
        menu_foreach_gui (me, menu_update_cb);
 
1822
 
 
1823
        if (me->state && me->cmd)
 
1824
                handle_command (current_sess, me->cmd, FALSE);
 
1825
}
 
1826
 
 
1827
/* toggle state changed via mouse click */
 
1828
static void
 
1829
menu_toggle_cb (GtkCheckMenuItem *item, menu_entry *me)
 
1830
{
 
1831
        me->state = 0;
 
1832
        if (item->active)
 
1833
                me->state = 1;
 
1834
 
 
1835
        /* update the state, incase this was changed via right-click. */
 
1836
        /* This will update all other windows and menu bars */
 
1837
        menu_foreach_gui (me, menu_update_cb);
 
1838
 
 
1839
        if (me->state)
 
1840
                handle_command (current_sess, me->cmd, FALSE);
 
1841
        else
 
1842
                handle_command (current_sess, me->ucmd, FALSE);
 
1843
}
 
1844
 
 
1845
static GtkWidget *
 
1846
menu_radio_item (char *label, GtkWidget *menu, void *callback, void *userdata,
 
1847
                                                int state, char *groupname)
 
1848
{
 
1849
        GtkWidget *item;
 
1850
        GtkMenuItem *parent;
 
1851
        GSList *grouplist = NULL;
 
1852
 
 
1853
        parent = menu_find_item (menu, groupname);
 
1854
        if (parent)
 
1855
                grouplist = gtk_radio_menu_item_get_group ((GtkRadioMenuItem *)parent);
 
1856
 
 
1857
        item = gtk_radio_menu_item_new_with_label (grouplist, label);
 
1858
        gtk_check_menu_item_set_active ((GtkCheckMenuItem*)item, state);
 
1859
        gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
 
1860
        g_signal_connect (G_OBJECT (item), "activate",
 
1861
                                                        G_CALLBACK (callback), userdata);
 
1862
        gtk_widget_show (item);
 
1863
 
 
1864
        return item;
 
1865
}
 
1866
 
 
1867
static void
 
1868
menu_reorder (GtkMenu *menu, GtkWidget *item, int pos)
 
1869
{
 
1870
        if (pos == 0xffff)      /* outbound.c uses this default */
 
1871
                return;
 
1872
 
 
1873
        if (pos < 0)    /* position offset from end/bottom */
 
1874
                gtk_menu_reorder_child (menu, item, (g_list_length (GTK_MENU_SHELL (menu)->children) + pos) - 1);
 
1875
        else
 
1876
                gtk_menu_reorder_child (menu, item, pos);
 
1877
}
 
1878
 
 
1879
static GtkWidget *
 
1880
menu_add_radio (GtkWidget *menu, menu_entry *me)
 
1881
{
 
1882
        GtkWidget *item = NULL;
 
1883
        char *path = me->path + me->root_offset;
 
1884
 
 
1885
        if (path[0] != 0)
 
1886
                menu = menu_find_path (menu, path);
 
1887
        if (menu)
 
1888
        {
 
1889
                item = menu_radio_item (me->label, menu, menu_radio_cb, me, me->state, me->group);
 
1890
                menu_reorder (GTK_MENU (menu), item, me->pos);
 
1891
        }
 
1892
        return item;
 
1893
}
 
1894
 
 
1895
static GtkWidget *
 
1896
menu_add_toggle (GtkWidget *menu, menu_entry *me)
 
1897
{
 
1898
        GtkWidget *item = NULL;
 
1899
        char *path = me->path + me->root_offset;
 
1900
 
 
1901
        if (path[0] != 0)
 
1902
                menu = menu_find_path (menu, path);
 
1903
        if (menu)
 
1904
        {
 
1905
                item = menu_toggle_item (me->label, menu, menu_toggle_cb, me, me->state);
 
1906
                menu_reorder (GTK_MENU (menu), item, me->pos);
 
1907
        }
 
1908
        return item;
 
1909
}
 
1910
 
 
1911
static GtkWidget *
 
1912
menu_add_item (GtkWidget *menu, menu_entry *me, char *target)
 
1913
{
 
1914
        GtkWidget *item = NULL;
 
1915
        char *path = me->path + me->root_offset;
 
1916
 
 
1917
        if (path[0] != 0)
 
1918
                menu = menu_find_path (menu, path);
 
1919
        if (menu)
 
1920
        {
 
1921
                item = menu_quick_item (me->cmd, me->label, menu, me->markup ? XCMENU_MARKUP|XCMENU_MNEMONIC : XCMENU_MNEMONIC, target, me->icon);
 
1922
                menu_reorder (GTK_MENU (menu), item, me->pos);
 
1923
        }
 
1924
        return item;
 
1925
}
 
1926
 
 
1927
static GtkWidget *
 
1928
menu_add_sub (GtkWidget *menu, menu_entry *me)
 
1929
{
 
1930
        GtkWidget *item = NULL;
 
1931
        char *path = me->path + me->root_offset;
 
1932
        int pos;
 
1933
 
 
1934
        if (path[0] != 0)
 
1935
                menu = menu_find_path (menu, path);
 
1936
        if (menu)
 
1937
        {
 
1938
                pos = me->pos;
 
1939
                if (pos < 0)    /* position offset from end/bottom */
 
1940
                        pos = g_list_length (GTK_MENU_SHELL (menu)->children) + pos;
 
1941
                menu_quick_sub (me->label, menu, &item, me->markup ? XCMENU_MARKUP|XCMENU_MNEMONIC : XCMENU_MNEMONIC, pos);
 
1942
        }
 
1943
        return item;
 
1944
}
 
1945
 
 
1946
static void
 
1947
menu_del_cb (GtkWidget *menu, menu_entry *me, char *target)
 
1948
{
 
1949
        GtkWidget *item = menu_find (menu, me->path + me->root_offset, me->label);
 
1950
        if (item)
 
1951
                gtk_widget_destroy (item);
 
1952
}
 
1953
 
 
1954
static void
 
1955
menu_add_cb (GtkWidget *menu, menu_entry *me, char *target)
 
1956
{
 
1957
        GtkWidget *item;
 
1958
        GtkAccelGroup *accel_group;
 
1959
 
 
1960
        if (me->group)  /* have a group name? Must be a radio item */
 
1961
                item = menu_add_radio (menu, me);
 
1962
        else if (me->ucmd)      /* have unselect-cmd? Must be a toggle item */
 
1963
                item = menu_add_toggle (menu, me);
 
1964
        else if (me->cmd || !me->label) /* label=NULL for separators */
 
1965
                item = menu_add_item (menu, me, target);
 
1966
        else
 
1967
                item = menu_add_sub (menu, me);
 
1968
 
 
1969
        if (item)
 
1970
        {
 
1971
                gtk_widget_set_sensitive (item, me->enable);
 
1972
                if (me->key)
 
1973
                {
 
1974
                        accel_group = g_object_get_data (G_OBJECT (menu), "accel");
 
1975
                        if (accel_group)        /* popup menus don't have them */
 
1976
                                gtk_widget_add_accelerator (item, "activate", accel_group, me->key,
 
1977
                                                                                                         me->modifier, GTK_ACCEL_VISIBLE);
 
1978
                }
 
1979
        }
 
1980
}
 
1981
 
 
1982
char *
 
1983
fe_menu_add (menu_entry *me)
 
1984
{
 
1985
        char *text;
 
1986
 
 
1987
        menu_foreach_gui (me, menu_add_cb);
 
1988
 
 
1989
        if (!me->markup)
 
1990
                return NULL;
 
1991
 
 
1992
        if (!pango_parse_markup (me->label, -1, 0, NULL, &text, NULL, NULL))
 
1993
                return NULL;
 
1994
 
 
1995
        /* return the label with markup stripped */
 
1996
        return text;
 
1997
}
 
1998
 
 
1999
void
 
2000
fe_menu_del (menu_entry *me)
 
2001
{
 
2002
        menu_foreach_gui (me, menu_del_cb);
 
2003
}
 
2004
 
 
2005
void
 
2006
fe_menu_update (menu_entry *me)
 
2007
{
 
2008
        menu_foreach_gui (me, menu_update_cb);
 
2009
}
 
2010
 
 
2011
/* used to add custom menus to the right-click menu */
 
2012
 
 
2013
static void
 
2014
menu_add_plugin_mainmenu_items (GtkWidget *menu)
 
2015
{
 
2016
        GSList *list;
 
2017
        menu_entry *me;
 
2018
 
 
2019
        list = menu_list;       /* outbound.c */
 
2020
        while (list)
 
2021
        {
 
2022
                me = list->data;
 
2023
                if (me->is_main)
 
2024
                        menu_add_cb (menu, me, NULL);
 
2025
                list = list->next;
 
2026
        }
 
2027
}
 
2028
 
 
2029
void
 
2030
menu_add_plugin_items (GtkWidget *menu, char *root, char *target)
 
2031
{
 
2032
        GSList *list;
 
2033
        menu_entry *me;
 
2034
 
 
2035
        list = menu_list;       /* outbound.c */
 
2036
        while (list)
 
2037
        {
 
2038
                me = list->data;
 
2039
                if (!me->is_main && !strncmp (me->path, root + 1, root[0]))
 
2040
                        menu_add_cb (menu, me, target);
 
2041
                list = list->next;
 
2042
        }
 
2043
}
 
2044
 
 
2045
/* === END STUFF FOR /MENU === */
 
2046
 
 
2047
GtkWidget *
 
2048
menu_create_main (void *accel_group, int bar, int away, int toplevel,
 
2049
                                                GtkWidget **menu_widgets)
 
2050
{
 
2051
        int i = 0;
 
2052
        GtkWidget *item;
 
2053
        GtkWidget *menu = 0;
 
2054
        GtkWidget *menu_item = 0;
 
2055
        GtkWidget *menu_bar;
 
2056
        GtkWidget *usermenu = 0;
 
2057
        GtkWidget *submenu = 0;
 
2058
        int close_mask = GDK_CONTROL_MASK;
 
2059
        int away_mask = GDK_MOD1_MASK;
 
2060
        char *key_theme = NULL;
 
2061
        GtkSettings *settings;
 
2062
        GSList *group = NULL;
 
2063
 
 
2064
        if (bar)
 
2065
                menu_bar = gtk_menu_bar_new ();
 
2066
        else
 
2067
                menu_bar = gtk_menu_new ();
 
2068
 
 
2069
        /* /MENU needs to know this later */
 
2070
        g_object_set_data (G_OBJECT (menu_bar), "accel", accel_group);
 
2071
 
 
2072
#if GTK_CHECK_VERSION(2,4,0)
 
2073
        g_signal_connect (G_OBJECT (menu_bar), "can-activate-accel",
 
2074
                                                        G_CALLBACK (menu_canacaccel), 0);
 
2075
#endif
 
2076
 
 
2077
        /* set the initial state of toggles */
 
2078
        mymenu[MENUBAR_OFFSET].state = !prefs.hidemenu;
 
2079
        mymenu[MENUBAR_OFFSET+1].state = prefs.topicbar;
 
2080
        mymenu[MENUBAR_OFFSET+2].state = !prefs.hideuserlist;
 
2081
        mymenu[MENUBAR_OFFSET+3].state = prefs.userlistbuttons;
 
2082
        mymenu[MENUBAR_OFFSET+4].state = prefs.chanmodebuttons;
 
2083
 
 
2084
        mymenu[AWAY_OFFSET].state = away;
 
2085
 
 
2086
        switch (prefs.tab_layout)
 
2087
        {
 
2088
        case 0:
 
2089
                mymenu[TABS_OFFSET].state = 1;
 
2090
                mymenu[TABS_OFFSET+1].state = 0;
 
2091
                break;
 
2092
        default:
 
2093
                mymenu[TABS_OFFSET].state = 0;
 
2094
                mymenu[TABS_OFFSET+1].state = 1;
 
2095
        }
 
2096
 
 
2097
        mymenu[METRE_OFFSET].state = 0;
 
2098
        mymenu[METRE_OFFSET+1].state = 0;
 
2099
        mymenu[METRE_OFFSET+2].state = 0;
 
2100
        mymenu[METRE_OFFSET+3].state = 0;
 
2101
        switch (prefs.lagometer)
 
2102
        {
 
2103
        case 0:
 
2104
                mymenu[METRE_OFFSET].state = 1;
 
2105
                break;
 
2106
        case 1:
 
2107
                mymenu[METRE_OFFSET+1].state = 1;
 
2108
                break;
 
2109
        case 2:
 
2110
                mymenu[METRE_OFFSET+2].state = 1;
 
2111
                break;
 
2112
        default:
 
2113
                mymenu[METRE_OFFSET+3].state = 1;
 
2114
        }
 
2115
 
 
2116
        /* change Close binding to ctrl-shift-w when using emacs keys */
 
2117
        settings = gtk_widget_get_settings (menu_bar);
 
2118
        if (settings)
 
2119
        {
 
2120
                g_object_get (settings, "gtk-key-theme-name", &key_theme, NULL);
 
2121
                if (key_theme)
 
2122
                {
 
2123
                        if (!strcasecmp (key_theme, "Emacs"))
 
2124
                        {
 
2125
                                close_mask = GDK_SHIFT_MASK | GDK_CONTROL_MASK;
 
2126
                                mymenu[SEARCH_OFFSET].key = 0;
 
2127
                        }
 
2128
                        g_free (key_theme);
 
2129
                }
 
2130
        }
 
2131
 
 
2132
        /* Away binding to ctrl-alt-a if the _Help menu conflicts (FR/PT/IT) */
 
2133
        {
 
2134
                char *help = _("_Help");
 
2135
                char *under = strchr (help, '_');
 
2136
                if (under && (under[1] == 'a' || under[1] == 'A'))
 
2137
                        away_mask = GDK_MOD1_MASK | GDK_CONTROL_MASK;
 
2138
        }
 
2139
 
 
2140
        if (!toplevel)
 
2141
        {
 
2142
                mymenu[DETACH_OFFSET].text = N_("_Detach");
 
2143
                mymenu[CLOSE_OFFSET].text = N_("_Close");
 
2144
        }
 
2145
        else
 
2146
        {
 
2147
                mymenu[DETACH_OFFSET].text = N_("_Attach");
 
2148
                mymenu[CLOSE_OFFSET].text = N_("_Close");
 
2149
        }
 
2150
 
 
2151
        while (1)
 
2152
        {
 
2153
                item = NULL;
 
2154
                if (mymenu[i].id == MENU_ID_USERMENU && !prefs.gui_usermenu)
 
2155
                {
 
2156
                        i++;
 
2157
                        continue;
 
2158
                }
 
2159
 
 
2160
                switch (mymenu[i].type)
 
2161
                {
 
2162
                case M_NEWMENU:
 
2163
                        if (menu)
 
2164
                                gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_item), menu);
 
2165
                        item = menu = gtk_menu_new ();
 
2166
                        if (mymenu[i].id == MENU_ID_USERMENU)
 
2167
                                usermenu = menu;
 
2168
                        menu_item = gtk_menu_item_new_with_mnemonic (_(mymenu[i].text));
 
2169
                        /* record the English name for /menu */
 
2170
                        g_object_set_data (G_OBJECT (menu_item), "name", mymenu[i].text);
 
2171
                        gtk_menu_shell_append (GTK_MENU_SHELL (menu_bar), menu_item);
 
2172
                        gtk_widget_show (menu_item);
 
2173
                        break;
 
2174
 
 
2175
                case M_MENUPIX:
 
2176
                        item = create_icon_menu (_(mymenu[i].text), mymenu[i].image, FALSE);
 
2177
                        goto normalitem;
 
2178
 
 
2179
                case M_MENUSTOCK:
 
2180
                        item = create_icon_menu (_(mymenu[i].text), mymenu[i].image, TRUE);
 
2181
                        goto normalitem;
 
2182
 
 
2183
                case M_MENUITEM:
 
2184
                        item = gtk_menu_item_new_with_mnemonic (_(mymenu[i].text));
 
2185
normalitem:
 
2186
                        if (mymenu[i].key != 0)
 
2187
                                gtk_widget_add_accelerator (item, "activate", accel_group,
 
2188
                                                                                mymenu[i].key,
 
2189
                                                                                mymenu[i].key == GDK_F1 ? 0 :
 
2190
                                                                                mymenu[i].key == GDK_w ? close_mask :
 
2191
                                                                                GDK_CONTROL_MASK,
 
2192
                                                                                GTK_ACCEL_VISIBLE);
 
2193
                        if (mymenu[i].callback)
 
2194
                                g_signal_connect (G_OBJECT (item), "activate",
 
2195
                                                                                G_CALLBACK (mymenu[i].callback), 0);
 
2196
                        if (submenu)
 
2197
                                gtk_menu_shell_append (GTK_MENU_SHELL (submenu), item);
 
2198
                        else
 
2199
                                gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
 
2200
                        gtk_widget_show (item);
 
2201
                        break;
 
2202
 
 
2203
                case M_MENUTOG:
 
2204
                        item = gtk_check_menu_item_new_with_mnemonic (_(mymenu[i].text));
 
2205
togitem:
 
2206
                        /* must avoid callback for Radio buttons */
 
2207
                        GTK_CHECK_MENU_ITEM (item)->active = mymenu[i].state;
 
2208
                        /*gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item),
 
2209
                                                                                                         mymenu[i].state);*/
 
2210
                        if (mymenu[i].key != 0)
 
2211
                                gtk_widget_add_accelerator (item, "activate", accel_group,
 
2212
                                                                        mymenu[i].key, mymenu[i].id == MENU_ID_AWAY ?
 
2213
                                                                        away_mask : GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
 
2214
                        if (mymenu[i].callback)
 
2215
                                g_signal_connect (G_OBJECT (item), "toggled",
 
2216
                                                                                G_CALLBACK (mymenu[i].callback), 0);
 
2217
                        if (submenu)
 
2218
                                gtk_menu_shell_append (GTK_MENU_SHELL (submenu), item);
 
2219
                        else
 
2220
                                gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
 
2221
                        gtk_widget_show (item);
 
2222
                        gtk_widget_set_sensitive (item, mymenu[i].sensitive);
 
2223
                        break;
 
2224
 
 
2225
                case M_MENURADIO:
 
2226
                        item = gtk_radio_menu_item_new_with_mnemonic (group, _(mymenu[i].text));
 
2227
                        group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (item));
 
2228
                        goto togitem;
 
2229
 
 
2230
                case M_SEP:
 
2231
                        item = gtk_menu_item_new ();
 
2232
                        gtk_widget_set_sensitive (item, FALSE);
 
2233
                        gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
 
2234
                        gtk_widget_show (item);
 
2235
                        break;
 
2236
 
 
2237
                case M_MENUSUB:
 
2238
                        group = NULL;
 
2239
                        submenu = gtk_menu_new ();
 
2240
                        item = create_icon_menu (_(mymenu[i].text), mymenu[i].image, TRUE);
 
2241
                        /* record the English name for /menu */
 
2242
                        g_object_set_data (G_OBJECT (item), "name", mymenu[i].text);
 
2243
                        gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), submenu);
 
2244
                        gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
 
2245
                        gtk_widget_show (item);
 
2246
                        break;
 
2247
 
 
2248
                /*case M_END:*/ default:
 
2249
                        if (!submenu)
 
2250
                        {
 
2251
                                if (menu)
 
2252
                                {
 
2253
                                        gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_item), menu);
 
2254
                                        menu_add_plugin_mainmenu_items (menu_bar);
 
2255
                                }
 
2256
                                if (usermenu)
 
2257
                                        usermenu_create (usermenu);
 
2258
                                return (menu_bar);
 
2259
                        }
 
2260
                        submenu = NULL;
 
2261
                }
 
2262
 
 
2263
                /* record this GtkWidget * so it's state might be changed later */
 
2264
                if (mymenu[i].id != 0 && menu_widgets)
 
2265
                        /* this ends up in sess->gui->menu_item[MENU_ID_XXX] */
 
2266
                        menu_widgets[mymenu[i].id] = item;
 
2267
 
 
2268
                i++;
 
2269
        }
 
2270
}