projects / lttv.git / blob
? search:


affd293dcc35c9bab35b3a0deb98619a2a5b3fb7
[lttv.git] / lttv / modules / gui / detailedevents / events.c
1 /* This file is part of the Linux Trace Toolkit viewer
2 * Copyright (C) 2003-2004 Mathieu Desnoyers and XangXiu Yang
3 * 2005 Mathieu Desnoyers
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License Version 2 as
7 * published by the Free Software Foundation;
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
17 * MA 02111-1307, USA.
18 */
19
20
21 //*! \defgroup GuiEvents libGuiEvents: The GUI Events display plugin */
22 /*\@{*/
23
24 /*! \file GuiEvents.c
25 * \brief Graphical plugin for showing events.
26 *
27 * This plugin lists all the events contained in the current time interval
28 * in a list.
29 *
30 * This plugin adds a Events Viewer functionnality to Linux TraceToolkit
31 * GUI when this plugin is loaded. The init and destroy functions add the
32 * viewer's insertion menu item and toolbar icon by calling viewer.h's
33 * API functions. Then, when a viewer's object is created, the constructor
34 * creates ans register through API functions what is needed to interact
35 * with the lttvwindow.
36 *
37 * Authors : Mathieu Desnoyers and XangXiu Yang, June to December 2003
38 * Inspired from original LTT, made by Karim Yaghmour
39 *
40 * Mostly rewritten by Mathieu Desnoyers, August 2005.
41 */
42
43 #ifdef HAVE_CONFIG_H
44 #include <config.h>
45 #endif
46
47 #include <math.h>
48
49 #include <glib.h>
50 #include <glib/gprintf.h>
51 #include <gtk/gtk.h>
52 #include <gdk/gdk.h>
53 #include <gdk/gdkx.h>
54 #include <string.h>
55
56 #include <lttv/lttv.h>
57 #include <lttv/module.h>
58 #include <lttv/hook.h>
59 #include <lttv/traceset.h>
60 #include <lttv/state.h>
61 #ifdef BABEL_CLEANUP
62 #include <lttv/filter.h>
63 #endif //babel_cleanup
64 #include <lttv/print.h>
65 #include <lttvwindow/lttvwindow.h>
66 #include <lttvwindow/lttvwindowtraces.h>
67 #include <lttvwindow/lttv_plugin_tab.h>
68 #include <lttvwindow/support.h>
69 #include "lttv_plugin_evd.h"
70
71 #include "events.h"
72 #include "hGuiEventsInsert.xpm"
73
74 #define g_info(format...) g_log (G_LOG_DOMAIN, G_LOG_LEVEL_INFO, format)
75
76 #ifndef g_debug
77 #define g_debug(format...) g_log (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, format)
78 #endif
79
80 #define abs(a) (((a)<0)?(-a):(a))
81 #define max(a,b) ((a)>(b)?(a):(b))
82 #define min(a,b) ((a)<(b)?(a):(b))
83
84 /** Array containing instanced objects. Used when module is unloaded */
85 static GSList *g_event_viewer_data_list = NULL ;
86
87 typedef enum _ScrollDirection{
88 SCROLL_STEP_UP,
89 SCROLL_STEP_DOWN,
90 SCROLL_PAGE_UP,
91 SCROLL_PAGE_DOWN,
92 SCROLL_JUMP,
93 SCROLL_NONE
94 } ScrollDirection;
95
96 /** hook functions for update time interval, current time ... */
97 gboolean update_current_time(void * hook_data, void * call_data);
98 gboolean update_current_position(void * hook_data, void * call_data);
99 //gboolean show_event_detail(void * hook_data, void * call_data);
100 gboolean traceset_changed(void * hook_data, void * call_data);
101 gboolean timespan_changed(void * hook_data, void * call_data);
102 #ifdef BABEL_CLEANUP
103 gboolean filter_changed(void * hook_data, void * call_data);
104 #endif // babel_cleanup
105 static void request_background_data(EventViewerData *event_viewer_data);
106
107 //! Event Viewer's constructor hook
108 GtkWidget *h_gui_events(LttvPlugin *plugin);
109 //! Event Viewer's constructor
110 EventViewerData *gui_events(LttvPluginTab *ptab);
111 //! Event Viewer's destructor
112 void gui_events_destructor(gpointer data);
113 void gui_events_free(gpointer data);
114
115 static gboolean
116 header_size_allocate(GtkWidget *widget,
117 GtkAllocation *allocation,
118 gpointer user_data);
119
120 void tree_v_set_cursor(EventViewerData *event_viewer_data);
121 void tree_v_get_cursor(EventViewerData *event_viewer_data);
122 static void redraw(EventViewerData *event_viewer_data);
123
124 /* Prototype for selection handler callback */
125 static void tree_selection_changed_cb (GtkTreeSelection *selection,
126 gpointer data);
127 static void v_scroll_cb (GtkAdjustment *adjustment, gpointer data);
128 static void tree_v_size_allocate_cb (GtkWidget *widget, GtkAllocation *alloc,
129 gpointer data);
130 static void tree_v_size_request_cb (GtkWidget *widget,
131 GtkRequisition *requisition, gpointer data);
132 static void tree_v_cursor_changed_cb (GtkWidget *widget, gpointer data);
133 static void tree_v_move_cursor_cb (GtkWidget *widget, GtkMovementStep arg1,
134 gint arg2, gpointer data);
135 static void filter_button (GtkToolButton *toolbutton,
136 gpointer user_data);
137 static gboolean tree_v_scroll_handler (GtkWidget *widget, GdkEventScroll *event, gpointer data);
138 static gboolean key_handler(GtkWidget *widget, GdkEventKey *event,
139 gpointer user_data);
140
141 static void adjust_event_viewer(double time, EventViewerData *event_viewer_data);
142
143 int event_hook(void *hook_data, void *call_data);
144
145 /* Enumeration of the columns */
146 enum
147 {
148 TRACE_NAME_COLUMN,
149 CPUID_COLUMN,
150 EVENT_COLUMN,
151 TIME_S_COLUMN,
152 TIME_NS_COLUMN,
153 PID_COLUMN,
154 EVENT_DESCR_COLUMN,
155 POSITION_COLUMN,
156 N_COLUMNS
157 };
158
159 /**
160 * Event Viewer's constructor hook
161 *
162 * This constructor is given as a parameter to the menuitem and toolbar button
163 * registration. It creates the list.
164 * @param parent_window A pointer to the parent window.
165 * @return The widget created.
166 */
167 GtkWidget *
168 h_gui_events(LttvPlugin *plugin)
169 {
170 LttvPluginTab *ptab = LTTV_PLUGIN_TAB(plugin);
171 EventViewerData* event_viewer_data = gui_events(ptab) ;
172 if(event_viewer_data)
173 return event_viewer_data->top_widget;
174 else return NULL;
175
176 }
177
178 /**
179 * Event Viewer's constructor
180 *
181 * This constructor is used to create EventViewerData data structure.
182 * @return The Event viewer data created.
183 */
184 EventViewerData *
185 gui_events(LttvPluginTab *ptab)
186 {
187 /*To disable the error bell when we reach the end(or the top) of the list of
188 event. Since we overload the management of the list*/
189 GtkSettings* gtk_settings = gtk_settings_get_default();
190 g_object_set(gtk_settings, "gtk-error-bell", FALSE, NULL);
191
192
193 LttTime end;
194 GtkTreeViewColumn *column;
195 GtkCellRenderer *renderer;
196 EventViewerData* event_viewer_data = g_new(EventViewerData,1);
197 LttvPluginEVD *plugin_evd = g_object_new(LTTV_TYPE_PLUGIN_EVD, NULL);
198 GtkTooltips *tooltips = gtk_tooltips_new();
199 plugin_evd->evd = event_viewer_data;
200 Tab *tab = ptab->tab;
201 event_viewer_data->tab = tab;
202 event_viewer_data->ptab = ptab;
203 GtkWidget *tmp_toolbar_icon;
204
205 LttvTraceset *ts =lttvwindow_get_traceset(event_viewer_data->tab);
206
207 event_viewer_data->event_hooks = lttv_hooks_new();
208 lttv_hooks_add(event_viewer_data->event_hooks,
209 event_hook,
210 event_viewer_data,
211 LTTV_PRIO_DEFAULT);
212
213 lttvwindow_register_current_time_notify(tab,
214 update_current_time,event_viewer_data);
215 lttvwindow_register_current_position_notify(tab,
216 update_current_position,event_viewer_data);
217 lttvwindow_register_traceset_notify(tab,
218 traceset_changed,event_viewer_data);
219 lttvwindow_register_timespan_notify(tab,
220 timespan_changed,event_viewer_data);
221 #ifdef BABEL_CLEANUP
222 lttvwindow_register_filter_notify(tab,
223 filter_changed, event_viewer_data);
224 #endif
225 lttvwindow_register_redraw_notify(tab,
226 evd_redraw_notify, event_viewer_data);
227 event_viewer_data->scroll_win = gtk_scrolled_window_new (NULL, NULL);
228 gtk_widget_show (event_viewer_data->scroll_win);
229 gtk_scrolled_window_set_policy(
230 GTK_SCROLLED_WINDOW(event_viewer_data->scroll_win),
231 GTK_POLICY_AUTOMATIC, GTK_POLICY_NEVER);
232
233 event_viewer_data->currently_selected_position =
234 lttv_traceset_create_current_position(ts);
235 event_viewer_data->first_event =
236 lttv_traceset_create_current_position(ts);
237 event_viewer_data->last_event =
238 lttv_traceset_create_current_position(ts);
239 event_viewer_data->main_win_filter = lttvwindow_get_filter(tab);
240
241 event_viewer_data->update_cursor = TRUE;
242 event_viewer_data->report_position = TRUE;
243
244 event_viewer_data->last_tree_update_time = 0;
245
246 event_viewer_data->init_done = 0;
247
248 /* Create a model for storing the data list */
249 event_viewer_data->store_m = gtk_list_store_new (
250 N_COLUMNS, /* Total number of columns */
251 G_TYPE_STRING, /* Trace name */
252 G_TYPE_UINT, /* CPUID */
253 G_TYPE_STRING, /* Event */
254 G_TYPE_UINT, /* Time s */
255 G_TYPE_UINT, /* Time ns */
256 G_TYPE_INT, /* PID */
257 G_TYPE_STRING, /* Event's description */
258 G_TYPE_POINTER);/* Position (not shown) */
259
260 event_viewer_data->pos = g_ptr_array_sized_new(10);
261
262 /* Create the viewer widget for the columned list */
263 event_viewer_data->tree_v =
264 gtk_tree_view_new_with_model (GTK_TREE_MODEL (event_viewer_data->store_m));
265
266 g_signal_connect (G_OBJECT (event_viewer_data->tree_v), "size-allocate",
267 G_CALLBACK (tree_v_size_allocate_cb),
268 event_viewer_data);
269 g_signal_connect (G_OBJECT (event_viewer_data->tree_v), "size-request",
270 G_CALLBACK (tree_v_size_request_cb),
271 event_viewer_data);
272
273 g_signal_connect (G_OBJECT (event_viewer_data->tree_v), "cursor-changed",
274 G_CALLBACK (tree_v_cursor_changed_cb),
275 event_viewer_data);
276
277 g_signal_connect (G_OBJECT (event_viewer_data->tree_v), "move-cursor",
278 G_CALLBACK (tree_v_move_cursor_cb),
279 event_viewer_data);
280
281 g_signal_connect (G_OBJECT(event_viewer_data->tree_v), "key-press-event",
282 G_CALLBACK(key_handler),
283 event_viewer_data);
284
285 g_signal_connect (G_OBJECT(event_viewer_data->tree_v), "scroll-event",
286 G_CALLBACK(tree_v_scroll_handler),
287 event_viewer_data);
288
289
290
291 // Use on each column!
292 //gtk_tree_view_column_set_sizing(event_viewer_data->tree_v,
293 //GTK_TREE_VIEW_COLUMN_FIXED);
294
295 /* The view now holds a reference. We can get rid of our own
296 * reference */
297 g_object_unref (G_OBJECT (event_viewer_data->store_m));
298
299
300 /* Create a column, associating the "text" attribute of the
301 * cell_renderer to the first column of the model */
302 /* Columns alignment : 0.0 : Left 0.5 : Center 1.0 : Right */
303 renderer = gtk_cell_renderer_text_new ();
304 column = gtk_tree_view_column_new_with_attributes ("Trace",
305 renderer,
306 "text", TRACE_NAME_COLUMN,
307 NULL);
308 gtk_tree_view_column_set_alignment (column, 0.0);
309 gtk_tree_view_column_set_fixed_width (column, 120);
310 gtk_tree_view_append_column (GTK_TREE_VIEW (event_viewer_data->tree_v),
311 column);
312
313 event_viewer_data->button = column->button;
314
315 g_signal_connect (G_OBJECT(event_viewer_data->button),
316 "size-allocate",
317 G_CALLBACK(header_size_allocate),
318 (gpointer)event_viewer_data);
319
320 renderer = gtk_cell_renderer_text_new ();
321 column = gtk_tree_view_column_new_with_attributes ("CPUID",
322 renderer,
323 "text", CPUID_COLUMN,
324 NULL);
325 gtk_tree_view_column_set_alignment (column, 0.0);
326 gtk_tree_view_column_set_fixed_width (column, 45);
327 gtk_tree_view_append_column (GTK_TREE_VIEW (event_viewer_data->tree_v),
328 column);
329
330 renderer = gtk_cell_renderer_text_new ();
331 column = gtk_tree_view_column_new_with_attributes ("Event",
332 renderer,
333 "text", EVENT_COLUMN,
334 NULL);
335 gtk_tree_view_column_set_alignment (column, 0.0);
336 gtk_tree_view_column_set_fixed_width (column, 120);
337 gtk_tree_view_append_column (GTK_TREE_VIEW (event_viewer_data->tree_v),
338 column);
339
340 renderer = gtk_cell_renderer_text_new ();
341 column = gtk_tree_view_column_new_with_attributes ("Time (s)",
342 renderer,
343 "text", TIME_S_COLUMN,
344 NULL);
345 gtk_tree_view_column_set_alignment (column, 1.0);
346 gtk_tree_view_column_set_fixed_width (column, 120);
347 gtk_tree_view_append_column (GTK_TREE_VIEW (event_viewer_data->tree_v),
348 column);
349
350 renderer = gtk_cell_renderer_text_new ();
351 column = gtk_tree_view_column_new_with_attributes ("Time (ns)",
352 renderer,
353 "text", TIME_NS_COLUMN,
354 NULL);
355 gtk_tree_view_column_set_alignment (column, 1.0);
356 gtk_tree_view_column_set_fixed_width (column, 120);
357 gtk_tree_view_append_column (GTK_TREE_VIEW (event_viewer_data->tree_v),
358 column);
359
360
361 renderer = gtk_cell_renderer_text_new ();
362 column = gtk_tree_view_column_new_with_attributes ("PID",
363 renderer,
364 "text", PID_COLUMN,
365 NULL);
366 gtk_tree_view_column_set_alignment (column, 1.0);
367 gtk_tree_view_column_set_fixed_width (column, 45);
368 gtk_tree_view_append_column (GTK_TREE_VIEW (event_viewer_data->tree_v),
369 column);
370
371 renderer = gtk_cell_renderer_text_new ();
372 column = gtk_tree_view_column_new_with_attributes ("Event Description",
373 renderer,
374 "text", EVENT_DESCR_COLUMN,
375 NULL);
376 gtk_tree_view_column_set_alignment (column, 0.0);
377 gtk_tree_view_append_column (GTK_TREE_VIEW (event_viewer_data->tree_v),
378 column);
379
380
381 /* Setup the selection handler */
382 event_viewer_data->select_c =
383 gtk_tree_view_get_selection (GTK_TREE_VIEW (event_viewer_data->tree_v));
384 gtk_tree_selection_set_mode (event_viewer_data->select_c,
385 GTK_SELECTION_SINGLE);
386 g_signal_connect (G_OBJECT (event_viewer_data->select_c), "changed",
387 G_CALLBACK (tree_selection_changed_cb),
388 event_viewer_data);
389
390 gtk_container_add (GTK_CONTAINER (event_viewer_data->scroll_win),
391 event_viewer_data->tree_v);
392
393 event_viewer_data->hbox_v = gtk_hbox_new(0, 0);
394 event_viewer_data->top_widget = event_viewer_data->hbox_v;
395 plugin_evd->parent.top_widget = event_viewer_data->hbox_v;
396
397 event_viewer_data->toolbar = gtk_toolbar_new();
398 gtk_toolbar_set_orientation(GTK_TOOLBAR(event_viewer_data->toolbar),
399 GTK_ORIENTATION_VERTICAL);
400
401 tmp_toolbar_icon = create_pixmap (main_window_get_widget(tab),
402 "guifilter16x16.png");
403 gtk_widget_show(tmp_toolbar_icon);
404 event_viewer_data->button_filter = gtk_tool_button_new(tmp_toolbar_icon,
405 "Filter");
406 g_signal_connect (G_OBJECT(event_viewer_data->button_filter),
407 "clicked",
408 G_CALLBACK (filter_button),
409 (gpointer)plugin_evd);
410 gtk_tool_item_set_tooltip(GTK_TOOL_ITEM(event_viewer_data->button_filter),
411 tooltips, "Open the filter window", NULL);
412 gtk_toolbar_insert(GTK_TOOLBAR(event_viewer_data->toolbar),
413 event_viewer_data->button_filter,
414 0);
415 gtk_toolbar_set_style(GTK_TOOLBAR(event_viewer_data->toolbar),
416 GTK_TOOLBAR_ICONS);
417 gtk_box_pack_start(GTK_BOX(event_viewer_data->hbox_v),
418 event_viewer_data->toolbar, FALSE, FALSE, 0);
419 event_viewer_data->filter = NULL;
420
421 gtk_box_pack_start(GTK_BOX(event_viewer_data->hbox_v),
422 event_viewer_data->scroll_win, TRUE, TRUE, 0);
423
424 gtk_container_set_border_width(GTK_CONTAINER(event_viewer_data->hbox_v), 1);
425
426 /* Create vertical scrollbar and pack it */
427 event_viewer_data->vscroll_vc = gtk_vscrollbar_new(NULL);
428 gtk_range_set_update_policy (GTK_RANGE(event_viewer_data->vscroll_vc),
429 GTK_UPDATE_CONTINUOUS);
430 // Changed by MD : more user friendly :)
431 //GTK_UPDATE_DISCONTINUOUS);
432 gtk_box_pack_start(GTK_BOX(event_viewer_data->hbox_v),
433 event_viewer_data->vscroll_vc, FALSE, TRUE, 0);
434
435 /* Get the vertical scrollbar's adjustment */
436 event_viewer_data->vadjust_c =
437 gtk_range_get_adjustment(GTK_RANGE(event_viewer_data->vscroll_vc));
438 event_viewer_data->vtree_adjust_c = gtk_tree_view_get_vadjustment(
439 GTK_TREE_VIEW (event_viewer_data->tree_v));
440
441 g_signal_connect (G_OBJECT (event_viewer_data->vadjust_c), "value-changed",
442 G_CALLBACK (v_scroll_cb),
443 event_viewer_data);
444 //TODO ybrosseau 2011-01-06: Fix comment
445 /* Set the upper bound to the last event number */
446 event_viewer_data->previous_value = 0;
447 event_viewer_data->vadjust_c->lower = 0.0;
448 //event_viewer_data->vadjust_c->upper = event_viewer_data->number_of_events;
449
450 LttTime time = lttvwindow_get_current_time(tab);
451 TimeInterval time_span = lttv_traceset_get_time_span_real(ts);
452 time = ltt_time_sub(time, time_span.start_time);
453 //TODO ybrosseau 2011-01-06: Which one do we keep?
454 #ifdef BABEL_CLEANUP
455 event_viewer_data->vadjust_c->value = ltt_time_to_double(time);
456 #endif //babel_cleanup
457 event_viewer_data->vadjust_c->value = 0.0;
458 event_viewer_data->vadjust_c->step_increment = 1.0;
459 event_viewer_data->vadjust_c->page_increment = 2.0;
460 // event_viewer_data->vtree_adjust_c->upper;
461 event_viewer_data->vadjust_c->page_size = 2.0;
462 // event_viewer_data->vtree_adjust_c->upper;
463 /* Raw event trace */
464 gtk_widget_show(GTK_WIDGET(event_viewer_data->button_filter));
465 gtk_widget_show(event_viewer_data->toolbar);
466 gtk_widget_show(event_viewer_data->hbox_v);
467 gtk_widget_show(event_viewer_data->tree_v);
468 gtk_widget_show(event_viewer_data->vscroll_vc);
469
470 /* Add the object's information to the module's array */
471 g_event_viewer_data_list = g_slist_append(g_event_viewer_data_list,
472 plugin_evd);
473
474 event_viewer_data->num_visible_events = 1;
475
476 //get the life span of the traceset and set the upper of the scroll bar
477
478 end = ltt_time_sub(time_span.end_time, time_span.start_time);
479
480 event_viewer_data->vadjust_c->upper = ltt_time_to_double(end);
481
482 /* Set the Selected Event */
483 // tree_v_set_cursor(event_viewer_data);
484
485 // event_viewer_data->current_time_updated = FALSE;
486 //
487 g_object_set_data_full(
488 G_OBJECT(event_viewer_data->hbox_v),
489 "plugin_data",
490 plugin_evd,
491 (GDestroyNotify)gui_events_free);
492
493 g_object_set_data(
494 G_OBJECT(event_viewer_data->hbox_v),
495 "event_viewer_data",
496 event_viewer_data);
497
498 event_viewer_data->background_info_waiting = 0;
499
500
501 request_background_data(event_viewer_data);
502 return event_viewer_data;
503 }
504
505
506
507 static gint background_ready(void *hook_data, void *call_data)
508 {
509 EventViewerData *event_viewer_data = (EventViewerData *)hook_data;
510
511 event_viewer_data->background_info_waiting--;
512
513 if(event_viewer_data->background_info_waiting == 0) {
514 g_message("event viewer : background computation data ready.");
515
516 evd_redraw_notify(event_viewer_data, NULL);
517 }
518
519 return 0;
520 }
521
522
523 static void request_background_data(EventViewerData *event_viewer_data)
524 {
525 LttvTraceset * ts =
526 lttvwindow_get_traceset(event_viewer_data->tab);
527 gint num_traces = ts->traces->len;
528 gint i;
529 LttvTrace *trace;
530
531 LttvHooks *background_ready_hook =
532 lttv_hooks_new();
533 lttv_hooks_add(background_ready_hook, background_ready, event_viewer_data,
534 LTTV_PRIO_DEFAULT);
535 event_viewer_data->background_info_waiting = 0;
536
537 for(i=0;i<num_traces;i++) {
538 trace = g_ptr_array_index(ts->traces,i);
539 #ifdef BABEL_CLEANUP
540 tstate = LTTV_TRACE_STATE(tsc->traces[i]);
541 #endif /*babel_cleanup*/
542
543 if(lttvwindowtraces_get_ready(g_quark_from_string("state"),trace)==FALSE
544 /*&& !tstate->has_precomputed_states*/) {
545
546 if(lttvwindowtraces_get_in_progress(g_quark_from_string("state"),
547 trace) == FALSE) {
548 /* We first remove requests that could have been done for the same
549 * information. Happens when two viewers ask for it before servicing
550 * starts.
551 */
552 if(!lttvwindowtraces_background_request_find(trace, "state"))
553 lttvwindowtraces_background_request_queue(
554 main_window_get_widget(event_viewer_data->tab), trace, "state");
555 lttvwindowtraces_background_notify_queue(event_viewer_data,
556 trace,
557 ltt_time_infinite,
558 NULL,
559 background_ready_hook);
560 event_viewer_data->background_info_waiting++;
561 } else { /* in progress */
562
563 lttvwindowtraces_background_notify_current(event_viewer_data,
564 trace,
565 ltt_time_infinite,
566 NULL,
567 background_ready_hook);
568 event_viewer_data->background_info_waiting++;
569 }
570 } else {
571 /* Data ready. By its nature, this viewer doesn't need to have
572 * its data ready hook called there, because a background
573 * request is always linked with a redraw.
574 */
575 }
576
577 }
578
579 lttv_hooks_destroy(background_ready_hook);
580 }
581
582 static gboolean
583 header_size_allocate(GtkWidget *widget,
584 GtkAllocation *allocation,
585 gpointer user_data)
586 {
587 EventViewerData *event_viewer_data = (EventViewerData*)user_data;
588
589 event_viewer_data->header_height = allocation->height;
590
591 return 0;
592 }
593
594
595 void tree_v_set_cursor(EventViewerData *event_viewer_data)
596 {
597 g_debug("set cursor cb - do nothing");
598
599 }
600
601 void tree_v_get_cursor(EventViewerData *event_viewer_data)
602 {
603 g_debug("get cursor cb - do nothing");
604
605
606 }
607
608 /* Filter out the key repeats that come too fast */
609 static gboolean key_handler(GtkWidget *widget, GdkEventKey *event,
610 gpointer user_data)
611 {
612 EventViewerData *evd = (EventViewerData *)user_data;
613
614 g_debug("event time : %u , last time : %u", event->time,
615 evd->last_tree_update_time);
616
617 if(guint32_before(event->time, evd->last_tree_update_time))
618 return TRUE;
619 else
620 return FALSE;
621 }
622
623 void tree_v_move_cursor_cb (GtkWidget *widget,
624 GtkMovementStep stepType,
625 gint arg2,
626 gpointer data)
627 {
628
629 GtkTreePath *path; // = gtk_tree_path_new();
630 EventViewerData *event_viewer_data = (EventViewerData*)data;
631
632 g_debug("move cursor cb");
633 //gtk_tree_view_get_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
634 // &path, NULL);
635 //if(path == NULL)
636 //{
637 /* No prior cursor, put it at beginning of page
638 * and let the execution do */
639 // path = gtk_tree_path_new_from_indices(0, -1);
640 // gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
641 // path, NULL, FALSE);
642 //}
643
644 //indices = gtk_tree_path_get_indices(path);
645
646 //value = gtk_adjustment_get_value(event_viewer_data->vadjust_c);
647
648 /* If events request pending, do nothing*/
649 if(lttvwindow_events_request_pending(event_viewer_data->tab)) return;
650
651 /* If no prior position... */
652
653
654 g_debug("tree view move cursor : stepType is %u and arg2 is %d",
655 (guint)stepType, arg2);
656
657 switch(stepType) {
658 case GTK_MOVEMENT_DISPLAY_LINES:
659 if(arg2 == 1) {
660 /* Move one line down */
661 LttvTracesetPosition *end_pos = 0;
662 if(event_viewer_data->pos->len > 0) {
663 end_pos =
664 (LttvTracesetPosition*)g_ptr_array_index(
665 event_viewer_data->pos,
666 event_viewer_data->pos->len-1);
667 }
668 if(!end_pos || lttv_traceset_position_compare(end_pos,
669 event_viewer_data->currently_selected_position) == 0) {
670 /* Must get down one event and select the last one */
671 gtk_tree_selection_unselect_all(gtk_tree_view_get_selection(
672 GTK_TREE_VIEW(event_viewer_data->tree_v)));
673 event_viewer_data->update_cursor = FALSE;
674 gtk_adjustment_set_value(event_viewer_data->vadjust_c,
675 gtk_adjustment_get_value(event_viewer_data->vadjust_c) + 1);
676 event_viewer_data->update_cursor = TRUE;
677 if(event_viewer_data->pos->len > 0) {
678 path = gtk_tree_path_new_from_indices(
679 max(0, event_viewer_data->pos->len - 1), -1);
680 if(path) {
681 gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
682 path, NULL, FALSE);
683 gtk_tree_path_free(path);
684 }
685 }
686 }
687
688 } else {
689 LttvTracesetPosition *begin_pos = 0;
690
691 if(event_viewer_data->pos->len > 0) {
692 /* Move one line up */
693 begin_pos =
694 (LttvTracesetPosition*)g_ptr_array_index(
695 event_viewer_data->pos,
696 0);
697 }
698 if(!begin_pos || lttv_traceset_position_compare(begin_pos,
699 event_viewer_data->currently_selected_position) == 0)
700
701
702 {
703 /* Must get up one event and select the first one */
704 gtk_tree_selection_unselect_all(gtk_tree_view_get_selection(
705 GTK_TREE_VIEW(event_viewer_data->tree_v)));
706 event_viewer_data->update_cursor = FALSE;
707 gtk_adjustment_set_value(event_viewer_data->vadjust_c,
708 gtk_adjustment_get_value(event_viewer_data->vadjust_c) - 1);
709 event_viewer_data->update_cursor = TRUE;
710 if(event_viewer_data->pos->len > 0) {
711 path = gtk_tree_path_new_from_indices(
712 0, -1);
713 if(path) {
714 gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
715 path, NULL, FALSE);
716 gtk_tree_path_free(path);
717 }
718 }
719 }
720
721 }
722 break;
723 case GTK_MOVEMENT_PAGES:
724 if(arg2 == 1) {
725 /* Move one page down */
726 LttvTracesetPosition *end_pos = 0;
727 if(event_viewer_data->pos->len > 0) {
728 end_pos =
729 (LttvTracesetPosition*)g_ptr_array_index(
730 event_viewer_data->pos,
731 event_viewer_data->pos->len-1);
732 }
733 if(!end_pos || lttv_traceset_position_compare(end_pos,
734 event_viewer_data->currently_selected_position) == 0) {
735 /* Must get down one page and select the last one */
736 gtk_tree_selection_unselect_all(gtk_tree_view_get_selection(
737 GTK_TREE_VIEW(event_viewer_data->tree_v)));
738 event_viewer_data->update_cursor = FALSE;
739 gtk_adjustment_set_value(event_viewer_data->vadjust_c,
740 gtk_adjustment_get_value(event_viewer_data->vadjust_c) + 2);
741 event_viewer_data->update_cursor = TRUE;
742 if(event_viewer_data->pos->len > 0) {
743 path = gtk_tree_path_new_from_indices(
744 event_viewer_data->pos->len - 1, -1);
745 if(path) {
746 gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
747 path, NULL, FALSE);
748 gtk_tree_path_free(path);
749 }
750 }
751 }
752 } else {
753 /* Move one page up */
754 LttvTracesetPosition *begin_pos = 0;
755
756 if(event_viewer_data->pos->len > 0) {
757 begin_pos =
758 (LttvTracesetPosition*)g_ptr_array_index(
759 event_viewer_data->pos,
760 0);
761 }
762 if(!begin_pos || lttv_traceset_position_compare(begin_pos,
763 event_viewer_data->currently_selected_position) == 0) {
764 /* Must get up one page and select the first one */
765 gtk_tree_selection_unselect_all(gtk_tree_view_get_selection(
766 GTK_TREE_VIEW(event_viewer_data->tree_v)));
767 event_viewer_data->update_cursor = FALSE;
768 gtk_adjustment_set_value(event_viewer_data->vadjust_c,
769 gtk_adjustment_get_value(event_viewer_data->vadjust_c) - 2);
770 event_viewer_data->update_cursor = TRUE;
771 if(event_viewer_data->pos->len > 0) {
772 path = gtk_tree_path_new_from_indices(
773 0, -1);
774 if(path) {
775 gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
776 path, NULL, FALSE);
777 gtk_tree_path_free(path);
778 }
779 }
780 }
781 }
782 break;
783 default:
784 break;
785 }
786 //gtk_tree_path_free(path);
787
788 }
789
790 static void filter_button (GtkToolButton *toolbutton,
791 gpointer user_data)
792 {
793 LttvPluginEVD *plugin_evd = (LttvPluginEVD*)user_data;
794 LttvAttribute *attribute;
795 LttvAttributeValue value;
796 gboolean ret;
797 g_printf("Filter button clicked\n");
798
799 attribute = LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(
800 LTTV_IATTRIBUTE(lttv_global_attributes()),
801 LTTV_VIEWER_CONSTRUCTORS));
802 g_assert(attribute);
803
804 ret = lttv_iattribute_find_by_path(LTTV_IATTRIBUTE(attribute),
805 "guifilter", LTTV_POINTER, &value);
806 g_assert(ret);
807 lttvwindow_viewer_constructor constructor =
808 (lttvwindow_viewer_constructor)*(value.v_pointer);
809 if(constructor) constructor(&plugin_evd->parent);
810 else g_warning("Filter module not loaded.");
811
812 //FIXME : viewer returned.
813 }
814
815 gboolean tree_v_scroll_handler (GtkWidget *widget, GdkEventScroll *event, gpointer data)
816 {
817 EventViewerData *event_viewer_data = (EventViewerData*) data;
818
819 switch(event->direction) {
820 case GDK_SCROLL_UP:
821 gtk_adjustment_set_value(event_viewer_data->vadjust_c,
822 gtk_adjustment_get_value(event_viewer_data->vadjust_c) - 1);
823 break;
824 case GDK_SCROLL_DOWN:
825 gtk_adjustment_set_value(event_viewer_data->vadjust_c,
826 gtk_adjustment_get_value(event_viewer_data->vadjust_c) + 1);
827 break;
828 default:
829 g_error("Only scroll up and down expected");
830 }
831 return TRUE;
832 }
833
834 void tree_v_cursor_changed_cb (GtkWidget *widget, gpointer data)
835 {
836
837 EventViewerData *event_viewer_data = (EventViewerData*) data;
838
839 Tab *tab = event_viewer_data->tab;
840 GtkTreeIter iter;
841 GtkTreeModel* model = GTK_TREE_MODEL(event_viewer_data->store_m);
842 GtkTreePath *path;
843 LttvTracesetPosition *pos;
844
845 g_debug("cursor changed cb");
846
847 /* On cursor change, modify the currently selected event by calling
848 * the right API function */
849 if(event_viewer_data->report_position) {
850 if(event_viewer_data->pos->len > 0) {
851 gtk_tree_view_get_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
852 &path, NULL);
853 if(path) {
854 if(gtk_tree_model_get_iter(model,&iter,path)){
855 gtk_tree_model_get(model, &iter, POSITION_COLUMN, &pos, -1);
856
857 if(lttv_traceset_position_compare(pos,
858 event_viewer_data->currently_selected_position) != 0) {
859 lttvwindow_report_current_position(tab, pos);
860 }
861 }else{
862 g_warning("Can not get iter\n");
863 }
864 gtk_tree_path_free(path);
865 }
866 }
867 }
868 }
869
870
871 static void tree_selection_changed_cb (GtkTreeSelection *selection,
872 gpointer data)
873 {
874 g_debug("tree sel changed cb - do nothing");
875
876
877 }
878
879 #if 0
880 static gint key_snooper(GtkWidget *grab_widget, GdkEventKey *event,
881 gpointer func_data)
882 {
883 return TRUE;
884 }
885 #endif //0
886
887 /* This callback may be recalled after a step up/down, but we don't want to lose
888 * the exact position : what we do is that we only set the value if it has
889 * changed : a step up/down that doesn't change the time value of the first
890 * event won't trigger a scrollbar change. */
891
892 void v_scroll_cb (GtkAdjustment *adjustment, gpointer data)
893 {
894 EventViewerData *event_viewer_data = (EventViewerData*)data;
895 g_debug("SCROLL begin");
896 g_debug("SCROLL values : %g , %g, %g",
897 adjustment->value, event_viewer_data->previous_value,
898 (adjustment->value - event_viewer_data->previous_value));
899
900 LttTime new_time_off = ltt_time_from_double(adjustment->value);
901 LttTime old_time_off = ltt_time_from_double(event_viewer_data->previous_value);
902 g_debug("SCROLL time values %lu.%lu, %lu.%lu", new_time_off.tv_sec,
903 new_time_off.tv_nsec, old_time_off.tv_sec, old_time_off.tv_nsec);
904 /* If same value : nothing to update */
905 if(ltt_time_compare(new_time_off, old_time_off) == 0)
906 return;
907
908 //LttTime old_time = event_viewer_data->first_event;
909
910
911 //gint snoop = gtk_key_snooper_install(key_snooper, NULL);
912
913 adjust_event_viewer(adjustment->value, event_viewer_data);
914
915 //gtk_key_snooper_remove(snoop);
916
917 g_debug("SCROLL end");
918 }
919
920 static __inline gint get_cell_height(GtkTreeView *TreeView)
921 {
922 gint height;
923 GtkTreeViewColumn *column = gtk_tree_view_get_column(TreeView, 0);
924
925 gtk_tree_view_column_cell_get_size(column, NULL, NULL, NULL, NULL, &height);
926
927 gint vertical_separator;
928 gtk_widget_style_get (GTK_WIDGET (TreeView),
929 "vertical-separator", &vertical_separator,
930 NULL);
931
932 height += vertical_separator;
933
934 return height;
935 }
936
937 void tree_v_size_allocate_cb (GtkWidget *widget, GtkAllocation *alloc, gpointer data)
938 {
939 EventViewerData *event_viewer_data = (EventViewerData*)data;
940 gint cell_height = get_cell_height(GTK_TREE_VIEW(event_viewer_data->tree_v));
941 gint last_num_visible_events = event_viewer_data->num_visible_events;
942 gdouble exact_num_visible;
943
944 exact_num_visible = ( alloc->height -
945 event_viewer_data->header_height )
946 / (double)cell_height ;
947
948 event_viewer_data->num_visible_events = ceil(exact_num_visible) ;
949
950 event_viewer_data->vadjust_c->page_increment =
951 floor(exact_num_visible);
952 event_viewer_data->vadjust_c->page_size =
953 floor(exact_num_visible);
954
955
956 g_debug("size allocate %p : last_num_visible_events : %d",
957 event_viewer_data, last_num_visible_events);
958 g_debug("num_visible_events : %d, value %f",
959 event_viewer_data->num_visible_events,
960 event_viewer_data->vadjust_c->value);
961
962 if(event_viewer_data->num_visible_events != last_num_visible_events) {
963 //TODO ybrosseau do a proper initialisation here, so we can use the redraw
964 adjust_event_viewer(event_viewer_data->vadjust_c->value, event_viewer_data);
965 //redraw(event_viewer_data);
966 }
967
968
969 }
970
971 void tree_v_size_request_cb (GtkWidget *widget, GtkRequisition *requisition, gpointer data)
972 {
973 gint h;
974 EventViewerData *event_viewer_data = (EventViewerData*)data;
975 gint cell_height = get_cell_height(GTK_TREE_VIEW(event_viewer_data->tree_v));
976
977 h = cell_height + event_viewer_data->header_height;
978 requisition->height = h;
979
980 }
981
982 static gboolean events_check_handler(guint count, gboolean *stop_flag,
983 gpointer data)
984 {
985 EventViewerData *evd = (EventViewerData*)data;
986 if(count % CHECK_GDK_INTERVAL == 0) {
987 GdkEvent *event;
988 GtkWidget *widget;
989 while((event = gdk_event_get()) != NULL) {
990 widget = gtk_get_event_widget(event);
991 if(widget ==
992 lookup_widget(main_window_get_widget(evd->tab),
993 "StopProcessingButton")
994 || widget == evd->vscroll_vc) {
995 gtk_main_do_event(event);
996 gdk_window_process_all_updates();
997 }
998 gdk_event_free(event);
999 }
1000 if(*stop_flag)
1001 return TRUE;
1002 else
1003 return FALSE;
1004 } else return FALSE;
1005 }
1006
1007
1008 /* This function will adjust the first event position for the viewer which
1009 will be used by the redraw to seek and display all the events
1010 */
1011 static void adjust_event_viewer(double new_value, EventViewerData *event_viewer_data)
1012 {
1013 #ifdef BABEL_CLEANUP
1014 LttvTracesetStats *tss =
1015 lttvwindow_get_traceset_stats(event_viewer_data->tab);
1016 #endif //babel_cleanup
1017 LttvTraceset *ts = lttvwindow_get_traceset(event_viewer_data->tab);
1018
1019 gboolean seek_by_time;
1020
1021 if(lttvwindow_preempt_count > 0) return;
1022
1023 double value = new_value - event_viewer_data->previous_value;
1024
1025 /* Set stop button status for foreground processing */
1026 event_viewer_data->tab->stop_foreground = FALSE;
1027 lttvwindow_events_request_disable();
1028
1029 /* See where we have to scroll... */
1030 ScrollDirection direction;
1031 gint relative_position;
1032
1033 if(value < -0.8) {
1034 if(value >= -1.0) direction = SCROLL_STEP_UP;
1035 else {
1036 if(value >= -2.0) direction = SCROLL_PAGE_UP;
1037 else direction = SCROLL_JUMP;
1038 }
1039 } else if(value > 0.8) {
1040 if(value <= 1.0) direction = SCROLL_STEP_DOWN;
1041 else {
1042 if(value <= 2.0) direction = SCROLL_PAGE_DOWN;
1043 else direction = SCROLL_JUMP;
1044 }
1045 } else direction = SCROLL_NONE; /* 0.0 */
1046
1047 switch(direction) {
1048 case SCROLL_STEP_UP:
1049 g_debug("adjust_event_viewer : SCROLL_STEP_UP");
1050 relative_position = -1;
1051 seek_by_time = 0;
1052 break;
1053 case SCROLL_STEP_DOWN:
1054 g_debug("adjust_event_viewer : SCROLL_STEP_DOWN");
1055 relative_position = 1;
1056 seek_by_time = 0;
1057 break;
1058 case SCROLL_PAGE_UP:
1059 g_debug("adjust_event_viewer : SCROLL_PAGE_UP");
1060 relative_position = -(event_viewer_data->num_visible_events);
1061 seek_by_time = 0;
1062 break;
1063 case SCROLL_PAGE_DOWN:
1064 g_debug("adjust_event_viewer : SCROLL_PAGE_DOWN");
1065 relative_position = event_viewer_data->num_visible_events;
1066 seek_by_time = 0;
1067 break;
1068 case SCROLL_JUMP:
1069 g_debug("adjust_event_viewer : SCROLL_JUMP");
1070 relative_position = 0;
1071 seek_by_time = 1;
1072 break;
1073 case SCROLL_NONE:
1074 g_debug("adjust_event_viewer : SCROLL_NONE");
1075 relative_position = 0;
1076 seek_by_time = 0;
1077 break;
1078 }
1079
1080 LttTime time = ltt_time_from_double(new_value);
1081 TimeInterval time_span = lttv_traceset_get_time_span_real(ts);
1082 time = ltt_time_add(time_span.start_time, time);
1083
1084 LttvTracesetPosition *timePos = lttv_traceset_create_time_position(ts,time);
1085
1086
1087 if(!seek_by_time) {
1088
1089 /* Remember the beginning position */
1090 if(event_viewer_data->pos->len > 0) {
1091
1092 if(relative_position != 0)
1093 {
1094 LttvTracesetPosition *pos = 0;
1095 pos = (LttvTracesetPosition*)g_ptr_array_index(
1096 event_viewer_data->pos,
1097 0);
1098 lttv_state_traceset_seek_position(ts,pos);
1099 }
1100 } else {
1101 lttv_state_traceset_seek_time(ts,time);
1102
1103 }
1104
1105 /* Note that, as we mess with the tsc position, this function CANNOT be called
1106 * from a hook inside the lttv_process_traceset_middle. */
1107 /* As the lttvwindow API keeps a sync_position inside the tsc to go back at
1108 * the right spot after being interrupted, it's ok to change the tsc position,
1109 * as long as we do not touch the sync_position. */
1110
1111 /* Get the beginning position of the read (with seek backward or seek forward)
1112 */
1113 if(relative_position > 0) {
1114 lttv_process_traceset_seek_n_forward(ts, relative_position,
1115 events_check_handler,
1116 &event_viewer_data->tab->stop_foreground,
1117 event_viewer_data->main_win_filter,
1118 event_viewer_data->filter, NULL, event_viewer_data);
1119 } else if(relative_position < 0) {
1120 /* Get an idea of currently shown event dispersion */
1121 guint64 first_event_time_stamp =
1122 lttv_traceset_position_get_timestamp(event_viewer_data->first_event);
1123 guint64 last_event_time_stamp =
1124 lttv_traceset_position_get_timestamp(event_viewer_data->last_event);
1125 guint64 timeSpan = (last_event_time_stamp - first_event_time_stamp);
1126 gdouble ratio = (gdouble)timeSpan / (gdouble)event_viewer_data->num_visible_events;
1127 if(ratio <= 0){
1128 ratio = SEEK_BACK_DEFAULT_RATIO;
1129 }
1130
1131 lttv_process_traceset_seek_n_backward(ts,
1132 (guint)abs(relative_position),
1133 ratio,
1134 events_check_handler,
1135 &event_viewer_data->tab->stop_foreground,
1136 event_viewer_data->main_win_filter,
1137 event_viewer_data->filter, NULL, event_viewer_data);
1138 } /* else 0 : do nothing : we are already at the beginning position */
1139
1140 /* Save the first event position */
1141
1142 event_viewer_data->first_event = lttv_traceset_create_current_position(ts);
1143
1144 time = ltt_time_from_uint64(lttv_traceset_position_get_timestamp(
1145 event_viewer_data->first_event));
1146 //if(ltt_time_compare(time, tsc->time_span.end_time) > 0)
1147 // time = tsc->time_span.end_time;
1148
1149 LttTime time_val = ltt_time_sub(time,time_span.start_time);
1150 event_viewer_data->previous_value = ltt_time_to_double(time_val);
1151
1152
1153 } else {
1154 /* Seek by time */
1155
1156 LttTime time_val = ltt_time_sub(time,time_span.start_time);
1157 event_viewer_data->previous_value = ltt_time_to_double(time_val);
1158 event_viewer_data->first_event = timePos;
1159 }
1160 lttvwindow_events_request_enable();
1161
1162 redraw(event_viewer_data);
1163 }
1164
1165 static void redraw(EventViewerData *event_viewer_data) {
1166 guint i;
1167 LttvTraceset *ts = lttvwindow_get_traceset(event_viewer_data->tab);
1168
1169 g_debug("EventViewer redraw");
1170
1171 //TODO ybrosseau verify its still required
1172 lttvwindow_events_request_disable();
1173
1174
1175 /* Clear the model (don't forget to free the TCS positions!) */
1176 gtk_list_store_clear(event_viewer_data->store_m);
1177 for(i=0;i<event_viewer_data->pos->len;i++) {
1178 LttvTracesetPosition *cur_pos =
1179 (LttvTracesetPosition*)g_ptr_array_index(event_viewer_data->pos,
1180 i);
1181 lttv_traceset_destroy_position(cur_pos);
1182 }
1183 g_ptr_array_set_size(event_viewer_data->pos, 0);
1184
1185 lttv_state_traceset_seek_position(ts, event_viewer_data->first_event);
1186
1187 /* Mathieu :
1188 * I make the choice not to use the mainwindow lttvwindow API here : the idle
1189 * loop might have a too low priority, and we want good update while
1190 * scrolling. However, we call the gdk loop to get events periodically so the
1191 * processing can be stopped.
1192 */
1193
1194 lttv_process_traceset_begin(ts,
1195 NULL, NULL, event_viewer_data->event_hooks);
1196
1197 event_viewer_data->num_events = 0;
1198
1199 lttv_process_traceset_middle(ts, ltt_time_infinite, G_MAXUINT, NULL);
1200
1201 lttv_process_traceset_end(ts, NULL, NULL, event_viewer_data->event_hooks);
1202
1203 /* Get the end position */
1204 if(event_viewer_data->pos->len > 0) {
1205 LttvTracesetPosition *cur_pos =
1206 (LttvTracesetPosition*)g_ptr_array_index(event_viewer_data->pos,
1207 event_viewer_data->pos->len - 1);
1208 event_viewer_data->last_event = cur_pos;
1209 } else
1210 event_viewer_data->last_event =lttv_traceset_create_current_position(ts);
1211
1212 gtk_adjustment_set_value(event_viewer_data->vadjust_c,
1213 event_viewer_data->previous_value);
1214
1215 //g_signal_emit_by_name(G_OBJECT (event_viewer_data->select_c),
1216 // "changed");
1217
1218 event_viewer_data->last_tree_update_time =
1219 gdk_x11_get_server_time(
1220 gtk_widget_get_parent_window(event_viewer_data->tree_v));
1221
1222 lttvwindow_events_request_enable();
1223
1224 return;
1225 }
1226
1227
1228 int event_hook(void *hook_data, void *call_data)
1229 {
1230
1231 EventViewerData *event_viewer_data = (EventViewerData*)hook_data;
1232
1233 LttvEvent * e = (LttvEvent *)call_data;
1234
1235 if(event_viewer_data->num_events % CHECK_GDK_INTERVAL == 0) {
1236 GdkEvent *event;
1237 GtkWidget *widget;
1238 while((event = gdk_event_get()) != NULL) {
1239 widget = gtk_get_event_widget(event);
1240 if(widget ==
1241 lookup_widget(main_window_get_widget(event_viewer_data->tab),
1242 "StopProcessingButton")
1243 || widget == event_viewer_data->vscroll_vc) {
1244 gtk_main_do_event(event);
1245 gdk_window_process_all_updates();
1246 }
1247 gdk_event_free(event);
1248 }
1249 //gtk_main_iteration_do(FALSE);
1250 if(event_viewer_data->tab->stop_foreground)
1251 return TRUE;
1252 }
1253
1254 event_viewer_data->num_events++;
1255 #ifdef BABEL_CLEANUP
1256 LttvFilter *filter = event_viewer_data->main_win_filter;
1257 if(filter != NULL && filter->head != NULL)
1258 if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
1259 tfc->t_context->t,tfc,NULL,NULL))
1260 return FALSE;
1261
1262 filter = event_viewer_data->filter;
1263 if(filter != NULL && filter->head != NULL)
1264 if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
1265 tfc->t_context->t,tfc,NULL,NULL))
1266 return FALSE;
1267 #endif //babel_cleanup
1268
1269 // LttFacility *facility = ltt_event_facility(e);
1270 // LttEventType *event_type = ltt_event_eventtype(e);
1271 LttTime time = lttv_event_get_timestamp(e);
1272 gint cpu = lttv_traceset_get_cpuid_from_event(e);
1273
1274 LttvTraceState *traceState = e->state;
1275 LttvProcessState *process = traceState->running_process[cpu];
1276
1277 GtkTreeIter iter;
1278
1279 GString *desc = g_string_new("");
1280 GString *name = g_string_new("");
1281
1282 LttvTracesetPosition *pos = lttv_traceset_create_current_position(traceState->trace->traceset);
1283
1284 lttv_event_to_string(e, desc, TRUE, FALSE);
1285 lttv_event_get_name(e,name);
1286
1287 g_info("detail : %s", desc->str);
1288
1289 gtk_list_store_append (event_viewer_data->store_m, &iter);
1290
1291 gtk_list_store_set (event_viewer_data->store_m, &iter,
1292 TRACE_NAME_COLUMN, traceState->trace->short_name,
1293 CPUID_COLUMN, cpu,
1294 EVENT_COLUMN,name->str,
1295 TIME_S_COLUMN, time.tv_sec,
1296 TIME_NS_COLUMN, time.tv_nsec,
1297 PID_COLUMN, process->pid,
1298 EVENT_DESCR_COLUMN, desc->str,
1299 POSITION_COLUMN, pos,
1300 -1);
1301
1302 g_ptr_array_add(event_viewer_data->pos, pos);
1303
1304 g_string_free(desc, TRUE);
1305 g_string_free(name, TRUE);
1306
1307 if(event_viewer_data->update_cursor) {
1308 if(lttv_traceset_position_compare(pos,
1309 event_viewer_data->currently_selected_position) == 0) {
1310 GtkTreePath *path = gtk_tree_path_new_from_indices(
1311 event_viewer_data->pos->len - 1, -1);
1312 if(path) {
1313 gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
1314 path, NULL, FALSE);
1315 gtk_tree_path_free(path);
1316 }
1317 }
1318 }
1319 if(event_viewer_data->pos->len >= event_viewer_data->num_visible_events )
1320 return TRUE;
1321 else
1322 return FALSE;
1323
1324 }
1325
1326
1327
1328 static void event_update_selection(EventViewerData *event_viewer_data)
1329 {
1330
1331 guint i;
1332 GPtrArray *positions = event_viewer_data->pos;
1333 g_info("event_update_selection");
1334
1335 int isFound = FALSE;
1336
1337
1338 for(i=0;i<positions->len;i++) {
1339 LttvTracesetPosition *cur_pos =
1340 (LttvTracesetPosition*)g_ptr_array_index(positions, i);
1341 if(lttv_traceset_position_compare(cur_pos,
1342 event_viewer_data->currently_selected_position) == 0) {
1343 GtkTreePath *path = gtk_tree_path_new_from_indices(i, -1);
1344 if(path) {
1345 gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
1346 path, NULL, FALSE);
1347 gtk_widget_grab_focus(event_viewer_data->tree_v );
1348 gtk_tree_path_free(path);
1349 isFound = TRUE;
1350 break;
1351 }
1352 }
1353 }
1354 if(isFound){
1355 return;
1356 }
1357 /* If the current selection is not in the currently displayed events*/
1358 LttTime currentTime = lttv_traceset_position_get_time(
1359 event_viewer_data->currently_selected_position);
1360 LttTime time;
1361
1362 LttvTraceset * ts = lttvwindow_get_traceset(event_viewer_data->tab);
1363 TimeInterval time_span = lttv_traceset_get_time_span_real(ts);
1364 time = ltt_time_sub(currentTime, time_span.start_time);
1365 gtk_adjustment_set_value(event_viewer_data->vadjust_c,
1366 ltt_time_to_double(time));
1367 gtk_widget_grab_focus(event_viewer_data->tree_v );
1368
1369 }
1370 #ifdef BABEL_CLEANUP
1371 static int current_time_get_first_event_hook(void *hook_data, void *call_data)
1372 {
1373
1374 EventViewerData *event_viewer_data = (EventViewerData*)hook_data;
1375
1376 LttvTracefileContext *tfc = (LttvTracefileContext*)call_data;
1377 LttEvent *e = ltt_tracefile_get_event(tfc->tf);
1378
1379 LttvFilter *filter = event_viewer_data->main_win_filter;
1380 if(filter != NULL && filter->head != NULL)
1381 if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
1382 tfc->t_context->t,tfc,NULL,NULL))
1383 return FALSE;
1384
1385 filter = event_viewer_data->filter;
1386 if(filter != NULL && filter->head != NULL)
1387 if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
1388 tfc->t_context->t,tfc,NULL,NULL))
1389 return FALSE;
1390
1391 lttv_traceset_context_position_save(tfc->t_context->ts_context,
1392 event_viewer_data->current_time_get_first);
1393 return TRUE;
1394
1395
1396 }
1397 #endif // BABEL_CLEANUP
1398
1399 gboolean update_current_time(void * hook_data, void * call_data)
1400 {
1401
1402 //LttvEvent * e = (LttvEvent *)call_data;
1403 g_info("update_current_time");
1404 EventViewerData *event_viewer_data = (EventViewerData*) hook_data;
1405
1406 const LttTime * current_time = (LttTime*)call_data;
1407 LttvTraceset * ts = lttvwindow_get_traceset(event_viewer_data->tab);
1408
1409 /* If the currently selected event time != current time, set the first event
1410 * with this time as currently selected. */
1411 LttTime pos_time = lttv_traceset_position_get_time(
1412 event_viewer_data->currently_selected_position);
1413
1414 if(ltt_time_compare(pos_time, *current_time) != 0) {
1415 /*create position*/
1416 //LttvTracesetPosition *currentPosition =
1417 // lttv_traceset_create_time_position(ts,*current_time );
1418 /*seek to current position*/
1419 lttv_state_traceset_seek_time(ts, *current_time);
1420
1421 event_viewer_data->currently_selected_position =
1422 lttv_traceset_create_current_position(ts);
1423 g_debug("update_current_time: %p %lu", event_viewer_data->currently_selected_position, event_viewer_data->currently_selected_position->timestamp);
1424 }
1425
1426 event_viewer_data->report_position = FALSE;
1427
1428 /* Simply update the current time : it is in the list */
1429 event_update_selection(event_viewer_data);
1430 event_viewer_data->report_position = TRUE;
1431
1432 return FALSE;
1433 }
1434
1435 gboolean update_current_position(void * hook_data, void * call_data)
1436 {
1437
1438 g_info("update_current_position");
1439 EventViewerData *event_viewer_data = (EventViewerData*) hook_data;
1440 const LttvTracesetPosition *current_pos = (LttvTracesetPosition*)call_data;
1441
1442 if(lttv_traceset_position_compare(
1443 event_viewer_data->currently_selected_position, current_pos) != 0) {
1444 g_debug("Update current pos: %p, %lu", current_pos, current_pos->timestamp);
1445 event_viewer_data->currently_selected_position = current_pos;
1446 /* Simply update the current time : it is in the list */
1447 event_update_selection(event_viewer_data);
1448 }
1449 return FALSE;
1450
1451 }
1452
1453 gboolean timespan_changed(void * hook_data, void * call_data)
1454 {
1455
1456 EventViewerData *event_viewer_data = (EventViewerData*) hook_data;
1457 LttvTraceset * ts = lttvwindow_get_traceset(event_viewer_data->tab);
1458 TimeInterval time_span = lttv_traceset_get_time_span_real(ts);
1459
1460 LttTime end;
1461
1462 end = ltt_time_sub(time_span.end_time, time_span.start_time);
1463 event_viewer_data->vadjust_c->upper = ltt_time_to_double(end);
1464
1465 if(event_viewer_data->pos->len < event_viewer_data->num_visible_events ) {
1466
1467
1468 redraw(event_viewer_data);
1469
1470 request_background_data(event_viewer_data);
1471 }
1472 return FALSE;
1473 }
1474
1475 gboolean traceset_changed(void * hook_data, void * call_data)
1476 {
1477
1478 EventViewerData *event_viewer_data = (EventViewerData*) hook_data;
1479 LttvTraceset * ts = lttvwindow_get_traceset(event_viewer_data->tab);
1480 TimeInterval time_span = lttv_traceset_get_time_span_real(ts);
1481
1482 LttTime end;
1483 gtk_list_store_clear(event_viewer_data->store_m);
1484 g_ptr_array_set_size(event_viewer_data->pos, 0);
1485
1486 end = ltt_time_sub(time_span.end_time, time_span.start_time);
1487 event_viewer_data->vadjust_c->upper = ltt_time_to_double(end);
1488 #ifdef BABEL_CLEANUP
1489 /* Reset the positions */
1490 lttv_traceset_destroy_position(event_viewer_data->currently_selected_position);
1491 lttv_traceset_destroy_position(event_viewer_data->first_event);
1492 lttv_traceset_destroy_position(event_viewer_data->last_event);
1493
1494 event_viewer_data->currently_selected_position =
1495 lttv_traceset_create_current_position(ts);
1496 event_viewer_data->first_event =
1497 lttv_traceset_create_current_position(ts);
1498 event_viewer_data->last_event =
1499 lttv_traceset_create_current_position(ts);
1500
1501 redraw(event_viewer_data);
1502
1503 #endif //babel_cleanup
1504 // event_viewer_data->vadjust_c->value = 0;
1505
1506 request_background_data(event_viewer_data);
1507
1508 return FALSE;
1509 }
1510
1511 gboolean filter_changed(void * hook_data, void * call_data)
1512 {
1513 EventViewerData *event_viewer_data = (EventViewerData*) hook_data;
1514
1515 event_viewer_data->main_win_filter =
1516 (LttvFilter*)call_data;
1517 redraw(event_viewer_data);
1518
1519 return FALSE;
1520 }
1521
1522
1523 gint evd_redraw_notify(void *hook_data, void *call_data)
1524 {
1525 EventViewerData *event_viewer_data = (EventViewerData*) hook_data;
1526
1527 redraw(event_viewer_data);
1528 return 0;
1529 }
1530
1531 void gui_events_free(gpointer data)
1532 {
1533 #ifdef BABEL_CLEANUP
1534 LttvPluginEVD *plugin_evd = (LttvPluginEVD*)data;
1535 Tab *tab = plugin_evd->evd->tab;
1536 EventViewerData *event_viewer_data = plugin_evd->evd;
1537 guint i;
1538
1539 lttv_filter_destroy(plugin_evd->evd->filter);
1540
1541 if(tab != NULL){
1542 lttv_hooks_remove(event_viewer_data->event_hooks,event_hook);
1543 lttv_hooks_destroy(event_viewer_data->event_hooks);
1544
1545 for(i=0;i<event_viewer_data->pos->len;i++) {
1546 LttvTracesetContextPosition *cur_pos =
1547 (LttvTracesetContextPosition*)g_ptr_array_index(event_viewer_data->pos,
1548 i);
1549 lttv_traceset_context_position_destroy(cur_pos);
1550 }
1551 lttv_traceset_context_position_destroy(
1552 event_viewer_data->currently_selected_position);
1553 lttv_traceset_context_position_destroy(
1554 event_viewer_data->first_event);
1555 lttv_traceset_context_position_destroy(
1556 event_viewer_data->last_event);
1557 g_ptr_array_free(event_viewer_data->pos, TRUE);
1558
1559 lttvwindow_unregister_current_time_notify(tab,
1560 update_current_time, event_viewer_data);
1561 lttvwindow_unregister_current_position_notify(tab,
1562 update_current_position, event_viewer_data);
1563 //lttvwindow_unregister_show_notify(tab,
1564 // show_event_detail, event_viewer_data);
1565 lttvwindow_unregister_traceset_notify(tab,
1566 traceset_changed, event_viewer_data);
1567 lttvwindow_unregister_timespan_notify(tab,
1568 timespan_changed,event_viewer_data);
1569 lttvwindow_unregister_filter_notify(tab,
1570 filter_changed, event_viewer_data);
1571 lttvwindow_unregister_redraw_notify(tab,
1572 evd_redraw_notify, event_viewer_data);
1573
1574 }
1575 lttvwindowtraces_background_notify_remove(event_viewer_data);
1576
1577 g_event_viewer_data_list = g_slist_remove(g_event_viewer_data_list,
1578 event_viewer_data);
1579 //g_free(event_viewer_data);
1580 g_object_unref(plugin_evd);
1581 #endif // BABEL_CLEANUP
1582 }
1583
1584
1585
1586 void gui_events_destructor(gpointer data)
1587 {
1588 LttvPluginEVD *plugin_evd = (LttvPluginEVD*)data;
1589 /* May already been done by GTK window closing */
1590 if(GTK_IS_WIDGET(plugin_evd->parent.top_widget)){
1591 gtk_widget_destroy(plugin_evd->parent.top_widget);
1592 }
1593 }
1594
1595
1596
1597 /**
1598 * plugin's init function
1599 *
1600 * This function initializes the Event Viewer functionnality through the
1601 * gtkTraceSet API.
1602 */
1603 static void init() {
1604
1605 lttvwindow_register_constructor("guievents",
1606 "/",
1607 "Insert Event Viewer",
1608 hGuiEventsInsert_xpm,
1609 "Insert Event Viewer",
1610 h_gui_events);
1611 }
1612
1613 void event_destroy_walk(gpointer data, gpointer user_data)
1614 {
1615 gui_events_destructor((LttvPluginEVD*)data);
1616 }
1617
1618 /**
1619 * plugin's destroy function
1620 *
1621 * This function releases the memory reserved by the module and unregisters
1622 * everything that has been registered in the gtkTraceSet API.
1623 */
1624 static void destroy() {
1625
1626 g_slist_foreach(g_event_viewer_data_list, event_destroy_walk, NULL );
1627 g_slist_free(g_event_viewer_data_list);
1628
1629 lttvwindow_unregister_constructor(h_gui_events);
1630
1631 }
1632
1633
1634
1635
1636 LTTV_MODULE("guievents", "Detailed events view", \
1637 "Graphical module to display a detailed event list", \
1638 init, destroy, "lttvwindow", "print")
LTTng 2.x Viewer (LTTV)
This page took 0.102433 seconds and 3 git commands to generate.