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