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