menu.c

   1 /* menu.c
   2  * Menu routines
   3  *
   4  * $Id: menu.c,v 1.10 1998/11/12 00:06:22 gram Exp $
   5  *
   6  * Ethereal - Network traffic analyzer
   7  * By Gerald Combs <gerald@zing.org>
   8  * Copyright 1998 Gerald Combs
   9  *
  10  *
  11  * This program is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU General Public License
  13  * as published by the Free Software Foundation; either version 2
  14  * of the License, or (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program; if not, write to the Free Software
  23  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  24  */
  25
  26 #ifdef HAVE_CONFIG_H
  27 # include "config.h"
  28 #endif
  29
  30 #include <glib.h>
  31
  32 #include <gtk/gtk.h>
  33 #include <pcap.h>       /* for capture.h */
  34
  35 #include <strings.h>
  36
  37 #include "menu.h"
  38 #include "ethereal.h"
  39 #include "capture.h"
  40 #include "packet.h"
  41 #include "prefs.h"
  42 #include "print.h"
  43 #include "follow.h"
  44
  45 /* Much of this was take from the GTK+ tuturial at http://www.gtk.org */
  46
  47 static void menus_remove_accel (GtkWidget *, gchar *, gchar *);
  48 static gint menus_install_accel (GtkWidget *, gchar *, gchar, gchar, gchar *);
  49
  50 /* this is the GtkMenuEntry structure used to create new menus.  The
  51  * first member is the menu definition string.  The second, the
  52  * default accelerator key used to access this menu function with
  53  * the keyboard.  The third is the callback function to call when
  54  * this menu item is selected (by the accelerator key, or with the
  55  * mouse.) The last member is the data to pass to your callback function.
  56  */
  57
  58 static GtkMenuEntry menu_items[] =
  59 {
  60   {"<Main>/File/Open", "<control>O", file_open_cmd_cb, NULL},
  61   {"<Main>/File/Close", "<control>W", file_close_cmd_cb, NULL},
  62   {"<Main>/File/Save", "<control>S", NULL, NULL},
  63   {"<Main>/File/Save as", NULL, NULL, NULL},
  64   {"<Main>/File/Reload", "<control>R", file_reload_cmd_cb, NULL},
  65   {"<Main>/File/<separator>", NULL, NULL, NULL},
  66   {"<Main>/File/Print Packet", "<control>P", file_print_cmd_cb, NULL},
  67   {"<Main>/File/<separator>", NULL, NULL, NULL},
  68   {"<Main>/File/Quit", "<control>Q", file_quit_cmd_cb, NULL},
  69   {"<Main>/Edit/Cut", "<control>X", NULL, NULL},
  70   {"<Main>/Edit/Copy", "<control>C", NULL, NULL},
  71   {"<Main>/Edit/Paste", "<control>V", NULL, NULL},
  72   {"<Main>/Edit/<separator>", NULL, NULL, NULL},
  73   {"<Main>/Edit/Find", "<control>F", NULL, NULL},
  74   {"<Main>/Edit/<separator>", NULL, NULL, NULL},
  75   {"<Main>/Edit/Preferences", NULL, prefs_cb, (gpointer) E_PR_PG_NONE},
  76   {"<Main>/Tools/Capture", "<control>K", capture_prep_cb, NULL},
  77   {"<Main>/Tools/Follow TCP Stream", NULL, follow_stream_cb, NULL},
  78   {"<Main>/Tools/Graph", NULL, NULL, NULL},
  79   {"<Main>/Help/About Ethereal", NULL, about_ethereal, NULL}
  80 };
  81
  82 /* calculate the number of menu_items */
  83 static int nmenu_items = sizeof(menu_items) / sizeof(menu_items[0]);
  84
  85 static int initialize = TRUE;
  86 static GtkMenuFactory *factory = NULL;
  87 static GtkMenuFactory *subfactory[1];
  88 static GHashTable *entry_ht = NULL;
  89
  90 void
  91 get_main_menu(GtkWidget ** menubar, GtkAcceleratorTable ** table) {
  92   if (initialize)
  93     menus_init();
  94
  95   if (menubar)
  96     *menubar = subfactory[0]->widget;
  97   if (table)
  98     *table = subfactory[0]->table;
  99 }
 100
 101 void
 102 menus_init(void) {
 103   GtkMenuPath *mp;
 104
 105   if (initialize) {
 106     initialize = FALSE;
 107
 108     factory = gtk_menu_factory_new(GTK_MENU_FACTORY_MENU_BAR);
 109     subfactory[0] = gtk_menu_factory_new(GTK_MENU_FACTORY_MENU_BAR);
 110
 111     gtk_menu_factory_add_subfactory(factory, subfactory[0], "<Main>");
 112     menus_create(menu_items, nmenu_items);
 113
 114     set_menu_sensitivity("<Main>/File/Close", FALSE);
 115     set_menu_sensitivity("<Main>/File/Save", FALSE);
 116     set_menu_sensitivity("<Main>/File/Save as", FALSE);
 117     set_menu_sensitivity("<Main>/File/Reload", FALSE);
 118     set_menu_sensitivity("<Main>/Edit/Cut", FALSE);
 119     set_menu_sensitivity("<Main>/Edit/Copy", FALSE);
 120     set_menu_sensitivity("<Main>/Edit/Paste", FALSE);
 121     set_menu_sensitivity("<Main>/Edit/Find", FALSE);
 122     set_menu_sensitivity("<Main>/Tools/Graph", FALSE);
 123     if ((mp = gtk_menu_factory_find(factory, "<Main>/Help")) != NULL) {
 124       gtk_menu_item_right_justify((GtkMenuItem *) mp->widget);
 125     }
 126   }
 127 }
 128
 129 void
 130 set_menu_sensitivity (gchar *path, gint val) {
 131   GtkMenuPath *mp;
 132
 133   if ((mp = gtk_menu_factory_find(factory, path)) != NULL)
 134     gtk_widget_set_sensitive(mp->widget, val);
 135 }
 136
 137 void
 138 set_menu_object_data (gchar *path, gchar *key, gpointer data) {
 139   GtkMenuPath *mp;
 140
 141   if ((mp = gtk_menu_factory_find(factory, path)) != NULL)
 142     gtk_object_set_data(GTK_OBJECT(mp->widget), key, data);
 143 }
 144
 145 void
 146 menus_create(GtkMenuEntry * entries, int nmenu_entries) {
 147   char *accelerator;
 148   int i;
 149
 150   if (initialize)
 151     menus_init();
 152
 153   if (entry_ht)
 154     for (i = 0; i < nmenu_entries; i++) {
 155       accelerator = g_hash_table_lookup(entry_ht, entries[i].path);
 156       if (accelerator) {
 157         if (accelerator[0] == '\0')
 158           entries[i].accelerator = NULL;
 159         else
 160           entries[i].accelerator = accelerator;
 161       }
 162     }
 163   gtk_menu_factory_add_entries(factory, entries, nmenu_entries);
 164
 165   for (i = 0; i < nmenu_entries; i++)
 166     if (entries[i].widget) {
 167       gtk_signal_connect(GTK_OBJECT(entries[i].widget), "install_accelerator",
 168          (GtkSignalFunc) menus_install_accel, entries[i].path);
 169       gtk_signal_connect(GTK_OBJECT(entries[i].widget), "remove_accelerator",
 170         (GtkSignalFunc) menus_remove_accel, entries[i].path);
 171   }
 172 }
 173
 174 static gint
 175 menus_install_accel(GtkWidget * widget, gchar * signal_name, gchar key, gchar modifiers, gchar * path) {
 176   char accel[64];
 177   char *t1, t2[2];
 178
 179   accel[0] = '\0';
 180   if (modifiers & GDK_CONTROL_MASK)
 181     strcat(accel, "<control>");
 182   if (modifiers & GDK_SHIFT_MASK)
 183     strcat(accel, "<shift>");
 184   if (modifiers & GDK_MOD1_MASK)
 185     strcat(accel, "<alt>");
 186
 187   t2[0] = key;
 188   t2[1] = '\0';
 189   strcat(accel, t2);
 190
 191   if (entry_ht) {
 192     t1 = g_hash_table_lookup(entry_ht, path);
 193     g_free(t1);
 194   } else
 195     entry_ht = g_hash_table_new(g_str_hash, g_str_equal);
 196
 197   g_hash_table_insert(entry_ht, path, g_strdup(accel));
 198
 199   return TRUE;
 200 }
 201
 202 static void
 203 menus_remove_accel(GtkWidget * widget, gchar * signal_name, gchar * path) {
 204   char *t;
 205
 206   if (entry_ht) {
 207     t = g_hash_table_lookup(entry_ht, path);
 208     g_free(t);
 209
 210     g_hash_table_insert(entry_ht, path, g_strdup(""));
 211   }
 212 }
 213
 214 void
 215 menus_set_sensitive(char *path, int sensitive) {
 216   GtkMenuPath *menu_path;
 217
 218   if (initialize)
 219     menus_init();
 220
 221   menu_path = gtk_menu_factory_find(factory, path);
 222   if (menu_path)
 223     gtk_widget_set_sensitive(menu_path->widget, sensitive);
 224   else
 225     g_warning("Unable to set sensitivity for menu which doesn't exist: %s", path);
 226 }