ui/gtk/filter_expression_save_dlg.c

   1 /* filter_expression_save_dlg.c
   2  * Routines for "Filter Save" window
   3  * Submitted by Edwin Groothuis <wireshark@mavetju.org>
   4  *
   5  * $Id$
   6  *
   7  * Wireshark - Network traffic analyzer
   8  * By Gerald Combs <gerald@wireshark.org>
   9  * Copyright 1998 Gerald Combs
  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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  24  */
  25
  26 #ifdef HAVE_CONFIG_H
  27 # include "config.h"
  28 #endif
  29
  30 #include <string.h>
  31 #include <ctype.h>
  32 #include <math.h>
  33
  34 #include <gtk/gtk.h>
  35
  36 #include <epan/proto.h>
  37 #include <epan/dfilter/dfilter.h>
  38 #include <epan/nstime.h>
  39 #include <epan/strutil.h>
  40 #include <epan/prefs.h>
  41 #include <epan/filter_expressions.h>
  42
  43 #include "../globals.h"
  44
  45 #include "ui/alert_box.h"
  46 #include "ui/simple_dialog.h"
  47 #include "ui/main_statusbar.h"
  48 #include "ui/ui_util.h"
  49
  50 #include "ui/gtk/gui_utils.h"
  51 #include "ui/gtk/filter_expression_save_dlg.h"
  52 #include "ui/gtk/dlg_utils.h"
  53 #include "ui/gtk/stock_icons.h"
  54 #include "ui/gtk/prefs_dlg.h"
  55 #include "ui/gtk/filter_dlg.h"
  56 #include "ui/gtk/filter_autocomplete.h"
  57 #include "ui/gtk/keys.h"
  58 #include "ui/gtk/help_dlg.h"
  59
  60 #include "main.h"
  61
  62 #include "main_filter_toolbar.h"
  63
  64 /* Capture callback data keys */
  65 #define E_FILTER_SAVE_EXPR_KEY     "filter_save_offset_expression"
  66 #define E_FILTER_SAVE_LABEL_KEY     "filter_save_offset_label"
  67
  68 static void filter_save_ok_cb(GtkWidget *ok_bt, GtkWindow *parent_w);
  69 static void filter_save_close_cb(GtkWidget *close_bt, gpointer parent_w);
  70 static void filter_save_frame_destroy_cb(GtkWidget *win, gpointer user_data);
  71 static void filter_button_cb(GtkWidget *close_bt, gpointer parent_w);
  72 static int filter_button_add(const char *label, const char *expr, struct filter_expression *newbutton);
  73
  74 /*
  75  * Keep a static pointer to the current "Filter Save" window, if any, so
  76  * that if somebody tries to do "Filter Save" while there's already a
  77  * "Filter Save" window up, we just pop up the existing one, rather than
  78  * creating a new one.
  79  */
  80 static GtkWidget *filter_save_frame_w;
  81
  82 GtkWidget *_filter_tb = NULL;
  83 GtkWidget *_filter_te = NULL;
  84
  85 /*
  86  * This does do two things:
  87  * - Keep track of the various elements of the Filter Toolbar which will
  88  *   be needed later when a new button has to be added.
  89  * - Since it is called after the preferences are read from the configfile,
  90  *   this is the one also which creates the initial buttons when the
  91  *   Filter Toolbar has been created.
  92  */
  93 void
  94 filter_expression_save_dlg_init(gpointer filter_tb, gpointer filter_te)
  95 {
  96         struct filter_expression *fe;
  97
  98         _filter_tb = (GtkWidget *)filter_tb;
  99         _filter_te = (GtkWidget *)filter_te;
 100
 101         fe = *pfilter_expression_head;
 102         while (fe != NULL) {
 103                 filter_button_add(NULL, NULL, fe);
 104                 fe = fe->next;
 105         }
 106 }
 107
 108 void
 109 filter_expression_nuke(struct filter_expression *fe)
 110 {
 111         if (fe == NULL)
 112                 return;
 113         filter_expression_nuke(fe->next);
 114         g_free(fe->label);
 115         g_free(fe->expression);
 116 }
 117
 118 void
 119 filter_expression_reinit(int what)
 120 {
 121         struct filter_expression *fe, *prevhead;
 122
 123         if ((what & FILTER_EXPRESSION_REINIT_DESTROY) != 0) {
 124                 fe = *pfilter_expression_head;
 125                 while (fe != NULL) {
 126                         if (fe->button != NULL) {
 127                                 gtk_widget_destroy(fe->button);
 128                                 fe->button = NULL;
 129                         }
 130                         fe = fe->next;
 131                 }
 132         }
 133         if (what == FILTER_EXPRESSION_REINIT_DESTROY) {
 134                 filter_expression_nuke(*pfilter_expression_head);
 135                 *pfilter_expression_head = NULL;
 136                 return;
 137         }
 138
 139         if ((what & FILTER_EXPRESSION_REINIT_CREATE) != 0) {
 140                 gint maxindex = -1, index;
 141                 fe = *pfilter_expression_head;
 142                 while (fe != NULL) {
 143                         maxindex = MAX(maxindex, fe->index);
 144                         fe = fe->next;
 145                 }
 146
 147                 prevhead = *pfilter_expression_head;
 148                 *pfilter_expression_head = NULL;
 149
 150                 /*
 151                  * The list should be in the order identified by the
 152                  * index member.
 153                  */
 154                 for (index = 0; index <= maxindex; index++) {
 155                         if (prevhead != NULL) {
 156                                 fe = prevhead;
 157                                 while (fe != NULL && fe->index != index)
 158                                         fe = fe->next;
 159                         }
 160                         if (fe == NULL)
 161                                 continue;       /* Shouldn't happen */
 162                         if (fe->deleted)
 163                                 continue;       /* Could happen */
 164                         filter_expression_new(fe->label, fe->expression,
 165                             fe->enabled);
 166                 }
 167                 filter_expression_nuke(prevhead);
 168
 169                 /* Create the buttons again */
 170                 fe = *pfilter_expression_head;
 171                 while (fe != NULL) {
 172                         if (fe->enabled && !fe->deleted)
 173                                 filter_button_add(NULL, NULL, fe);
 174                         fe = fe->next;
 175                 }
 176         }
 177 }
 178
 179 static int
 180 filter_button_add(const char *label, const char *expr, struct filter_expression *newfe)
 181 {
 182         struct filter_expression *fe;
 183
 184         /* No duplicate buttons when adding a new one  */
 185         if (newfe == NULL)
 186                 fe = filter_expression_new(label, expr, TRUE);
 187         else
 188                 fe = newfe;
 189
 190         if (fe->enabled == FALSE)
 191                 return(0);
 192
 193         /* Create the "Label" button */
 194         fe->button = gtk_tool_button_new(NULL, fe->label);
 195         g_signal_connect(fe->button, "clicked", G_CALLBACK(filter_button_cb),
 196             NULL);
 197         gtk_widget_set_sensitive(GTK_WIDGET(fe->button), FALSE);
 198         gtk_widget_show(GTK_WIDGET(fe->button));
 199
 200         gtk_toolbar_insert(GTK_TOOLBAR(_filter_tb), fe->button, -1);
 201         gtk_widget_set_sensitive(GTK_WIDGET(fe->button), TRUE);
 202         gtk_widget_set_tooltip_text(GTK_WIDGET(fe->button), fe->expression);
 203
 204         return(0);
 205 }
 206
 207 static void
 208 filter_button_cb(GtkWidget *this_button, gpointer parent_w _U_)
 209 {
 210         struct filter_expression *fe;
 211
 212         fe = *pfilter_expression_head;
 213         while (fe != NULL) {
 214                 if ((void *)fe->button == (void *)this_button) {
 215                         gtk_entry_set_text(GTK_ENTRY(_filter_te),
 216                             fe->expression);
 217                         main_filter_packets(&cfile, fe->expression, FALSE);
 218                         return;
 219                 }
 220                 fe = fe->next;
 221         }
 222         printf("No Callback\n");
 223 }
 224
 225 void
 226 filter_expression_save_dlg(gpointer data)
 227 {
 228         GtkWidget   *main_vb, *main_filter_save_hb, *filter_save_frame,
 229                     *filter_save_type_vb, *filter_save_type_hb, *entry_hb,
 230                     *bbox, *ok_bt, *cancel_bt, *help_bt, *filter_text_box,
 231                     *label_text_box;
 232
 233         const char *expr;
 234
 235         /* The filter requested */
 236         expr = gtk_entry_get_text(GTK_ENTRY(data));
 237
 238         if (filter_save_frame_w != NULL) {
 239                 /* There's already a "Filter Save" dialog box; reactivate it. */
 240                 reactivate_window(filter_save_frame_w);
 241                 return;
 242         }
 243
 244         filter_save_frame_w = dlg_window_new("Wireshark: Save Filter");
 245
 246         /* Container for each row of widgets */
 247         main_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 3, FALSE);
 248         gtk_container_set_border_width(GTK_CONTAINER(main_vb), 5);
 249         gtk_container_add(GTK_CONTAINER(filter_save_frame_w), main_vb);
 250         gtk_widget_show(main_vb);
 251
 252
 253         /* */
 254         main_filter_save_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3, FALSE);
 255     gtk_box_pack_start(GTK_BOX (main_vb), main_filter_save_hb, TRUE, TRUE, 0);
 256         gtk_widget_show(main_filter_save_hb);
 257
 258         /* Filter Save frame */
 259         filter_save_frame = gtk_frame_new("Save Filter as...");
 260         gtk_box_pack_start(GTK_BOX(main_filter_save_hb), filter_save_frame,
 261             TRUE, TRUE, 0);
 262         gtk_widget_show(filter_save_frame);
 263
 264         filter_save_type_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 3, FALSE);
 265         gtk_container_set_border_width(GTK_CONTAINER(filter_save_type_vb), 3);
 266         gtk_container_add(GTK_CONTAINER(filter_save_frame),
 267             filter_save_type_vb);
 268         gtk_widget_show(filter_save_type_vb);
 269
 270         /* filter_save type row */
 271         filter_save_type_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3, FALSE);
 272     gtk_box_pack_start(GTK_BOX (filter_save_type_vb), filter_save_type_hb, TRUE, TRUE, 0);
 273
 274         gtk_widget_show(filter_save_type_hb);
 275
 276         /* filter_save row */
 277         entry_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3, FALSE);
 278         gtk_box_pack_start(GTK_BOX(filter_save_type_vb), entry_hb, FALSE,
 279             FALSE, 0);
 280         gtk_widget_show(entry_hb);
 281
 282         filter_text_box = gtk_entry_new();
 283         gtk_box_pack_start(GTK_BOX(entry_hb), filter_text_box, TRUE, TRUE, 0);
 284         g_signal_connect(filter_text_box, "changed", G_CALLBACK(filter_te_syntax_check_cb), NULL);
 285         g_signal_connect(filter_text_box, "key-press-event", G_CALLBACK (filter_string_te_key_pressed_cb), NULL);
 286         g_signal_connect(filter_save_frame_w, "key-press-event", G_CALLBACK (filter_parent_dlg_key_pressed_cb), NULL);
 287
 288         gtk_entry_set_text(GTK_ENTRY(filter_text_box), expr);
 289         gtk_widget_show(filter_text_box);
 290
 291         label_text_box = gtk_entry_new();
 292         gtk_box_pack_start(GTK_BOX(entry_hb), label_text_box, TRUE, TRUE, 0);
 293         gtk_entry_set_text(GTK_ENTRY(label_text_box), "Filter");
 294         gtk_widget_show(label_text_box);
 295
 296         /* Button row */
 297         bbox = dlg_button_row_new(GTK_STOCK_OK, GTK_STOCK_CANCEL,
 298             GTK_STOCK_HELP, NULL);
 299         gtk_box_pack_start(GTK_BOX(main_vb), bbox, FALSE, FALSE, 0);
 300         gtk_widget_show(bbox);
 301
 302         ok_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_OK);
 303         g_signal_connect(ok_bt, "clicked", G_CALLBACK(filter_save_ok_cb),
 304         filter_save_frame_w);
 305
 306         cancel_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_CANCEL);
 307         g_signal_connect(cancel_bt, "clicked", G_CALLBACK(filter_save_close_cb),
 308         filter_save_frame_w);
 309
 310         help_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_HELP);
 311         g_signal_connect(help_bt, "clicked", G_CALLBACK(topic_cb),
 312         (gpointer)HELP_FILTER_SAVE_DIALOG);
 313
 314         g_object_set_data(G_OBJECT(filter_save_frame_w),
 315             E_FILTER_SAVE_EXPR_KEY, filter_text_box);
 316         g_object_set_data(G_OBJECT(filter_save_frame_w),
 317             E_FILTER_SAVE_LABEL_KEY, label_text_box);
 318
 319         dlg_set_activate(label_text_box, ok_bt);
 320
 321         /* Give the initial focus to the "offset" entry box. */
 322         gtk_widget_grab_focus(label_text_box);
 323
 324         g_signal_connect(filter_save_frame_w, "delete_event",
 325         G_CALLBACK(window_delete_event_cb), NULL);
 326         g_signal_connect(filter_save_frame_w, "destroy",
 327         G_CALLBACK(filter_save_frame_destroy_cb), NULL);
 328
 329         gtk_widget_show(filter_save_frame_w);
 330         window_present(filter_save_frame_w);
 331 }
 332
 333 static void
 334 filter_save_ok_cb(GtkWidget *ok_bt _U_, GtkWindow *parent_w)
 335 {
 336         GtkWidget *expr_te, *label_te;
 337         const char *expr, *label;
 338
 339         /* The filter requested */
 340         expr_te = (GtkWidget *)g_object_get_data(G_OBJECT(parent_w),
 341             E_FILTER_SAVE_EXPR_KEY);
 342         label_te = (GtkWidget *)g_object_get_data(G_OBJECT(parent_w),
 343             E_FILTER_SAVE_LABEL_KEY);
 344         expr = gtk_entry_get_text(GTK_ENTRY(expr_te));
 345         label = gtk_entry_get_text(GTK_ENTRY(label_te));
 346
 347         if (filter_button_add(label, expr, NULL) == 0) {
 348                 prefs_main_write();
 349                 filter_save_close_cb(NULL, parent_w);
 350         }
 351 }
 352
 353 static void
 354 filter_save_close_cb(GtkWidget *close_bt _U_, gpointer parent_w)
 355 {
 356         gtk_grab_remove(GTK_WIDGET(parent_w));
 357         window_destroy(GTK_WIDGET(parent_w));
 358 }
 359
 360 static void
 361 filter_save_frame_destroy_cb(GtkWidget *win _U_, gpointer user_data _U_)
 362 {
 363         /* Note that we no longer have a "Filter Save" dialog box. */
 364         filter_save_frame_w = NULL;
 365 }