ltt/branches/poly/lttv/modules/gui/filter/filter.c

   1 /* This file is part of the Linux Trace Toolkit viewer
   2  * Copyright (C) 2005 Simon Bouvier-Zappa
   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 Version 2 as
   6  * published by the Free Software Foundation;
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this program; if not, write to the Free Software
  15  * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  16  * MA 02111-1307, USA.
  17  */
  18
  19 #include <glib.h>
  20 #include <string.h>
  21 #include <gtk/gtk.h>
  22 #include <gdk/gdk.h>
  23
  24 #include <lttv/lttv.h>
  25 #include <lttv/module.h>
  26 #include <lttv/hook.h>
  27 #include <lttv/filter.h>
  28
  29 #include <lttvwindow/lttvwindow.h>
  30 #include <lttvwindow/lttvwindowtraces.h>
  31
  32 #include "hGuiFilterInsert.xpm"
  33
  34 /*
  35  * TODO
  36  * - connect the gui filter to the core filter
  37  */
  38
  39 /*
  40  * NOTE
  41  * The version of gtk-2.0 currently installed on
  42  * my desktop misses some function of the newer
  43  * gtk+ api.
  44  *
  45  * For the time being, I'll use the older api
  46  * to keep compatibility with most systems.
  47  */
  48
  49 typedef struct _FilterViewerData FilterViewerData;
  50 typedef struct _FilterViewerDataLine FilterViewerDataLine;
  51
  52 /*
  53  * Prototypes
  54  */
  55 GtkWidget *guifilter_get_widget(FilterViewerData *fvd);
  56 FilterViewerData *gui_filter(Tab *tab);
  57 void gui_filter_destructor(FilterViewerData *fvd);
  58 FilterViewerDataLine* gui_filter_add_line(FilterViewerData *fvd);
  59 void gui_filter_line_set_visible(FilterViewerDataLine *fvdl, gboolean v);
  60 void gui_filter_line_reset(FilterViewerDataLine *fvdl);
  61 gboolean filter_traceset_changed(void * hook_data, void * call_data);
  62 gboolean filter_viewer_data(void * hook_data, void * call_data);
  63 GtkWidget* h_guifilter(Tab *tab);
  64 void filter_destroy_walk(gpointer data, gpointer user_data);
  65
  66 /*
  67  * Callback functions
  68  */
  69 void callback_process_button(GtkWidget *widget, gpointer data);
  70 void callback_add_button(GtkWidget *widget, gpointer data);
  71 void callback_logical_op_box(GtkWidget *widget, gpointer data);
  72 void callback_expression_field(GtkWidget *widget, gpointer data);
  73
  74 /**
  75  *  @struct _FilterViewerDataLine
  76  *
  77  *  @brief Defines a simple expression
  78  *  This structures defines a simple
  79  *  expression whithin the main filter
  80  *  viewer data
  81  */
  82 struct _FilterViewerDataLine {
  83   int row;                            /** row number */
  84   gboolean visible;                   /** visible state */
  85   GtkWidget *f_not_op_box;            /** '!' operator (GtkComboBox) */
  86   GtkWidget *f_logical_op_box;        /** '&,|,^' operators (GtkComboBox) */
  87   GtkWidget *f_field_box;             /** field types (GtkComboBox) */
  88   GtkWidget *f_math_op_box;           /** '>,>=,<,<=,=,!=' operators (GtkComboBox) */
  89   GtkWidget *f_value_field;           /** expression's value (GtkComboBox) */
  90 };
  91
  92 /**
  93  * @struct _FilterViewerData
  94  * Main struct for the filter gui module
  95  */
  96 struct _FilterViewerData {
  97   Tab *tab;
  98
  99   GtkWidget *f_main_box;                /** main container */
 100
 101   GtkWidget *f_expression_field;        /** entire expression (GtkEntry) */
 102   GtkWidget *f_process_button;          /** process expression button (GtkButton) */
 103
 104   GtkWidget *f_logical_op_junction_box; /** linking operator box (GtkComboBox) */
 105
 106   int rows;                             /** number of rows */
 107   GPtrArray *f_lines;                   /** array of FilterViewerDataLine */
 108
 109   GPtrArray *f_not_op_options;          /** array of operators types for not_op box */
 110   GPtrArray *f_logical_op_options;      /** array of operators types for logical_op box */
 111   GPtrArray *f_field_options;           /** array of field types for field box */
 112   GPtrArray *f_math_op_options;         /** array of operators types for math_op box */
 113
 114   GtkWidget *f_add_button;              /** add expression to current expression (GtkButton) */
 115
 116 };
 117
 118 /**
 119  *  @fn guifilter_get_widget(FilterViewerData*)
 120  *
 121  *  This function returns the current main widget
 122  *  used by this module
 123  *  @param fvd the module struct
 124  *  @return The main widget
 125  */
 126 GtkWidget
 127 *guifilter_get_widget(FilterViewerData *fvd)
 128 {
 129   return fvd->f_main_box;
 130 }
 131
 132 /**
 133  *  @fn gui_filter(Tab*)
 134  *
 135  *  Constructor is used to create FilterViewerData data structure.
 136  *  @param the tab structure used by the widget
 137  *  @return The Filter viewer data created.
 138  */
 139 FilterViewerData*
 140 gui_filter(Tab *tab)
 141 {
 142   g_print("filter::gui_filter()");
 143
 144   unsigned i;
 145   GtkCellRenderer *renderer;
 146   GtkTreeViewColumn *column;
 147
 148   FilterViewerData* fvd = g_new(FilterViewerData,1);
 149
 150   fvd->tab  = tab;
 151
 152   lttvwindow_register_traceset_notify(fvd->tab,
 153                                       filter_traceset_changed,
 154                                       filter_viewer_data);
 155 //  request_background_data(filter_viewer_data);
 156
 157   /*
 158    * Initiating items for
 159    * combo boxes
 160    */
 161   fvd->f_not_op_options = g_ptr_array_new();
 162   g_ptr_array_add(fvd->f_not_op_options,(gpointer) g_string_new(""));
 163   g_ptr_array_add(fvd->f_not_op_options,(gpointer) g_string_new("!"));
 164
 165   fvd->f_logical_op_options = g_ptr_array_new(); //g_array_new(FALSE,FALSE,sizeof(gchar));
 166   g_ptr_array_add(fvd->f_logical_op_options,(gpointer) g_string_new(""));
 167   g_ptr_array_add(fvd->f_logical_op_options,(gpointer) g_string_new("&"));
 168   g_ptr_array_add(fvd->f_logical_op_options,(gpointer) g_string_new("|"));
 169   g_ptr_array_add(fvd->f_logical_op_options,(gpointer) g_string_new("!"));
 170   g_ptr_array_add(fvd->f_logical_op_options,(gpointer) g_string_new("^"));
 171
 172   fvd->f_field_options = g_ptr_array_new(); //g_array_new(FALSE,FALSE,16);
 173   g_ptr_array_add(fvd->f_field_options,(gpointer) g_string_new(""));
 174   g_ptr_array_add(fvd->f_field_options,(gpointer) g_string_new("event.name"));
 175   g_ptr_array_add(fvd->f_field_options,(gpointer) g_string_new("event.category"));
 176   g_ptr_array_add(fvd->f_field_options,(gpointer) g_string_new("event.time"));
 177   g_ptr_array_add(fvd->f_field_options,(gpointer) g_string_new("event.tsc"));
 178   /*
 179    * TODO: Add core.xml fields here !
 180    */
 181   g_ptr_array_add(fvd->f_field_options,(gpointer) g_string_new("tracefile.name"));
 182   g_ptr_array_add(fvd->f_field_options,(gpointer) g_string_new("trace.name"));
 183   g_ptr_array_add(fvd->f_field_options,(gpointer) g_string_new("state.pid"));
 184   g_ptr_array_add(fvd->f_field_options,(gpointer) g_string_new("state.ppid"));
 185   g_ptr_array_add(fvd->f_field_options,(gpointer) g_string_new("state.creation_time"));
 186   g_ptr_array_add(fvd->f_field_options,(gpointer) g_string_new("state.insertion_time"));
 187   g_ptr_array_add(fvd->f_field_options,(gpointer) g_string_new("state.execution_mode"));
 188   g_ptr_array_add(fvd->f_field_options,(gpointer) g_string_new("state.execution_submode"));
 189   g_ptr_array_add(fvd->f_field_options,(gpointer) g_string_new("state.process_status"));
 190   g_ptr_array_add(fvd->f_field_options,(gpointer) g_string_new("state.cpu"));
 191
 192   fvd->f_math_op_options = g_ptr_array_new(); //g_array_new(FALSE,FALSE,7);
 193   g_ptr_array_add(fvd->f_math_op_options,(gpointer) g_string_new(""));
 194   g_ptr_array_add(fvd->f_math_op_options,(gpointer) g_string_new("="));
 195   g_ptr_array_add(fvd->f_math_op_options,(gpointer) g_string_new("!="));
 196   g_ptr_array_add(fvd->f_math_op_options,(gpointer) g_string_new("<"));
 197   g_ptr_array_add(fvd->f_math_op_options,(gpointer) g_string_new("<="));
 198   g_ptr_array_add(fvd->f_math_op_options,(gpointer) g_string_new(">"));
 199   g_ptr_array_add(fvd->f_math_op_options,(gpointer) g_string_new(">="));
 200
 201
 202   /*
 203    * Initiating GtkTable layout
 204    * starts with 2 rows and 5 columns and
 205    * expands when expressions added
 206    */
 207   fvd->f_main_box = gtk_table_new(3,7,FALSE);
 208   gtk_table_set_row_spacings(GTK_TABLE(fvd->f_main_box),5);
 209   gtk_table_set_col_spacings(GTK_TABLE(fvd->f_main_box),5);
 210
 211   /*
 212    *  First half of the filter window
 213    *  - textual entry of filter expression
 214    *  - processing button
 215    */
 216   fvd->f_expression_field = gtk_entry_new(); //gtk_scrolled_window_new (NULL, NULL);
 217 //  gtk_entry_set_text(GTK_ENTRY(fvd->f_expression_field),"state.cpu>0");
 218   gtk_widget_show (fvd->f_expression_field);
 219
 220   g_signal_connect (G_OBJECT (fvd->f_expression_field), "changed",
 221       G_CALLBACK (callback_expression_field), (gpointer) fvd);
 222
 223   fvd->f_process_button = gtk_button_new_with_label("Process");
 224   gtk_widget_show (fvd->f_process_button);
 225
 226   g_signal_connect (G_OBJECT (fvd->f_process_button), "clicked",
 227       G_CALLBACK (callback_process_button), (gpointer) fvd);
 228
 229   gtk_table_attach( GTK_TABLE(fvd->f_main_box),fvd->f_expression_field,0,6,0,1,GTK_FILL,GTK_FILL,0,0);
 230   gtk_table_attach( GTK_TABLE(fvd->f_main_box),fvd->f_process_button,6,7,0,1,GTK_FILL,GTK_FILL,0,0);
 231
 232
 233
 234   /*
 235    *  Second half of the filter window
 236    *  - combo boxes featuring filtering options added to the expression
 237    */
 238   fvd->f_add_button = gtk_button_new_with_label("Add Expression");
 239   gtk_widget_show (fvd->f_add_button);
 240
 241   g_signal_connect (G_OBJECT (fvd->f_add_button), "clicked",
 242       G_CALLBACK (callback_add_button), (gpointer) fvd);
 243
 244   gtk_table_attach( GTK_TABLE(fvd->f_main_box),fvd->f_add_button,6,7,1,2,GTK_FILL,GTK_FILL,0,0);
 245
 246   fvd->f_logical_op_junction_box = gtk_combo_box_new_text();
 247   for(i=0;i<fvd->f_logical_op_options->len;i++) {
 248     GString* s = g_ptr_array_index(fvd->f_logical_op_options,i);
 249     gtk_combo_box_append_text(GTK_COMBO_BOX(fvd->f_logical_op_junction_box), s->str);
 250   }
 251   gtk_combo_box_set_active(GTK_COMBO_BOX(fvd->f_logical_op_junction_box),0);
 252
 253   //gtk_widget_show(fvd->f_logical_op_box);
 254
 255   gtk_table_attach( GTK_TABLE(fvd->f_main_box),fvd->f_logical_op_junction_box,0,1,1,2,GTK_SHRINK,GTK_FILL,0,0);
 256
 257   /* initialize a new line */
 258   fvd->f_lines = g_ptr_array_new();
 259   fvd->rows = 1;
 260   FilterViewerDataLine* fvdl = gui_filter_add_line(fvd);
 261   g_ptr_array_add(fvd->f_lines,(gpointer) fvdl);
 262
 263   /*
 264    * show main container
 265    */
 266   gtk_widget_show(fvd->f_main_box);
 267
 268
 269   g_object_set_data_full(
 270       G_OBJECT(guifilter_get_widget(fvd)),
 271       "filter_viewer_data",
 272       fvd,
 273       (GDestroyNotify)gui_filter_destructor);
 274
 275
 276   return fvd;
 277 }
 278
 279 /**
 280  *  @fn gui_filter_add_line(FilterViewerData*)
 281  *
 282  *  Adds a filter option line on the module tab
 283  *  @param fvd The filter module structure
 284  *  @return The line structure
 285  */
 286 FilterViewerDataLine*
 287 gui_filter_add_line(FilterViewerData* fvd) {
 288
 289   FilterViewerDataLine* fvdl = g_new(FilterViewerDataLine,1);
 290
 291   unsigned i;
 292   fvdl->row = fvd->rows;
 293   fvdl->visible = TRUE;
 294
 295   fvdl->f_not_op_box = gtk_combo_box_new_text();
 296   for(i=0;i<fvd->f_not_op_options->len;i++) {
 297     GString* s = g_ptr_array_index(fvd->f_not_op_options,i);
 298     gtk_combo_box_append_text(GTK_COMBO_BOX(fvdl->f_not_op_box), s->str);
 299   }
 300
 301   fvdl->f_field_box = gtk_combo_box_new_text();
 302   for(i=0;i<fvd->f_field_options->len;i++) {
 303     GString* s = g_ptr_array_index(fvd->f_field_options,i);
 304 //    g_print("String field: %s\n",s->str);
 305     gtk_combo_box_append_text(GTK_COMBO_BOX(fvdl->f_field_box), s->str);
 306   }
 307
 308   fvdl->f_math_op_box = gtk_combo_box_new_text();
 309   for(i=0;i<fvd->f_math_op_options->len;i++) {
 310     GString* s = g_ptr_array_index(fvd->f_math_op_options,i);
 311     gtk_combo_box_append_text(GTK_COMBO_BOX(fvdl->f_math_op_box), s->str);
 312   }
 313
 314   fvdl->f_value_field = gtk_entry_new();
 315
 316   fvdl->f_logical_op_box = gtk_combo_box_new_text();
 317   for(i=0;i<fvd->f_logical_op_options->len;i++) {
 318     GString* s = g_ptr_array_index(fvd->f_logical_op_options,i);
 319     gtk_combo_box_append_text(GTK_COMBO_BOX(fvdl->f_logical_op_box), s->str);
 320   }
 321   gtk_widget_set_events(fvdl->f_logical_op_box,
 322       GDK_ENTER_NOTIFY_MASK |
 323       GDK_LEAVE_NOTIFY_MASK |
 324       GDK_FOCUS_CHANGE_MASK);
 325
 326   g_signal_connect (G_OBJECT (fvdl->f_logical_op_box), "changed",
 327     G_CALLBACK (callback_logical_op_box), (gpointer) fvd);
 328
 329   gui_filter_line_reset(fvdl);
 330   gui_filter_line_set_visible(fvdl,TRUE);
 331
 332   gtk_table_attach( GTK_TABLE(fvd->f_main_box),fvdl->f_not_op_box,0,1,fvd->rows+1,fvd->rows+2,GTK_SHRINK,GTK_FILL,0,0);
 333   gtk_table_attach( GTK_TABLE(fvd->f_main_box),fvdl->f_field_box,1,3,fvd->rows+1,fvd->rows+2,GTK_SHRINK,GTK_FILL,0,0);
 334   gtk_table_attach( GTK_TABLE(fvd->f_main_box),fvdl->f_math_op_box,3,4,fvd->rows+1,fvd->rows+2,GTK_SHRINK,GTK_FILL,0,0);
 335   gtk_table_attach( GTK_TABLE(fvd->f_main_box),fvdl->f_value_field,4,5,fvd->rows+1,fvd->rows+2,GTK_SHRINK,GTK_FILL,0,0);
 336   gtk_table_attach( GTK_TABLE(fvd->f_main_box),fvdl->f_logical_op_box,5,6,fvd->rows+1,fvd->rows+2,GTK_SHRINK,GTK_FILL,0,0);
 337
 338   return fvdl;
 339 }
 340
 341 /**
 342  *  @fn gui_filter_line_set_visible(FilterViewerDataLine*,gboolean)
 343  *
 344  *  Change visible state of current FilterViewerDataLine
 345  *  @param fvdl pointer to the current FilterViewerDataLine
 346  *  @param v TRUE: sets visible, FALSE: sets invisible
 347  */
 348 void gui_filter_line_set_visible(FilterViewerDataLine *fvdl, gboolean v) {
 349
 350   fvdl->visible = v;
 351   if(v) {
 352     gtk_widget_show(fvdl->f_not_op_box);
 353     gtk_widget_show(fvdl->f_field_box);
 354     gtk_widget_show(fvdl->f_math_op_box);
 355     gtk_widget_show(fvdl->f_value_field);
 356     gtk_widget_show(fvdl->f_logical_op_box);
 357   } else {
 358     gtk_widget_hide(fvdl->f_not_op_box);
 359     gtk_widget_hide(fvdl->f_field_box);
 360     gtk_widget_hide(fvdl->f_math_op_box);
 361     gtk_widget_hide(fvdl->f_value_field);
 362     gtk_widget_hide(fvdl->f_logical_op_box);
 363  }
 364
 365 }
 366
 367 /**
 368  *  @fn gui_filter_line_reset(FilterViewerDataLine*)
 369  *
 370  *  Sets selections of all boxes in current FilterViewerDataLine
 371  *  to default value (0)
 372  *  @param fvdl pointer to current FilterViewerDataLine
 373  */
 374 void gui_filter_line_reset(FilterViewerDataLine *fvdl) {
 375
 376   gtk_combo_box_set_active(GTK_COMBO_BOX(fvdl->f_not_op_box),0);
 377   gtk_combo_box_set_active(GTK_COMBO_BOX(fvdl->f_field_box),0);
 378   gtk_combo_box_set_active(GTK_COMBO_BOX(fvdl->f_math_op_box),0);
 379   gtk_entry_set_text(GTK_COMBO_BOX(fvdl->f_value_field),"");
 380   gtk_combo_box_set_active(GTK_COMBO_BOX(fvdl->f_logical_op_box),0);
 381 }
 382
 383 /**
 384  *  @fn gui_filter_destructor(FilterViewerData*)
 385  *
 386  *  Destructor for the filter gui module
 387  *  @param fvd The module structure
 388  */
 389 void
 390 gui_filter_destructor(FilterViewerData *fvd)
 391 {
 392   Tab *tab = fvd->tab;
 393
 394   /* May already been done by GTK window closing */
 395   if(GTK_IS_WIDGET(guifilter_get_widget(fvd))){
 396     g_info("widget still exists");
 397   }
 398   if(tab != NULL) {
 399     lttvwindow_unregister_traceset_notify(fvd->tab,
 400                                           filter_traceset_changed,
 401                                           filter_viewer_data);
 402   }
 403   lttvwindowtraces_background_notify_remove(fvd);
 404
 405   g_free(fvd);
 406 }
 407
 408 /**
 409  *  @fn filter_traceset_changed(void*,void*)
 410  *
 411  *  Hook function
 412  *  @param hook_data The hook data
 413  *  @param call_data The call data
 414  *  @return Success/Failure of operation
 415  */
 416 gboolean
 417 filter_traceset_changed(void * hook_data, void * call_data) {
 418
 419   return FALSE;
 420 }
 421
 422 /**
 423  *  @fn filter_viewer_data(void*,void*)
 424  *
 425  *  Hook function
 426  *  @param hook_data The hook data
 427  *  @param call_data The call data
 428  *  @return Success/Failure of operation
 429  */
 430 gboolean
 431 filter_viewer_data(void * hook_data, void * call_data) {
 432
 433   return FALSE;
 434 }
 435
 436 /**
 437  *  @fn h_guifilter(Tab*)
 438  *
 439  *  Filter Module's constructor hook
 440  *
 441  *  This constructor is given as a parameter to the menuitem and toolbar button
 442  *  registration. It creates the list.
 443  *  @param tab A pointer to the parent window.
 444  *  @return The widget created.
 445  */
 446 GtkWidget *
 447 h_guifilter(Tab *tab)
 448 {
 449   FilterViewerData* f = gui_filter(tab) ;
 450
 451   g_print("FilterViewerData:%p\n",f);
 452   if(f)
 453     return guifilter_get_widget(f);
 454   else return NULL;
 455
 456 }
 457
 458 /**
 459  *  @fn init()
 460  *
 461  *  This function initializes the Filter Viewer functionnality through the
 462  *  gtkTraceSet API.
 463  */
 464 static void init() {
 465
 466   lttvwindow_register_constructor("guifilter",
 467                                   "/",
 468                                   "Insert Filter Module",
 469                                   hGuiFilterInsert_xpm,
 470                                   "Insert Filter Module",
 471                                   h_guifilter);
 472 }
 473
 474 /**
 475  *  @fn filter_destroy_walk(gpointer,gpointer)
 476  *
 477  *  Initiate the destruction of the current gui module
 478  *  on the GTK Interface
 479  */
 480 void filter_destroy_walk(gpointer data, gpointer user_data)
 481 {
 482   FilterViewerData *fvd = (FilterViewerData*)data;
 483
 484   g_debug("CFV.c : filter_destroy_walk, %p", fvd);
 485   /* May already have been done by GTK window closing */
 486   if(GTK_IS_WIDGET(guifilter_get_widget(fvd)))
 487     gtk_widget_destroy(guifilter_get_widget(fvd));
 488 }
 489
 490 /**
 491  *  @fn destroy()
 492  *  @brief plugin's destroy function
 493  *
 494  *  This function releases the memory reserved by the module and unregisters
 495  *  everything that has been registered in the gtkTraceSet API.
 496  */
 497 static void destroy() {
 498
 499   lttvwindow_unregister_constructor(h_guifilter);
 500
 501 }
 502
 503 /**
 504  *  @fn callback_process_button(GtkWidget*,gpointer)
 505  *
 506  *  The Process Button callback function
 507  *  @param widget The Button widget passed to the callback function
 508  *  @param data Data sent along with the callback function
 509  */
 510 void callback_process_button(GtkWidget *widget, gpointer data) {
 511
 512   FilterViewerData *fvd = (FilterViewerData*)data;
 513
 514   if(strlen(gtk_entry_get_text(GTK_ENTRY(fvd->f_expression_field))) !=0) {
 515     LttvFilter* filter = lttv_filter_new();
 516     lttv_filter_append_expression(filter,gtk_entry_get_text(GTK_ENTRY(fvd->f_expression_field)));
 517     SetFilter(fvd->tab,filter);
 518   }
 519 }
 520
 521 /**
 522  *  @fn callback_expression_field(GtkWidget*,gpointer)
 523  *
 524  *  The Add Button callback function
 525  *  @param widget The Button widget passed to the callback function
 526  *  @param data Data sent along with the callback function
 527  */
 528 void callback_expression_field(GtkWidget *widget, gpointer data) {
 529
 530   FilterViewerData *fvd = (FilterViewerData*)data;
 531
 532   if(strlen(gtk_entry_get_text(GTK_ENTRY(fvd->f_expression_field))) !=0) {
 533     gtk_widget_show(fvd->f_logical_op_junction_box);
 534   } else {
 535     gtk_widget_hide(fvd->f_logical_op_junction_box);
 536   }
 537 }
 538
 539
 540 /**
 541  *  @fn callback_add_button(GtkWidget*,gpointer)
 542  *
 543  *  The Add Button callback function
 544  *  @param widget The Button widget passed to the callback function
 545  *  @param data Data sent along with the callback function
 546  */
 547 void callback_add_button(GtkWidget *widget, gpointer data) {
 548
 549   g_print("filter::callback_add_button()\n");
 550
 551   FilterViewerData *fvd = (FilterViewerData*)data;
 552   FilterViewerDataLine *fvdl = NULL;
 553   GString* a_filter_string = g_string_new("");
 554
 555   GString* s;
 556   s = g_ptr_array_index(fvd->f_logical_op_options,gtk_combo_box_get_active(GTK_COMBO_BOX(fvd->f_logical_op_junction_box)));
 557   g_print("s:%p\n",s);
 558   g_print("string:%s\n",s);
 559   g_string_append(a_filter_string,s->str);
 560   gtk_combo_box_set_active(fvd->f_logical_op_junction_box,0);
 561
 562   g_print("passe junction\n");
 563
 564   g_string_append_c(a_filter_string,'(');
 565
 566   int i;
 567   for(i=0;i<fvd->f_lines->len;i++) {
 568     fvdl = (FilterViewerDataLine*)g_ptr_array_index(fvd->f_lines,i);
 569
 570     s = g_ptr_array_index(fvd->f_not_op_options,gtk_combo_box_get_active(GTK_COMBO_BOX(fvdl->f_not_op_box)));
 571     g_string_append(a_filter_string,s->str);
 572
 573     s = g_ptr_array_index(fvd->f_field_options,gtk_combo_box_get_active(GTK_COMBO_BOX(fvdl->f_field_box)));
 574     g_string_append(a_filter_string,s->str);
 575
 576     s = g_ptr_array_index(fvd->f_math_op_options,gtk_combo_box_get_active(GTK_COMBO_BOX(fvdl->f_math_op_box)));
 577     g_string_append(a_filter_string,s->str);
 578
 579     g_string_append(a_filter_string,gtk_entry_get_text(GTK_ENTRY(fvdl->f_value_field)));
 580
 581     s = g_ptr_array_index(fvd->f_logical_op_options,gtk_combo_box_get_active(GTK_COMBO_BOX(fvdl->f_logical_op_box)));
 582     g_string_append(a_filter_string,s->str);
 583
 584     gui_filter_line_reset(fvdl);
 585     if(i) gui_filter_line_set_visible(fvdl,FALSE); // Only keep the first line
 586   }
 587
 588   g_string_append_c(a_filter_string,')');
 589
 590   g_string_prepend(a_filter_string,gtk_entry_get_text(GTK_ENTRY(fvd->f_expression_field)));
 591   gtk_entry_set_text(GTK_ENTRY(fvd->f_expression_field),a_filter_string->str);
 592
 593 }
 594
 595 /**
 596  *  @fn callback_logical_op_box(GtkWidget*,gpointer)
 597  *
 598  *  The logical op box callback function
 599  *  @param widget The Button widget passed to the callback function
 600  *  @param data Data sent along with the callback function
 601  */
 602 void callback_logical_op_box(GtkWidget *widget, gpointer data) {
 603
 604   g_print("filter::callback_logical_op_box()\n");
 605
 606   FilterViewerData *fvd = (FilterViewerData*)data;
 607   FilterViewerDataLine *fvdl = NULL;
 608
 609   int i;
 610   for(i=0;i<fvd->f_lines->len;i++) {
 611     fvdl = (FilterViewerDataLine*)g_ptr_array_index(fvd->f_lines,i);
 612     if(fvdl->f_logical_op_box == widget) {
 613       if(gtk_combo_box_get_active(fvdl->f_logical_op_box) == 0) return;
 614       if(i==fvd->f_lines->len-1) {  /* create a new line */
 615         fvd->rows++;
 616         FilterViewerDataLine* fvdl2 = gui_filter_add_line(fvd);
 617         g_ptr_array_add(fvd->f_lines,(gpointer) fvdl2);
 618       } else {
 619         FilterViewerDataLine *fvdl2 = (FilterViewerDataLine*)g_ptr_array_index(fvd->f_lines,i+1);
 620         if(!fvdl2->visible) gui_filter_line_set_visible(fvdl2,TRUE);
 621       }
 622     }
 623   }
 624
 625 }
 626
 627 LTTV_MODULE("guifilter", "Filter window", \
 628     "Graphical module that let user specify their filtering options", \
 629     init, destroy, "lttvwindow")
 630