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