ui/gtk/funnel_stat.c

   1 /*
   2  * funnel_stat.c
   3  *
   4  * EPAN's funneled GUI mini-API
   5  *
   6  * (c) 2006, Luis E. Garcia Ontanon <luis@ontanon.org>
   7  *
   8  * $Id$
   9  *
  10  * Wireshark - Network traffic analyzer
  11  * By Gerald Combs <gerald@wireshark.org>
  12  * Copyright 1998 Gerald Combs
  13  *
  14  * This program is free software; you can redistribute it and/or
  15  * modify it under the terms of the GNU General Public License
  16  * as published by the Free Software Foundation; either version 2
  17  * of the License, or (at your option) any later version.
  18  *
  19  * This program is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  * GNU General Public License for more details.
  23  *
  24  * You should have received a copy of the GNU General Public License
  25  * along with this program; if not, write to the Free Software
  26  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  27  */
  28
  29 /*
  30  * Most of the code here has been harvested from other Wireshark gtk modules.
  31  * most from prefs_dlg.c and about_dlg.c
  32  *
  33  * (From original checkin message:
  34  * The funneled GUI mini API.
  35  * A very reduced set of gui ops (by now just a text window)
  36  * that can be funneled to dissectors (even plugins) via epan.
  37  */
  38
  39 #include "config.h"
  40
  41 #include <stdio.h>
  42 #include <string.h>
  43
  44 #include <gtk/gtk.h>
  45
  46 #include <epan/prefs.h>
  47 #include <epan/funnel.h>
  48
  49 #include "../file.h"
  50 #include "../stat_menu.h"
  51 #include "ui/progress_dlg.h"
  52 #include "../color_filters.h"
  53
  54 #include "ui/gtk/gui_utils.h"
  55 #include "ui/gtk/dlg_utils.h"
  56 #include "ui/gtk/tap_param_dlg.h"
  57 #include "ui/gtk/font_utils.h"
  58 #include "ui/gtk/gui_stat_menu.h"
  59 #include "ui/gtk/prefs_dlg.h"
  60 #include "ui/gtk/main.h"
  61 #include "ui/gtk/webbrowser.h"
  62 #include "ui/gtk/gtkglobals.h"
  63 #include "ui/gtk/old-gtk-compat.h"
  64
  65 void register_tap_listener_gtkfunnel(void);
  66
  67 struct _funnel_text_window_t {
  68     GtkWidget* win;
  69     GtkWidget* txt;
  70     GtkWidget* button_hbox;
  71     GtkWidget* bt_close;
  72     text_win_close_cb_t close_cb;
  73     void* close_data;
  74     GPtrArray* buttons;
  75 };
  76
  77 struct _funnel_tree_window_t {
  78     GtkWidget *win;
  79
  80 };
  81
  82 struct _funnel_node_t {
  83     void* dummy;
  84 };
  85
  86 static void text_window_cancel_button_cb(GtkWidget *bt _U_, gpointer data) {
  87     funnel_text_window_t* tw = (funnel_text_window_t *)data;
  88
  89     window_destroy(GTK_WIDGET(tw->win));
  90     tw->win = NULL;
  91
  92     if (tw->close_cb)
  93         tw->close_cb(tw->close_data);
  94 }
  95
  96 static void unref_text_win_cancel_bt_cb(GtkWidget *bt _U_, gpointer data) {
  97     funnel_text_window_t* tw = (funnel_text_window_t *)data;
  98     guint i;
  99
 100     window_destroy(GTK_WIDGET(tw->win));
 101     tw->win = NULL;
 102
 103     if (tw->close_cb)
 104         tw->close_cb(tw->close_data);
 105
 106     for (i = 0; i < tw->buttons->len; i++) {
 107         funnel_bt_t* cbd = (funnel_bt_t *)g_ptr_array_index(tw->buttons,i);
 108         /* XXX a free cb should be passed somehow */
 109         if (cbd->data && cbd->free_data_fcn) cbd->free_data_fcn(cbd->data);
 110         if (cbd->free_fcn) cbd->free_fcn(cbd);
 111     }
 112     g_ptr_array_free(tw->buttons,TRUE);
 113     g_free(tw);
 114 }
 115
 116
 117 static gboolean text_window_unref_del_event_cb(GtkWidget *win _U_, GdkEvent *event _U_, gpointer user_data) {
 118     funnel_text_window_t* tw = (funnel_text_window_t *)user_data;
 119     guint i;
 120
 121     window_destroy(GTK_WIDGET(tw->win));
 122     tw->win = NULL;
 123
 124     if (tw->close_cb)
 125         tw->close_cb(tw->close_data);
 126
 127     for (i = 0; i < tw->buttons->len; i++) {
 128         funnel_bt_t* cbd = (funnel_bt_t *)g_ptr_array_index(tw->buttons,i);
 129         /* XXX a free cb should be passed somehow */
 130         if (cbd->data && cbd->free_data_fcn) cbd->free_data_fcn(cbd->data);
 131         if (cbd->free_fcn) cbd->free_fcn(cbd);
 132     }
 133     g_ptr_array_free(tw->buttons,TRUE);
 134     g_free(tw);
 135
 136     return TRUE;
 137 }
 138
 139 static gboolean text_window_delete_event_cb(GtkWidget *win _U_, GdkEvent *event _U_, gpointer user_data)
 140 {
 141     funnel_text_window_t* tw = (funnel_text_window_t *)user_data;
 142
 143     window_destroy(GTK_WIDGET(tw->win));
 144     tw->win = NULL;
 145
 146     if (tw->close_cb)
 147         tw->close_cb(tw->close_data);
 148
 149     return TRUE;
 150 }
 151
 152 static funnel_text_window_t* new_text_window(const gchar* title) {
 153     funnel_text_window_t* tw = (funnel_text_window_t *)g_malloc(sizeof(funnel_text_window_t));
 154     GtkWidget *txt_scrollw, *main_vb, *hbox;
 155
 156     tw->close_cb = NULL;
 157     tw->close_data = NULL;
 158     tw->buttons = g_ptr_array_new();
 159
 160     tw->win = dlg_window_new(title);  /* transient_for top_level */
 161     gtk_window_set_destroy_with_parent (GTK_WINDOW(tw->win), TRUE);
 162
 163     g_signal_connect(tw->win, "delete-event", G_CALLBACK(text_window_delete_event_cb), tw);
 164
 165     txt_scrollw = scrolled_window_new(NULL, NULL);
 166     main_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 3, FALSE);
 167     gtk_container_set_border_width(GTK_CONTAINER(main_vb), 6);
 168     gtk_container_add(GTK_CONTAINER(tw->win), main_vb);
 169
 170     gtk_box_pack_start(GTK_BOX (main_vb), txt_scrollw, TRUE, TRUE, 0);
 171
 172     gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(txt_scrollw),
 173                                         GTK_SHADOW_IN);
 174
 175     gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(txt_scrollw),
 176                                    GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 177     tw->txt = gtk_text_view_new();
 178     gtk_text_view_set_editable(GTK_TEXT_VIEW(tw->txt), FALSE);
 179     gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(tw->txt), GTK_WRAP_WORD);
 180     gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(tw->txt), FALSE);
 181
 182     gtk_text_view_set_left_margin(GTK_TEXT_VIEW(tw->txt), 4);
 183     gtk_text_view_set_right_margin(GTK_TEXT_VIEW(tw->txt), 4);
 184
 185     hbox = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0, FALSE);
 186     gtk_widget_show(hbox);
 187
 188     tw->button_hbox = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL);
 189     gtk_button_box_set_layout(GTK_BUTTON_BOX(tw->button_hbox), GTK_BUTTONBOX_START);
 190
 191     gtk_box_pack_start(GTK_BOX(hbox), tw->button_hbox, TRUE, TRUE, 0);
 192     gtk_widget_show(tw->button_hbox);
 193
 194     gtk_box_pack_start(GTK_BOX(main_vb), hbox, FALSE, FALSE, 0);
 195
 196     tw->bt_close = gtk_button_new_with_label("Close");
 197     gtk_widget_set_can_default(tw->bt_close, TRUE);
 198     g_object_set_data(G_OBJECT(hbox), "Close", tw->bt_close);
 199
 200     gtk_box_pack_end(GTK_BOX(hbox), tw->bt_close, FALSE, FALSE, 0);
 201     gtk_widget_show(tw->bt_close);
 202
 203     g_signal_connect(tw->bt_close, "clicked", G_CALLBACK(text_window_cancel_button_cb), tw);
 204     gtk_widget_grab_default(tw->bt_close);
 205
 206     gtk_container_add(GTK_CONTAINER(txt_scrollw), tw->txt);
 207     gtk_window_resize(GTK_WINDOW(tw->win),400,300);
 208     gtk_widget_show_all(tw->win);
 209
 210     return tw;
 211 }
 212
 213
 214 static void text_window_clear(funnel_text_window_t*  tw)
 215 {
 216     GtkTextBuffer *buf;
 217
 218     if (! tw->win) return;
 219
 220     buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(tw->txt));
 221
 222     gtk_text_buffer_set_text(buf, "", 0);
 223 }
 224
 225
 226 static void text_window_append(funnel_text_window_t*  tw, const char *str)
 227 {
 228     GtkWidget *txt;
 229     int nchars;
 230     GtkTextBuffer *buf;
 231     GtkTextIter    iter;
 232
 233     if (! tw->win) return;
 234
 235     txt = tw->txt;
 236     nchars = (int) strlen(str);
 237
 238
 239     buf= gtk_text_view_get_buffer(GTK_TEXT_VIEW(txt));
 240
 241     gtk_text_buffer_get_end_iter(buf, &iter);
 242 #if GTK_CHECK_VERSION(3,0,0)
 243     gtk_widget_override_font(GTK_WIDGET(txt), user_font_get_regular());
 244 #else
 245     gtk_widget_modify_font(GTK_WIDGET(txt), user_font_get_regular());
 246 #endif
 247     if (!g_utf8_validate(str, -1, NULL))
 248         printf("Invalid utf8 encoding: %s\n", str);
 249
 250     gtk_text_buffer_insert(buf, &iter, str, nchars);
 251 }
 252
 253
 254 static void text_window_set_text(funnel_text_window_t*  tw, const gchar* text)
 255 {
 256     if (! tw->win) return;
 257
 258     text_window_clear(tw);
 259     text_window_append(tw, text);
 260 }
 261
 262
 263 static void text_window_prepend(funnel_text_window_t*  tw, const char *str _U_) {
 264     GtkWidget *txt;
 265     int nchars;
 266     GtkTextBuffer *buf;
 267     GtkTextIter    iter;
 268
 269     if (! tw->win) return;
 270
 271     txt = tw->txt;
 272     nchars = (int) strlen(str);
 273
 274
 275     buf= gtk_text_view_get_buffer(GTK_TEXT_VIEW(txt));
 276
 277     gtk_text_buffer_get_start_iter(buf, &iter);
 278  #if GTK_CHECK_VERSION(3,0,0)
 279    gtk_widget_override_font(GTK_WIDGET(txt), user_font_get_regular());
 280 #else
 281    gtk_widget_modify_font(GTK_WIDGET(txt), user_font_get_regular());
 282 #endif
 283     if (!g_utf8_validate(str, -1, NULL))
 284         printf("Invalid utf8 encoding: %s\n", str);
 285
 286     gtk_text_buffer_insert(buf, &iter, str, nchars);
 287 }
 288
 289 static const gchar* text_window_get_text(funnel_text_window_t*  tw) {
 290     GtkWidget *txt;
 291     GtkTextBuffer *buf;
 292     GtkTextIter    start;
 293     GtkTextIter    end;
 294
 295     if (! tw->win) return "";
 296
 297     txt = tw->txt;
 298
 299     buf= gtk_text_view_get_buffer(GTK_TEXT_VIEW(txt));
 300     gtk_text_buffer_get_start_iter(buf, &start);
 301     gtk_text_buffer_get_end_iter(buf, &end);
 302
 303     return gtk_text_buffer_get_text(buf, &start, &end, FALSE);
 304 }
 305
 306
 307
 308 static void text_window_set_close_cb(funnel_text_window_t*  tw, text_win_close_cb_t cb, void* data) {
 309     tw->close_cb = cb;
 310     tw->close_data = data;
 311 }
 312
 313 static void text_window_destroy(funnel_text_window_t*  tw) {
 314     if (tw->win) {
 315         /*
 316          * the window is still there and its callbacks refer to this data structure
 317          * we need to change the callback so that they free tw.
 318          */
 319         g_signal_connect(tw->bt_close, "clicked", G_CALLBACK(unref_text_win_cancel_bt_cb), tw);
 320         g_signal_connect(tw->win, "delete-event", G_CALLBACK(text_window_unref_del_event_cb), tw);
 321     } else {
 322         guint i;
 323         /*
 324          * we have no window anymore a human user closed
 325          * the window already just free the container
 326          */
 327         for (i = 0; i < tw->buttons->len; i++) {
 328             funnel_bt_t* cbd = (funnel_bt_t *)g_ptr_array_index(tw->buttons,i);
 329             /* XXX a free cb should be passed somehow */
 330             if (cbd->data && cbd->free_data_fcn) cbd->free_data_fcn(cbd->data);
 331             if (cbd->free_fcn) cbd->free_fcn(cbd);
 332         }
 333         g_ptr_array_free(tw->buttons,TRUE);
 334         g_free(tw);
 335     }
 336 }
 337
 338 static void text_window_set_editable(funnel_text_window_t*  tw, gboolean editable){
 339     gtk_text_view_set_editable(GTK_TEXT_VIEW(tw->txt), editable);
 340     gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(tw->txt), editable);
 341 }
 342
 343 static gboolean text_window_button_cb(GtkWidget *bt _U_, gpointer user_data)
 344 {
 345     funnel_bt_t* cbd = (funnel_bt_t *)user_data;
 346
 347     if (cbd->func) {
 348         return cbd->func(cbd->tw,cbd->data);
 349     } else {
 350         return TRUE;
 351     }
 352 }
 353
 354 static void text_window_add_button(funnel_text_window_t*  tw, funnel_bt_t* cbd, const gchar* label) {
 355     GtkWidget *button;
 356
 357     cbd->tw = tw;
 358     g_ptr_array_add(tw->buttons,cbd);
 359
 360     button = gtk_button_new_with_label(label);
 361     gtk_widget_set_can_default(button, TRUE);
 362
 363     gtk_box_pack_start(GTK_BOX(tw->button_hbox), button, FALSE, FALSE, 0);
 364
 365     gtk_widget_show(button);
 366     g_signal_connect(button, "clicked", G_CALLBACK(text_window_button_cb), cbd);
 367
 368 }
 369
 370
 371 struct _funnel_dlg_data {
 372     GtkWidget* win;
 373     GPtrArray* entries;
 374     funnel_dlg_cb_t dlg_cb;
 375     void* data;
 376 };
 377
 378 static gboolean funnel_dlg_cb(GtkWidget *win _U_, gpointer user_data)
 379 {
 380     struct _funnel_dlg_data* dd = (struct _funnel_dlg_data *)user_data;
 381     guint i;
 382     guint len = dd->entries->len;
 383     GPtrArray* returns = g_ptr_array_new();
 384
 385     for(i=0; i<len; i++) {
 386         GtkEntry* entry = (GtkEntry *)g_ptr_array_index(dd->entries,i);
 387         g_ptr_array_add(returns,g_strdup(gtk_entry_get_text(entry)));
 388     }
 389
 390     g_ptr_array_add(returns,NULL);
 391
 392     if (dd->dlg_cb)
 393         dd->dlg_cb((gchar**)returns->pdata,dd->data);
 394
 395     window_destroy(GTK_WIDGET(dd->win));
 396
 397     g_ptr_array_free(returns,FALSE);
 398
 399     return TRUE;
 400 }
 401
 402 static void funnel_cancel_btn_cb(GtkWidget *bt _U_, gpointer data) {
 403     GtkWidget* win = (GtkWidget *)data;
 404
 405     window_destroy(GTK_WIDGET(win));
 406 }
 407
 408 static void funnel_new_dialog(const gchar* title,
 409                                           const gchar** fieldnames,
 410                                           funnel_dlg_cb_t dlg_cb,
 411                                           void* data) {
 412     GtkWidget *win, *main_grid, *main_vb, *bbox, *bt_cancel, *bt_ok;
 413     guint i;
 414     const gchar* fieldname;
 415     struct _funnel_dlg_data* dd = (struct _funnel_dlg_data *)g_malloc(sizeof(struct _funnel_dlg_data));
 416
 417     dd->entries = g_ptr_array_new();
 418     dd->dlg_cb = dlg_cb;
 419     dd->data = data;
 420
 421     for (i=0; fieldnames[i]; i++);
 422
 423     win = dlg_window_new(title);
 424
 425     dd->win = win;
 426
 427     gtk_window_resize(GTK_WINDOW(win),400,10*(i+2));
 428
 429     main_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 5, FALSE);
 430     gtk_container_add(GTK_CONTAINER(win), main_vb);
 431     gtk_container_set_border_width(GTK_CONTAINER(main_vb), 6);
 432
 433     main_grid = ws_gtk_grid_new();
 434     gtk_box_pack_start(GTK_BOX(main_vb), main_grid, FALSE, FALSE, 0);
 435     ws_gtk_grid_set_row_spacing(GTK_GRID(main_grid), 10);
 436     ws_gtk_grid_set_column_spacing(GTK_GRID(main_grid), 15);
 437
 438     for (i = 0; (fieldname = fieldnames[i]) ; i++) {
 439         GtkWidget *entry, *label;
 440
 441         label = gtk_label_new(fieldname);
 442         gtk_misc_set_alignment(GTK_MISC(label), 1.0f, 0.5f);
 443         ws_gtk_grid_attach_defaults(GTK_GRID(main_grid), label, 0, i+1, 1, 1);
 444         gtk_widget_show(label);
 445
 446         entry = gtk_entry_new();
 447         g_ptr_array_add(dd->entries,entry);
 448         ws_gtk_grid_attach_defaults(GTK_GRID(main_grid), entry, 1, i+1, 1, 1);
 449         gtk_widget_show(entry);
 450     }
 451
 452     bbox = dlg_button_row_new(GTK_STOCK_CANCEL,GTK_STOCK_OK, NULL);
 453     gtk_box_pack_start(GTK_BOX(main_vb), bbox, FALSE, FALSE, 0);
 454
 455     bt_ok = (GtkWidget *)g_object_get_data(G_OBJECT(bbox), GTK_STOCK_OK);
 456     g_signal_connect(bt_ok, "clicked", G_CALLBACK(funnel_dlg_cb), dd);
 457     gtk_widget_grab_default(bt_ok);
 458
 459     bt_cancel = (GtkWidget *)g_object_get_data(G_OBJECT(bbox), GTK_STOCK_CANCEL);
 460     g_signal_connect(bt_cancel, "clicked", G_CALLBACK(funnel_cancel_btn_cb), win);
 461     gtk_widget_grab_default(bt_cancel);
 462
 463     gtk_widget_show(main_grid);
 464     gtk_widget_show(main_vb);
 465     gtk_widget_show(win);
 466 }
 467
 468 static gchar * funnel_get_filter(void) {
 469     return (gchar *)gtk_entry_get_text(GTK_ENTRY(main_display_filter_widget));
 470 }
 471
 472 static void funnel_set_filter(const char* filter_string) {
 473     gtk_entry_set_text(GTK_ENTRY(main_display_filter_widget), filter_string);
 474 }
 475
 476 static void funnel_set_color_filter_slot(guint8 filt_nr, const gchar* filter_string) {
 477     color_filters_set_tmp(filt_nr, (gchar *)filter_string, FALSE);
 478 }
 479
 480 static void funnel_apply_filter(void) {
 481     const char* filter_string = gtk_entry_get_text(GTK_ENTRY(main_display_filter_widget));
 482     main_filter_packets(&cfile, filter_string, FALSE);
 483 }
 484
 485 /* XXX: finish this */
 486 static void funnel_logger(const gchar *log_domain _U_,
 487                           GLogLevelFlags log_level _U_,
 488                           const gchar *message,
 489                           gpointer user_data _U_) {
 490     fputs(message,stderr);
 491 }
 492
 493 static void funnel_retap_packets(void) {
 494     cf_retap_packets(&cfile);
 495 }
 496
 497 static gboolean funnel_open_file(const char* fname, const char* filter, const char** err_str) {
 498     int err = 0;
 499     dfilter_t   *rfcode = NULL;
 500
 501     *err_str = "no error";
 502
 503     switch (cfile.state) {
 504         case FILE_CLOSED:
 505         case FILE_READ_DONE:
 506         case FILE_READ_ABORTED:
 507             break;
 508         case FILE_READ_IN_PROGRESS:
 509             *err_str = "file read in progress";
 510             return FALSE;
 511     }
 512
 513     if (filter) {
 514         if (!dfilter_compile(filter, &rfcode)) {
 515             *err_str = dfilter_error_msg ? dfilter_error_msg : "cannot compile filter";
 516             return FALSE;
 517         }
 518     }
 519
 520
 521     if (cf_open(&cfile, fname, FALSE, &err) != CF_OK) {
 522         *err_str = g_strerror(err);
 523         if (rfcode != NULL) dfilter_free(rfcode);
 524         return FALSE;
 525     }
 526
 527     cfile.rfcode = rfcode;
 528
 529     switch (cf_read(&cfile, FALSE)) {
 530         case CF_READ_OK:
 531         case CF_READ_ERROR:
 532             break;
 533         default:
 534             *err_str = "problem while reading file";
 535             return FALSE;
 536     }
 537
 538     return TRUE;
 539 }
 540
 541 static funnel_progress_window_t* funnel_new_progress_window(const gchar* label, const gchar* task, gboolean terminate_is_stop, gboolean *stop_flag) {
 542     return (funnel_progress_window_t*)create_progress_dlg(top_level, label, task, terminate_is_stop, stop_flag);
 543 }
 544
 545 static void funnel_update_progress(funnel_progress_window_t* win, float pr, const gchar* task) {
 546     update_progress_dlg((progdlg_t*)win, pr, task);
 547 }
 548
 549 static void funnel_destroy_progress_window(funnel_progress_window_t* win) {
 550     destroy_progress_dlg((progdlg_t*)win);
 551 }
 552
 553 static void funnel_reload(void) {
 554     if (cfile.state == FILE_READ_DONE) cf_reload(&cfile);
 555 }
 556
 557 static const funnel_ops_t funnel_ops = {
 558     new_text_window,
 559     text_window_set_text,
 560     text_window_append,
 561     text_window_prepend,
 562     text_window_clear,
 563     text_window_get_text,
 564     text_window_set_close_cb,
 565     text_window_set_editable,
 566     text_window_destroy,
 567     text_window_add_button,
 568     /*...,*/
 569     funnel_new_dialog,
 570     funnel_logger,
 571     funnel_retap_packets,
 572     copy_to_clipboard,
 573     funnel_get_filter,
 574     funnel_set_filter,
 575     funnel_set_color_filter_slot,
 576     funnel_open_file,
 577     funnel_reload,
 578     funnel_apply_filter,
 579     browser_open_url,
 580     browser_open_data_file,
 581     funnel_new_progress_window,
 582     funnel_update_progress,
 583     funnel_destroy_progress_window
 584 };
 585
 586
 587 typedef struct _menu_cb_t {
 588     void (*callback)(gpointer);
 589     void* callback_data;
 590     gboolean retap;
 591 } menu_cb_t;
 592
 593 static void our_menu_callback(void* unused _U_, gpointer data) {
 594     menu_cb_t* mcb = (menu_cb_t *)data;
 595     mcb->callback(mcb->callback_data);
 596     if (mcb->retap) cf_retap_packets(&cfile);
 597 }
 598
 599 static void register_menu_cb(const char *name,
 600                              register_stat_group_t group,
 601                              void (*callback)(gpointer),
 602                              gpointer callback_data,
 603                              gboolean retap) {
 604
 605     menu_cb_t* mcb = (menu_cb_t *)g_malloc(sizeof(menu_cb_t));
 606     const char *label = NULL, *str = NULL;
 607
 608     mcb->callback = callback;
 609     mcb->callback_data = callback_data;
 610     mcb->retap = retap;
 611
 612     str = strrchr(name,'/');
 613     if(str){
 614         label = str+1;
 615     }else{
 616         label = name;
 617     }
 618
 619     register_menu_bar_menu_items(
 620         stat_group_name(group), /* GUI path to the place holder in the menu */
 621         name, /* Action name */
 622         NULL, /* Stock id */
 623         label, /* label */
 624         NULL, /* Accelerator */
 625         NULL, /* Tooltip */
 626         our_menu_callback, /* Callback */
 627         mcb,               /* callback data */
 628         TRUE,              /* enabled */
 629         NULL,
 630         NULL);
 631 }
 632
 633 void initialize_funnel_ops(void) {
 634     funnel_set_funnel_ops(&funnel_ops);
 635 }
 636
 637 void
 638 register_tap_listener_gtkfunnel(void)
 639 {
 640     funnel_register_all_menus(register_menu_cb);
 641 }