projects / lttv.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Fix some warnings in lttv/modules/gui
[lttv.git] / 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 #ifdef HAVE_CONFIG_H
20 #include <config.h>
21 #endif
22
23 #include <glib.h>
24 #include <string.h>
25 #include <gtk/gtk.h>
26 #include <gdk/gdk.h>
27 #include <gdk/gdkkeysyms.h>
28
29 #include <lttv/lttv.h>
30 #include <lttv/module.h>
31 #include <lttv/hook.h>
32 #include <lttv/filter.h>
33
34 #include <lttvwindow/lttvwindow.h>
35 #include <lttvwindow/lttvwindowtraces.h>
36
37 #include "hGuiFilterInsert.xpm"
38
39
40 GSList *g_filter_list = NULL ;
41
42 /*! \file lttv/modules/gui/filter/filter.c
43 * \brief Graphic filter interface.
44 *
45 * The gui filter facility gives the user an easy to use
46 * basic interface to construct and modify at will a filter
47 * expression. User may either decide to write it himself in
48 * expression text entry or add simple expressions using the
49 * many choices boxes.
50 *
51 * \note The version of gtk-2.0 currently installed on
52 * my desktop misses some function of the newer
53 * gtk+ api. For the time being, I'll use the older api
54 * to keep compatibility with most systems.
55 */
56
57 typedef struct _FilterViewerData FilterViewerData;
58 typedef struct _FilterViewerDataLine FilterViewerDataLine;
59
60 /*
61 * Prototypes
62 */
63 GtkWidget *guifilter_get_widget(FilterViewerData *fvd);
64 FilterViewerData *gui_filter(LttvPlugin *plugin);
65 void gui_filter_destructor(FilterViewerData *fvd);
66 FilterViewerDataLine* gui_filter_add_line(FilterViewerData *fvd);
67 void gui_filter_line_set_visible(FilterViewerDataLine *fvdl, gboolean v);
68 void gui_filter_line_reset(FilterViewerDataLine *fvdl);
69 GtkWidget* h_guifilter(LttvPlugin *plugin);
70 void filter_destroy_walk(gpointer data, gpointer user_data);
71
72 /*
73 * Callback functions
74 */
75 void callback_process_button(GtkWidget *widget, gpointer data);
76 gboolean callback_enter_check(GtkWidget *widget,
77 GdkEventKey *event,
78 gpointer user_data);
79 void callback_add_button(GtkWidget *widget, gpointer data);
80 void callback_logical_op_box(GtkWidget *widget, gpointer data);
81 void callback_expression_field(GtkWidget *widget, gpointer data);
82 void callback_cancel_button(GtkWidget *widget, gpointer data);
83
84 /**
85 * @struct _FilterViewerDataLine
86 *
87 * @brief Defines a simple expression
88 * This structures defines a simple
89 * expression whithin the main filter
90 * viewer data
91 */
92 struct _FilterViewerDataLine {
93 int row; /**< row number */
94 gboolean visible; /**< visible state */
95 GtkWidget *f_not_op_box; /**< '!' operator (GtkComboBox) */
96 GtkWidget *f_logical_op_box; /**< '&,|,^' operators (GtkComboBox) */
97 GtkWidget *f_field_box; /**< field types (GtkComboBox) */
98 GtkWidget *f_math_op_box; /**< '>,>=,<,<=,=,!=' operators (GtkComboBox) */
99 GtkWidget *f_value_field; /**< expression's value (GtkComboBox) */
100 };
101
102 /**
103 * @struct _FilterViewerData
104 *
105 * @brief Main structure of gui filter
106 * Main struct for the filter gui module
107 */
108 struct _FilterViewerData {
109 LttvPlugin *plugin; /**< Plugin on which we interact. */
110
111 GtkWidget *f_window; /**< filter window */
112
113 GtkWidget *f_main_box; /**< main container */
114
115 GtkWidget *f_expression_field; /**< entire expression (GtkEntry) */
116 GtkWidget *f_process_button; /**< process expression button (GtkButton) */
117
118 GtkWidget *f_logical_op_junction_box; /**< linking operator box (GtkComboBox) */
119
120 int rows; /**< number of rows */
121 GPtrArray *f_lines; /**< array of FilterViewerDataLine */
122
123 GPtrArray *f_not_op_options; /**< array of operators types for not_op box */
124 GPtrArray *f_logical_op_options; /**< array of operators types for logical_op box */
125 GPtrArray *f_field_options; /**< array of field types for field box */
126 GPtrArray *f_math_op_options; /**< array of operators types for math_op box */
127
128 GtkWidget *f_add_button; /**< add expression to current expression (GtkButton) */
129 GtkWidget *f_cancel_button; /**< cancel and close dialog (GtkButton) */
130
131 };
132
133 /**
134 * @fn GtkWidget* guifilter_get_widget(FilterViewerData*)
135 *
136 * This function returns the current main widget
137 * used by this module
138 * @param fvd the module struct
139 * @return The main widget
140 */
141 GtkWidget*
142 guifilter_get_widget(FilterViewerData *fvd)
143 {
144 return fvd->f_window;
145 }
146
147 /**
148 * @fn FilterViewerData* gui_filter(Tab*)
149 *
150 * Constructor is used to create FilterViewerData data structure.
151 * @param tab The tab structure used by the widget
152 * @return The Filter viewer data created.
153 */
154 FilterViewerData*
155 gui_filter(LttvPlugin *plugin)
156 {
157 g_debug("filter::gui_filter()");
158
159 unsigned i;
160
161 FilterViewerData* fvd = g_new(FilterViewerData,1);
162
163 fvd->plugin = plugin;
164
165 // lttvwindow_register_traceset_notify(fvd->tab,
166 // filter_traceset_changed,
167 // filter_viewer_data);
168 // request_background_data(filter_viewer_data);
169
170 /*
171 * Initiating items for
172 * combo boxes
173 */
174 fvd->f_not_op_options = g_ptr_array_new();
175 g_ptr_array_add(fvd->f_not_op_options,(gpointer) g_string_new(""));
176 g_ptr_array_add(fvd->f_not_op_options,(gpointer) g_string_new("!"));
177
178 fvd->f_logical_op_options = g_ptr_array_new(); //g_array_new(FALSE,FALSE,sizeof(gchar));
179 g_ptr_array_add(fvd->f_logical_op_options,(gpointer) g_string_new(""));
180 g_ptr_array_add(fvd->f_logical_op_options,(gpointer) g_string_new("&"));
181 g_ptr_array_add(fvd->f_logical_op_options,(gpointer) g_string_new("|"));
182 g_ptr_array_add(fvd->f_logical_op_options,(gpointer) g_string_new("!"));
183 g_ptr_array_add(fvd->f_logical_op_options,(gpointer) g_string_new("^"));
184
185 fvd->f_field_options = g_ptr_array_new(); //g_array_new(FALSE,FALSE,16);
186 g_ptr_array_add(fvd->f_field_options,(gpointer) g_string_new(""));
187 g_ptr_array_add(fvd->f_field_options,(gpointer) g_string_new("event.name"));
188 g_ptr_array_add(fvd->f_field_options,(gpointer) g_string_new("event.subname"));
189 g_ptr_array_add(fvd->f_field_options,(gpointer) g_string_new("event.category"));
190 g_ptr_array_add(fvd->f_field_options,(gpointer) g_string_new("event.time"));
191 g_ptr_array_add(fvd->f_field_options,(gpointer) g_string_new("event.tsc"));
192 g_ptr_array_add(fvd->f_field_options,(gpointer) g_string_new("event.target_pid"));
193 /*
194 * TODO: Add core.xml fields here !
195 */
196 g_ptr_array_add(fvd->f_field_options,(gpointer) g_string_new("channel.name"));
197 g_ptr_array_add(fvd->f_field_options,(gpointer) g_string_new("trace.name"));
198 g_ptr_array_add(fvd->f_field_options,(gpointer) g_string_new("state.process_name"));
199 g_ptr_array_add(fvd->f_field_options,(gpointer) g_string_new("state.thread_brand"));
200 g_ptr_array_add(fvd->f_field_options,(gpointer) g_string_new("state.pid"));
201 g_ptr_array_add(fvd->f_field_options,(gpointer) g_string_new("state.ppid"));
202 g_ptr_array_add(fvd->f_field_options,(gpointer) g_string_new("state.creation_time"));
203 g_ptr_array_add(fvd->f_field_options,(gpointer) g_string_new("state.insertion_time"));
204 g_ptr_array_add(fvd->f_field_options,(gpointer) g_string_new("state.execution_mode"));
205 g_ptr_array_add(fvd->f_field_options,(gpointer) g_string_new("state.execution_submode"));
206 g_ptr_array_add(fvd->f_field_options,(gpointer) g_string_new("state.process_status"));
207 g_ptr_array_add(fvd->f_field_options,(gpointer) g_string_new("state.cpu"));
208
209 fvd->f_math_op_options = g_ptr_array_new(); //g_array_new(FALSE,FALSE,7);
210 g_ptr_array_add(fvd->f_math_op_options,(gpointer) g_string_new(""));
211 g_ptr_array_add(fvd->f_math_op_options,(gpointer) g_string_new("="));
212 g_ptr_array_add(fvd->f_math_op_options,(gpointer) g_string_new("!="));
213 g_ptr_array_add(fvd->f_math_op_options,(gpointer) g_string_new("<"));
214 g_ptr_array_add(fvd->f_math_op_options,(gpointer) g_string_new("<="));
215 g_ptr_array_add(fvd->f_math_op_options,(gpointer) g_string_new(">"));
216 g_ptr_array_add(fvd->f_math_op_options,(gpointer) g_string_new(">="));
217
218
219 fvd->f_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
220 gtk_window_set_title(GTK_WINDOW(fvd->f_window), "LTTV Filter");
221 gtk_window_set_transient_for(GTK_WINDOW(fvd->f_window),
222 GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(fvd->plugin->top_widget))));
223 gtk_window_set_destroy_with_parent(GTK_WINDOW(fvd->f_window), TRUE);
224 gtk_window_set_resizable(GTK_WINDOW(fvd->f_window), FALSE);
225
226 /*
227 * Initiating GtkTable layout
228 * starts with 2 rows and 5 columns and
229 * expands when expressions added
230 */
231 fvd->f_main_box = gtk_table_new(3,7,FALSE);
232 gtk_table_set_row_spacings(GTK_TABLE(fvd->f_main_box),5);
233 gtk_table_set_col_spacings(GTK_TABLE(fvd->f_main_box),5);
234
235 gtk_container_add(GTK_CONTAINER(fvd->f_window), GTK_WIDGET(fvd->f_main_box));
236
237 /*
238 * First half of the filter window
239 * - textual entry of filter expression
240 * - processing button
241 */
242 fvd->f_expression_field = gtk_entry_new(); //gtk_scrolled_window_new (NULL, NULL);
243 g_signal_connect (G_OBJECT(fvd->f_expression_field),
244 "key-press-event", G_CALLBACK (callback_enter_check), (gpointer)fvd);
245 // gtk_entry_set_text(GTK_ENTRY(fvd->f_expression_field),"state.cpu>0");
246 gtk_widget_show (fvd->f_expression_field);
247
248 g_signal_connect (G_OBJECT (fvd->f_expression_field), "changed",
249 G_CALLBACK (callback_expression_field), (gpointer) fvd);
250
251 fvd->f_process_button = gtk_button_new_with_label("Process");
252 gtk_widget_show (fvd->f_process_button);
253
254 g_signal_connect (G_OBJECT (fvd->f_process_button), "clicked",
255 G_CALLBACK (callback_process_button), (gpointer) fvd);
256
257 gtk_table_attach( GTK_TABLE(fvd->f_main_box),fvd->f_expression_field,0,6,0,1,GTK_FILL,GTK_FILL,0,0);
258 gtk_table_attach( GTK_TABLE(fvd->f_main_box),fvd->f_process_button,6,7,0,1,GTK_FILL,GTK_FILL,0,0);
259
260
261
262 /*
263 * Second half of the filter window
264 * - combo boxes featuring filtering options added to the expression
265 */
266 fvd->f_add_button = gtk_button_new_with_label("Add Expression");
267 gtk_widget_show (fvd->f_add_button);
268
269 g_signal_connect (G_OBJECT (fvd->f_add_button), "clicked",
270 G_CALLBACK (callback_add_button), (gpointer) fvd);
271
272 gtk_table_attach( GTK_TABLE(fvd->f_main_box),fvd->f_add_button,6,7,2,3,GTK_FILL,GTK_FILL,0,0);
273
274 fvd->f_cancel_button = gtk_button_new_with_label("Cancel");
275 gtk_widget_show (fvd->f_cancel_button);
276 g_signal_connect (G_OBJECT (fvd->f_cancel_button), "clicked",
277 G_CALLBACK (callback_cancel_button), (gpointer) fvd);
278
279 gtk_table_attach( GTK_TABLE(fvd->f_main_box),fvd->f_cancel_button,6,7,1,2,GTK_FILL,GTK_FILL,0,0);
280
281 fvd->f_logical_op_junction_box = gtk_combo_box_new_text();
282 for(i=0;i<fvd->f_logical_op_options->len;i++) {
283 GString* s = g_ptr_array_index(fvd->f_logical_op_options,i);
284 gtk_combo_box_append_text(GTK_COMBO_BOX(fvd->f_logical_op_junction_box), s->str);
285 }
286 gtk_combo_box_set_active(GTK_COMBO_BOX(fvd->f_logical_op_junction_box),0);
287
288 //gtk_widget_show(fvd->f_logical_op_box);
289
290 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);
291
292 gtk_container_set_border_width(GTK_CONTAINER(fvd->f_main_box), 1);
293
294 /* initialize a new line */
295 fvd->f_lines = g_ptr_array_new();
296 fvd->rows = 1;
297 FilterViewerDataLine* fvdl = gui_filter_add_line(fvd);
298 g_ptr_array_add(fvd->f_lines,(gpointer) fvdl);
299
300 /*
301 * show main container
302 */
303 gtk_widget_show(fvd->f_main_box);
304 gtk_widget_show(fvd->f_window);
305
306
307 g_object_set_data_full(
308 G_OBJECT(guifilter_get_widget(fvd)),
309 "filter_viewer_data",
310 fvd,
311 (GDestroyNotify)gui_filter_destructor);
312
313 g_filter_list = g_slist_append(
314 g_filter_list,
315 fvd);
316
317 return fvd;
318 }
319
320 /**
321 * @fn FilterViewerDataLine* gui_filter_add_line(FilterViewerData*)
322 *
323 * Adds a filter option line on the module tab
324 * @param fvd The filter module structure
325 * @return The line structure
326 */
327 FilterViewerDataLine*
328 gui_filter_add_line(FilterViewerData* fvd) {
329
330 FilterViewerDataLine* fvdl = g_new(FilterViewerDataLine,1);
331
332 unsigned i;
333 fvdl->row = fvd->rows;
334 fvdl->visible = TRUE;
335
336 fvdl->f_not_op_box = gtk_combo_box_new_text();
337 for(i=0;i<fvd->f_not_op_options->len;i++) {
338 GString* s = g_ptr_array_index(fvd->f_not_op_options,i);
339 gtk_combo_box_append_text(GTK_COMBO_BOX(fvdl->f_not_op_box), s->str);
340 }
341
342 fvdl->f_field_box = gtk_combo_box_new_text();
343 for(i=0;i<fvd->f_field_options->len;i++) {
344 GString* s = g_ptr_array_index(fvd->f_field_options,i);
345 // g_print("String field: %s\n",s->str);
346 gtk_combo_box_append_text(GTK_COMBO_BOX(fvdl->f_field_box), s->str);
347 }
348
349 fvdl->f_math_op_box = gtk_combo_box_new_text();
350 for(i=0;i<fvd->f_math_op_options->len;i++) {
351 GString* s = g_ptr_array_index(fvd->f_math_op_options,i);
352 gtk_combo_box_append_text(GTK_COMBO_BOX(fvdl->f_math_op_box), s->str);
353 }
354
355 fvdl->f_value_field = gtk_entry_new();
356
357 fvdl->f_logical_op_box = gtk_combo_box_new_text();
358 for(i=0;i<fvd->f_logical_op_options->len;i++) {
359 GString* s = g_ptr_array_index(fvd->f_logical_op_options,i);
360 gtk_combo_box_append_text(GTK_COMBO_BOX(fvdl->f_logical_op_box), s->str);
361 }
362 gtk_widget_set_events(fvdl->f_logical_op_box,
363 GDK_ENTER_NOTIFY_MASK |
364 GDK_LEAVE_NOTIFY_MASK |
365 GDK_FOCUS_CHANGE_MASK);
366
367 g_signal_connect (G_OBJECT (fvdl->f_logical_op_box), "changed",
368 G_CALLBACK (callback_logical_op_box), (gpointer) fvd);
369
370 gui_filter_line_reset(fvdl);
371 gui_filter_line_set_visible(fvdl,TRUE);
372
373 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);
374 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);
375 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);
376 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);
377 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);
378
379 return fvdl;
380 }
381
382 /**
383 * @fn void gui_filter_line_set_visible(FilterViewerDataLine*,gboolean)
384 *
385 * Change visible state of current FilterViewerDataLine
386 * @param fvdl pointer to the current FilterViewerDataLine
387 * @param v TRUE: sets visible, FALSE: sets invisible
388 */
389 void
390 gui_filter_line_set_visible(FilterViewerDataLine *fvdl, gboolean v) {
391
392 fvdl->visible = v;
393 if(v) {
394 gtk_widget_show(fvdl->f_not_op_box);
395 gtk_widget_show(fvdl->f_field_box);
396 gtk_widget_show(fvdl->f_math_op_box);
397 gtk_widget_show(fvdl->f_value_field);
398 gtk_widget_show(fvdl->f_logical_op_box);
399 } else {
400 gtk_widget_hide(fvdl->f_not_op_box);
401 gtk_widget_hide(fvdl->f_field_box);
402 gtk_widget_hide(fvdl->f_math_op_box);
403 gtk_widget_hide(fvdl->f_value_field);
404 gtk_widget_hide(fvdl->f_logical_op_box);
405 }
406
407 }
408
409 /**
410 * @fn void gui_filter_line_reset(FilterViewerDataLine*)
411 *
412 * Sets selections of all boxes in current FilterViewerDataLine
413 * to default value (0)
414 * @param fvdl pointer to current FilterViewerDataLine
415 */
416 void
417 gui_filter_line_reset(FilterViewerDataLine *fvdl) {
418
419 gtk_combo_box_set_active(GTK_COMBO_BOX(fvdl->f_not_op_box),0);
420 gtk_combo_box_set_active(GTK_COMBO_BOX(fvdl->f_field_box),0);
421 gtk_combo_box_set_active(GTK_COMBO_BOX(fvdl->f_math_op_box),0);
422 gtk_entry_set_text(GTK_ENTRY(fvdl->f_value_field),"");
423 gtk_combo_box_set_active(GTK_COMBO_BOX(fvdl->f_logical_op_box),0);
424 }
425
426 /**
427 * @fn void gui_filter_destructor(FilterViewerData*)
428 *
429 * Destructor for the filter gui module
430 * @param fvd The module structure
431 */
432 void
433 gui_filter_destructor(FilterViewerData *fvd)
434 {
435 /* May already been done by GTK window closing */
436 if(GTK_IS_WIDGET(guifilter_get_widget(fvd))){
437 g_info("widget still exists");
438 }
439 // if(tab != NULL) {
440 // lttvwindow_unregister_traceset_notify(fvd->tab,
441 // filter_traceset_changed,
442 // filter_viewer_data);
443 // }
444 lttvwindowtraces_background_notify_remove(fvd);
445
446 g_filter_list = g_slist_remove(g_filter_list, fvd);
447
448 g_free(fvd);
449 }
450
451
452 /**
453 * @fn GtkWidget* h_guifilter(Tab*)
454 *
455 * Filter Module's constructor hook
456 *
457 * This constructor is given as a parameter to the menuitem and toolbar button
458 * registration. It creates the list.
459 * @param obj Object to interact with.
460 * @return The widget created.
461 */
462 GtkWidget *
463 h_guifilter(LttvPlugin *plugin)
464 {
465 return NULL;
466 }
467
468 /**
469 * @fn static void init()
470 *
471 * This function initializes the Filter Viewer functionnality through the
472 * gtkTraceSet API.
473 */
474 static void init() {
475
476 lttvwindow_register_constructor("guifilter",
477 "/",
478 "Insert Filter Module",
479 hGuiFilterInsert_xpm,
480 "Insert Filter Module",
481 h_guifilter);
482 }
483
484 /**
485 * @fn void filter_destroy_walk(gpointer,gpointer)
486 *
487 * Initiate the destruction of the current gui module
488 * on the GTK Interface
489 */
490 void
491 filter_destroy_walk(gpointer data, gpointer user_data)
492 {
493 FilterViewerData *fvd = (FilterViewerData*)data;
494
495 g_debug("CFV.c : filter_destroy_walk, %p", fvd);
496
497 /* May already have been done by GTK window closing */
498 if(GTK_IS_WIDGET(guifilter_get_widget(fvd)))
499 gtk_widget_destroy(guifilter_get_widget(fvd));
500 }
501
502 /**
503 * @fn static void destroy()
504 * @brief plugin's destroy function
505 *
506 * This function releases the memory reserved by the module and unregisters
507 * everything that has been registered in the gtkTraceSet API.
508 */
509 static void destroy() {
510
511 g_slist_foreach(g_filter_list, filter_destroy_walk, NULL );
512
513 lttvwindow_unregister_constructor(h_guifilter);
514
515 }
516
517 /**
518 * @fn void callback_process_button(GtkWidget*,gpointer)
519 *
520 * The Process Button callback function
521 * @param widget The Button widget passed to the callback function
522 * @param data Data sent along with the callback function
523 */
524 void
525 callback_process_button(GtkWidget *widget, gpointer data) {
526
527 g_debug("callback_process_button(): Processing expression");
528
529 FilterViewerData *fvd = (FilterViewerData*)data;
530 LttvFilter* filter;
531
532 if(strlen(gtk_entry_get_text(GTK_ENTRY(fvd->f_expression_field))) !=0) {
533 filter = lttv_filter_new();
534 GString* s = g_string_new(gtk_entry_get_text(GTK_ENTRY(fvd->f_expression_field)));
535 lttv_filter_append_expression(filter,s->str);
536 g_string_free(s,TRUE);
537 } else {
538 filter = NULL;
539 }
540 /* Remove the old filter if present */
541 //g_object_set_data_full(fvd->obj, "filter", filter,
542 // (GDestroyNotify)lttv_filter_destroy);
543 //g_object_notify(fvd->obj, "filter");
544 lttv_plugin_update_filter(fvd->plugin, filter);
545 }
546
547 /**
548 * @fn void callback_cancel_button(GtkWidget*,gpointer)
549 *
550 * The Cancel Button callback function
551 * @param widget The Button widget passed to the callback function
552 * @param data Data sent along with the callback function
553 */
554 void
555 callback_cancel_button(GtkWidget *widget, gpointer data) {
556
557 FilterViewerData *fvd = (FilterViewerData*)data;
558 gtk_widget_destroy(fvd->f_window);
559 }
560
561 gboolean callback_enter_check(GtkWidget *widget,
562 GdkEventKey *event,
563 gpointer user_data)
564 {
565 g_debug("typed : %x", event->keyval);
566 switch(event->keyval) {
567 case GDK_Return:
568 case GDK_KP_Enter:
569 case GDK_ISO_Enter:
570 case GDK_3270_Enter:
571 callback_process_button(widget, user_data);
572 break;
573 default:
574 break;
575 }
576 return FALSE;
577 }
578
579 /**
580 * @fn void callback_expression_field(GtkWidget*,gpointer)
581 *
582 * The Add Button callback function
583 * @param widget The Button widget passed to the callback function
584 * @param data Data sent along with the callback function
585 */
586 void
587 callback_expression_field(GtkWidget *widget, gpointer data) {
588
589 FilterViewerData *fvd = (FilterViewerData*)data;
590
591 if(strlen(gtk_entry_get_text(GTK_ENTRY(fvd->f_expression_field))) !=0) {
592 gtk_widget_show(fvd->f_logical_op_junction_box);
593 } else {
594 gtk_widget_hide(fvd->f_logical_op_junction_box);
595 }
596 }
597
598
599 /**
600 * @fn void callback_add_button(GtkWidget*,gpointer)
601 *
602 * The Add Button callback function
603 * @param widget The Button widget passed to the callback function
604 * @param data Data sent along with the callback function
605 */
606 void
607 callback_add_button(GtkWidget *widget, gpointer data) {
608
609 g_debug("callback_add_button(): processing simple expressions");
610
611 unsigned i;
612
613 FilterViewerData *fvd = (FilterViewerData*)data;
614 FilterViewerDataLine *fvdl = NULL;
615 GString* a_filter_string = g_string_new("");
616
617 /*
618 * adding linking operator to
619 * string
620 */
621 GString* s;
622 s = g_ptr_array_index(fvd->f_logical_op_options,gtk_combo_box_get_active(GTK_COMBO_BOX(fvd->f_logical_op_junction_box)));
623 a_filter_string = g_string_append(a_filter_string,s->str);
624 gtk_combo_box_set_active(GTK_COMBO_BOX(fvd->f_logical_op_junction_box),0);
625
626 /* begin expression */
627 a_filter_string = g_string_append_c(a_filter_string,'(');
628
629 /*
630 * For each simple expression, add the resulting string
631 * to the filter string
632 *
633 * Each simple expression takes the following schema
634 * [not operator '!',' '] [field type] [math operator '<','<=','>','>=','=','!='] [value]
635 */
636 for(i=0;i<fvd->f_lines->len;i++) {
637 fvdl = (FilterViewerDataLine*)g_ptr_array_index(fvd->f_lines,i);
638
639 s = g_ptr_array_index(fvd->f_not_op_options,gtk_combo_box_get_active(GTK_COMBO_BOX(fvdl->f_not_op_box)));
640 a_filter_string = g_string_append(a_filter_string,s->str);
641
642 s = g_ptr_array_index(fvd->f_field_options,gtk_combo_box_get_active(GTK_COMBO_BOX(fvdl->f_field_box)));
643 a_filter_string = g_string_append(a_filter_string,s->str);
644
645 s = g_ptr_array_index(fvd->f_math_op_options,gtk_combo_box_get_active(GTK_COMBO_BOX(fvdl->f_math_op_box)));
646 a_filter_string = g_string_append(a_filter_string,s->str);
647
648 a_filter_string = g_string_append(a_filter_string,gtk_entry_get_text(GTK_ENTRY(fvdl->f_value_field)));
649
650 s = g_ptr_array_index(fvd->f_logical_op_options,gtk_combo_box_get_active(GTK_COMBO_BOX(fvdl->f_logical_op_box)));
651 a_filter_string = g_string_append(a_filter_string,s->str);
652
653 /*
654 * resetting simple expression lines
655 */
656 gui_filter_line_reset(fvdl);
657 if(i) gui_filter_line_set_visible(fvdl,FALSE); // Only keep the first line
658 }
659
660 /* end expression */
661 a_filter_string = g_string_append_c(a_filter_string,')');
662
663 g_string_prepend(a_filter_string,gtk_entry_get_text(GTK_ENTRY(fvd->f_expression_field)));
664 gtk_entry_set_text(GTK_ENTRY(fvd->f_expression_field),a_filter_string->str);
665
666 }
667
668 /**
669 * @fn void callback_logical_op_box(GtkWidget*,gpointer)
670 *
671 * The logical op box callback function
672 * @param widget The Button widget passed to the callback function
673 * @param data Data sent along with the callback function
674 */
675 void
676 callback_logical_op_box(GtkWidget *widget, gpointer data) {
677
678 g_debug("callback_logical_op_box(): adding new simple expression");
679
680 FilterViewerData *fvd = (FilterViewerData*)data;
681 FilterViewerDataLine *fvdl = NULL;
682
683 int i;
684 for(i=0;i<fvd->f_lines->len;i++) {
685 fvdl = (FilterViewerDataLine*)g_ptr_array_index(fvd->f_lines,i);
686 if(fvdl->f_logical_op_box == widget) {
687 if(gtk_combo_box_get_active(GTK_COMBO_BOX(fvdl->f_logical_op_box)) == 0) return;
688 if(i==fvd->f_lines->len-1) { /* create a new line */
689 fvd->rows++;
690 FilterViewerDataLine* fvdl2 = gui_filter_add_line(fvd);
691 g_ptr_array_add(fvd->f_lines,(gpointer) fvdl2);
692 } else {
693 FilterViewerDataLine *fvdl2 = (FilterViewerDataLine*)g_ptr_array_index(fvd->f_lines,i+1);
694 if(!fvdl2->visible) gui_filter_line_set_visible(fvdl2,TRUE);
695 }
696 }
697 }
698
699 }
700
701 LTTV_MODULE("guifilter", "Filter window", \
702 "Graphical module that let user specify their filtering options", \
703 init, destroy, "lttvwindow")
704
LTTng 2.x Viewer (LTTV)
This page took 0.061335 seconds and 4 git commands to generate.