projects / lttv.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
compile fixes
[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(
566 main_window_get_widget(event_viewer_data->tab), trace, "state");
567 lttvwindowtraces_background_notify_queue(event_viewer_data,
568 trace,
569 ltt_time_infinite,
570 NULL,
571 background_ready_hook);
572 event_viewer_data->background_info_waiting++;
573 } else { /* in progress */
574
575 lttvwindowtraces_background_notify_current(event_viewer_data,
576 trace,
577 ltt_time_infinite,
578 NULL,
579 background_ready_hook);
580 event_viewer_data->background_info_waiting++;
581 }
582 } else {
583 /* Data ready. Be its nature, this viewer doesn't need to have
584 * its data ready hook called htere, because a background
585 * request is always linked with a redraw.
586 */
587 }
588
589 }
590
591 lttv_hooks_destroy(background_ready_hook);
592
593}
594
595static gboolean
596header_size_allocate(GtkWidget *widget,
597 GtkAllocation *allocation,
598 gpointer user_data)
599{
600 EventViewerData *event_viewer_data = (EventViewerData*)user_data;
601
602 event_viewer_data->header_height = allocation->height;
603
604 return 0;
605}
606
607
608void tree_v_set_cursor(EventViewerData *event_viewer_data)
609{
610 GtkTreePath *path;
611
612 g_debug("set cursor cb");
613
614#if 0
615 if(event_viewer_data->currently_selected_event != -1)
616 {
617 path = gtk_tree_path_new_from_indices(
618 event_viewer_data->currently_selected_event,
619 -1);
620
621 gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
622 path, NULL, FALSE);
623 gtk_tree_path_free(path);
624 }
625#endif //0
626}
627
628void tree_v_get_cursor(EventViewerData *event_viewer_data)
629{
630 GtkTreePath *path;
631 gint *indices;
632
633 g_debug("get cursor cb");
634
635
636#if 0
637 gtk_tree_view_get_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
638 &path, NULL);
639 indices = gtk_tree_path_get_indices(path);
640
641 if(indices != NULL)
642 event_viewer_data->currently_selected_event = indices[0];
643 else
644 event_viewer_data->currently_selected_event = -1;
645
646 gtk_tree_path_free(path);
647#endif //0
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(guint32_before(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 events request pending, do nothing*/
692 if(lttvwindow_events_request_pending(event_viewer_data->tab)) return;
693
694 /* If no prior position... */
695 if(ltt_time_compare(
696 lttv_traceset_context_position_get_time(
697 event_viewer_data->currently_selected_position),
698 ltt_time_infinite) == 0) {
699
700 path = gtk_tree_path_new_from_indices(0, -1);
701 gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
702 path, NULL, FALSE);
703
704 gtk_tree_path_free(path);
705 return;
706
707 }
708
709
710 g_debug("tree view move cursor : arg1 is %u and arg2 is %d",
711 (guint)arg1, arg2);
712
713 switch(arg1) {
714 case GTK_MOVEMENT_DISPLAY_LINES:
715 if(arg2 == 1) {
716 /* Move one line down */
717 if(event_viewer_data->pos->len > 0) {
718 LttvTracesetContextPosition *end_pos =
719 (LttvTracesetContextPosition*)g_ptr_array_index(
720 event_viewer_data->pos,
721 event_viewer_data->pos->len-1);
722 if(lttv_traceset_context_pos_pos_compare(end_pos,
723 event_viewer_data->currently_selected_position) == 0) {
724 /* Must get down one event and select the last one */
725 gtk_tree_selection_unselect_all(gtk_tree_view_get_selection(
726 GTK_TREE_VIEW(event_viewer_data->tree_v)));
727 event_viewer_data->update_cursor = FALSE;
728 gtk_adjustment_set_value(event_viewer_data->vadjust_c,
729 gtk_adjustment_get_value(event_viewer_data->vadjust_c) + 1);
730 event_viewer_data->update_cursor = TRUE;
731 path = gtk_tree_path_new_from_indices(
732 event_viewer_data->pos->len - 1, -1);
733 gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
734 path, NULL, FALSE);
735 gtk_tree_path_free(path);
736 }
737 }
738
739 } else {
740 if(event_viewer_data->pos->len > 0) {
741 /* Move one line up */
742 LttvTracesetContextPosition *begin_pos =
743 (LttvTracesetContextPosition*)g_ptr_array_index(
744 event_viewer_data->pos,
745 0);
746 if(lttv_traceset_context_pos_pos_compare(begin_pos,
747 event_viewer_data->currently_selected_position) == 0) {
748 /* Must get up one event and select the first one */
749 gtk_tree_selection_unselect_all(gtk_tree_view_get_selection(
750 GTK_TREE_VIEW(event_viewer_data->tree_v)));
751 event_viewer_data->update_cursor = FALSE;
752 gtk_adjustment_set_value(event_viewer_data->vadjust_c,
753 gtk_adjustment_get_value(event_viewer_data->vadjust_c) - 1);
754 event_viewer_data->update_cursor = TRUE;
755 path = gtk_tree_path_new_from_indices(
756 0, -1);
757 gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
758 path, NULL, FALSE);
759 gtk_tree_path_free(path);
760 }
761 }
762 }
763 break;
764 case GTK_MOVEMENT_PAGES:
765 if(arg2 == 1) {
766 /* Move one page down */
767 if(event_viewer_data->pos->len > 0) {
768 LttvTracesetContextPosition *end_pos =
769 (LttvTracesetContextPosition*)g_ptr_array_index(
770 event_viewer_data->pos,
771 event_viewer_data->pos->len-1);
772 if(lttv_traceset_context_pos_pos_compare(end_pos,
773 event_viewer_data->currently_selected_position) == 0) {
774 /* Must get down one page and select the last one */
775 gtk_tree_selection_unselect_all(gtk_tree_view_get_selection(
776 GTK_TREE_VIEW(event_viewer_data->tree_v)));
777
778 event_viewer_data->update_cursor = FALSE;
779 gtk_adjustment_set_value(event_viewer_data->vadjust_c,
780 gtk_adjustment_get_value(event_viewer_data->vadjust_c) + 2);
781 event_viewer_data->update_cursor = TRUE;
782
783 path = gtk_tree_path_new_from_indices(
784 event_viewer_data->pos->len - 1, -1);
785 gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
786 path, NULL, FALSE);
787 gtk_tree_path_free(path);
788
789 }
790 }
791
792 } else {
793 /* Move one page up */
794 if(event_viewer_data->pos->len > 0) {
795 LttvTracesetContextPosition *begin_pos =
796 (LttvTracesetContextPosition*)g_ptr_array_index(
797 event_viewer_data->pos,
798 0);
799 if(lttv_traceset_context_pos_pos_compare(begin_pos,
800 event_viewer_data->currently_selected_position) == 0) {
801 /* Must get up one page and select the first one */
802 gtk_tree_selection_unselect_all(gtk_tree_view_get_selection(
803 GTK_TREE_VIEW(event_viewer_data->tree_v)));
804
805 event_viewer_data->update_cursor = FALSE;
806 gtk_adjustment_set_value(event_viewer_data->vadjust_c,
807 gtk_adjustment_get_value(event_viewer_data->vadjust_c) - 2);
808 event_viewer_data->update_cursor = TRUE;
809
810 path = gtk_tree_path_new_from_indices(
811 0, -1);
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 }
819 break;
820 default:
821 break;
822 }
823
824 //gtk_tree_path_free(path);
825
826#if 0
827 if(arg1 == GTK_MOVEMENT_DISPLAY_LINES)
828 {
829 /* Move one line */
830 if(arg2 == 1)
831 {
832 /* move one line down */
833 if(indices[0]) // Do we need an empty field here (before first)?
834 {
835 if(value + event_viewer_data->num_visible_events <=
836 event_viewer_data->number_of_events -1)
837 {
838 event_viewer_data->currently_selected_event += 1;
839 // gtk_adjustment_set_value(event_viewer_data->vadjust_c, value+1);
840 //gtk_tree_path_free(path);
841 //path = gtk_tree_path_new_from_indices(event_viewer_data->num_visible_events-1, -1);
842 //gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), path, NULL, FALSE);
843 g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
844 }
845 }
846 } else {
847 /* Move one line up */
848 if(indices[0] == 0)
849 {
850 if(value - 1 >= 0 )
851 {
852 event_viewer_data->currently_selected_event -= 1;
853 // gtk_adjustment_set_value(event_viewer_data->vadjust_c, value-1);
854 //gtk_tree_path_free(path);
855 //path = gtk_tree_path_new_from_indices(0, -1);
856 //gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), path, NULL, FALSE);
857 g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
858 }
859 }
860 }
861 }
862
863 if(arg1 == GTK_MOVEMENT_PAGES)
864 {
865 /* Move one page */
866 if(arg2 == 1)
867 {
868 if(event_viewer_data->num_visible_events == 1)
869 value += 1 ;
870 /* move one page down */
871 if(value + event_viewer_data->num_visible_events-1 <=
872 event_viewer_data->number_of_events )
873 {
874 event_viewer_data->currently_selected_event +=
875 event_viewer_data->num_visible_events-1;
876 // gtk_adjustment_set_value(event_viewer_data->vadjust_c,
877 // value+(event_viewer_data->num_visible_events-1));
878 //gtk_tree_path_free(path);
879 //path = gtk_tree_path_new_from_indices(0, -1);
880 //gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), path, NULL, FALSE);
881 g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
882 }
883 } else {
884 /* Move one page up */
885 if(event_viewer_data->num_visible_events == 1)
886 value -= 1 ;
887
888 if(indices[0] < event_viewer_data->num_visible_events - 2 )
889 {
890 if(value - (event_viewer_data->num_visible_events-1) >= 0)
891 {
892 event_viewer_data->currently_selected_event -=
893 event_viewer_data->num_visible_events-1;
894
895 // gtk_adjustment_set_value(event_viewer_data->vadjust_c,
896 // value-(event_viewer_data->num_visible_events-1));
897 //gtk_tree_path_free(path);
898 //path = gtk_tree_path_new_from_indices(0, -1);
899 //gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), path, NULL, FALSE);
900 g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
901
902 } else {
903 /* Go to first Event */
904 event_viewer_data->currently_selected_event == 0 ;
905 // gtk_adjustment_set_value(event_viewer_data->vadjust_c,
906 // 0);
907 //gtk_tree_path_free(path);
908 //path = gtk_tree_path_new_from_indices(0, -1);
909 //gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), path, NULL, FALSE);
910 g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
911
912 }
913 }
914 }
915 }
916
917 if(arg1 == GTK_MOVEMENT_BUFFER_ENDS)
918 {
919 /* Move to the ends of the buffer */
920 if(arg2 == 1)
921 {
922 /* move end of buffer */
923 event_viewer_data->currently_selected_event =
924 event_viewer_data->number_of_events-1 ;
925 // gtk_adjustment_set_value(event_viewer_data->vadjust_c,
926 // event_viewer_data->number_of_events -
927 // event_viewer_data->num_visible_events);
928 //gtk_tree_path_free(path);
929 //path = gtk_tree_path_new_from_indices(event_viewer_data->num_visible_events-1, -1);
930 //gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), path, NULL, FALSE);
931 g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
932 } else {
933 /* Move beginning of buffer */
934 event_viewer_data->currently_selected_event = 0 ;
935 // gtk_adjustment_set_value(event_viewer_data->vadjust_c, 0);
936 //gtk_tree_path_free(path);
937 //path = gtk_tree_path_new_from_indices(0, -1);
938 //gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), path, NULL, FALSE);
939 g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
940 }
941 }
942#endif //0
943}
944
945void tree_v_cursor_changed_cb (GtkWidget *widget, gpointer data)
946{
947 EventViewerData *event_viewer_data = (EventViewerData*) data;
948 Tab *tab = event_viewer_data->tab;
949 GtkTreeIter iter;
950 GtkTreeModel* model = GTK_TREE_MODEL(event_viewer_data->store_m);
951 GtkTreePath *path;
952 LttvTracesetContextPosition *pos;
953
954 g_debug("cursor changed cb");
955
956 /* On cursor change, modify the currently selected event by calling
957 * the right API function */
958
959
960 if(event_viewer_data->report_position) {
961 gtk_tree_view_get_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
962 &path, NULL);
963 if(gtk_tree_model_get_iter(model,&iter,path)){
964 gtk_tree_model_get(model, &iter, POSITION_COLUMN, &pos, -1);
965
966 if(lttv_traceset_context_pos_pos_compare(pos,
967 event_viewer_data->currently_selected_position) != 0)
968 lttvwindow_report_current_position(tab, pos);
969 }else{
970 g_warning("Can not get iter\n");
971 }
972 gtk_tree_path_free(path);
973 }
974}
975
976
977static void tree_selection_changed_cb (GtkTreeSelection *selection,
978 gpointer data)
979{
980 g_debug("tree sel changed cb");
981 EventViewerData *event_viewer_data = (EventViewerData*) data;
982#if 0
983 /* Set the cursor to currently selected event */
984 GtkTreeModel* model = GTK_TREE_MODEL(event_viewer_data->store_m);
985 GtkTreeIter iter;
986 LttvTracesetContextPosition *pos;
987 guint i;
988 GtkTreePath *tree_path;
989
990 for(i=0;i<event_viewer_data->num_visible_events;i++) {
991 tree_path = gtk_tree_path_new_from_indices(
992 i,
993 -1);
994 if(gtk_tree_model_get_iter(model,&iter,tree_path)){
995 gtk_tree_model_get(model, &iter, POSITION_COLUMN, &pos, -1);
996
997 if(lttv_traceset_context_pos_pos_compare(pos,
998 event_viewer_data->currently_selected_position) == 0) {
999 /* Match! */
1000 gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
1001 tree_path, NULL, FALSE);
1002 break;
1003 }
1004
1005 }else{
1006 g_warning("Can not get iter\n");
1007 }
1008 gtk_tree_path_free(tree_path);
1009 }
1010#endif //0
1011}
1012
1013#if 0
1014static gint key_snooper(GtkWidget *grab_widget, GdkEventKey *event,
1015 gpointer func_data)
1016{
1017 return TRUE;
1018}
1019#endif //0
1020
1021/* This callback may be recalled after a step up/down, but we don't want to lose
1022 * the exact position : what we do is that we only set the value if it has
1023 * changed : a step up/down that doesn't change the time value of the first
1024 * event won't trigger a scrollbar change. */
1025
1026void v_scroll_cb (GtkAdjustment *adjustment, gpointer data)
1027{
1028 EventViewerData *event_viewer_data = (EventViewerData*)data;
1029 LttvTracesetStats *tss =
1030 lttvwindow_get_traceset_stats(event_viewer_data->tab);
1031 LttvTracesetContext *tsc = (LttvTracesetContext*)tss;
1032 g_debug("SCROLL begin");
1033 g_debug("SCROLL values : %g , %g, %g",
1034 adjustment->value, event_viewer_data->previous_value,
1035 (adjustment->value - event_viewer_data->previous_value));
1036
1037 LttTime new_time_off = ltt_time_from_double(adjustment->value);
1038 LttTime old_time_off = ltt_time_from_double(event_viewer_data->previous_value);
1039 g_debug("SCROLL time values %lu.%lu, %lu.%lu", new_time_off.tv_sec,
1040 new_time_off.tv_nsec, old_time_off.tv_sec, old_time_off.tv_nsec);
1041 /* If same value : nothing to update */
1042 if(ltt_time_compare(new_time_off, old_time_off) == 0)
1043 return;
1044
1045 //LttTime old_time = event_viewer_data->first_event;
1046
1047
1048 //gint snoop = gtk_key_snooper_install(key_snooper, NULL);
1049
1050 get_events(adjustment->value, event_viewer_data);
1051
1052 //gtk_key_snooper_remove(snoop);
1053#if 0
1054 LttTime time = ltt_time_sub(event_viewer_data->first_event,
1055 tsc->time_span.start_time);
1056 double value = ltt_time_to_double(time);
1057 gtk_adjustment_set_value(event_viewer_data->vadjust_c, value);
1058
1059 if(event_viewer_data->currently_selected_event != -1) {
1060
1061 tree_path = gtk_tree_path_new_from_indices(
1062 event_viewer_data->currently_selected_event,
1063 -1);
1064
1065 // gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), tree_path,
1066 // NULL, FALSE);
1067 gtk_tree_path_free(tree_path);
1068 }
1069#endif //0
1070 g_debug("SCROLL end");
1071}
1072
1073static __inline gint get_cell_height(GtkTreeView *TreeView)
1074{
1075 gint height;
1076 GtkTreeViewColumn *column = gtk_tree_view_get_column(TreeView, 0);
1077
1078 gtk_tree_view_column_cell_get_size(column, NULL, NULL, NULL, NULL, &height);
1079
1080 return height;
1081}
1082
1083void tree_v_size_allocate_cb (GtkWidget *widget, GtkAllocation *alloc, gpointer data)
1084{
1085 EventViewerData *event_viewer_data = (EventViewerData*)data;
1086 gint cell_height = get_cell_height(GTK_TREE_VIEW(event_viewer_data->tree_v));
1087 gint last_num_visible_events = event_viewer_data->num_visible_events;
1088 gdouble exact_num_visible;
1089
1090 exact_num_visible = ( alloc->height -
1091 event_viewer_data->header_height )
1092 / (double)cell_height ;
1093
1094 event_viewer_data->num_visible_events = ceil(exact_num_visible) ;
1095
1096/*
1097 event_viewer_data->vadjust_c->page_increment =
1098 floor(exact_num_visible);
1099 event_viewer_data->vadjust_c->page_size =
1100 floor(exact_num_visible);
1101*/
1102
1103 g_debug("size allocate : last_num_visible_events : %d,\
1104 num_visible_events : %d",
1105 last_num_visible_events,
1106 event_viewer_data->num_visible_events);
1107 if(event_viewer_data->num_visible_events != last_num_visible_events)
1108 {
1109 get_events(event_viewer_data->vadjust_c->value, event_viewer_data);
1110 }
1111
1112
1113}
1114
1115void tree_v_size_request_cb (GtkWidget *widget, GtkRequisition *requisition, gpointer data)
1116{
1117 gint h;
1118 EventViewerData *event_viewer_data = (EventViewerData*)data;
1119 gint cell_height = get_cell_height(GTK_TREE_VIEW(event_viewer_data->tree_v));
1120
1121 h = cell_height + event_viewer_data->header_height;
1122 requisition->height = h;
1123
1124}
1125
1126#if 0
1127gboolean show_event_detail(void * hook_data, void * call_data)
1128{
1129 EventViewerData *event_viewer_data = (EventViewerData*) hook_data;
1130 LttvTracesetContext * tsc = lttvwindow_get_traceset_context(event_viewer_data->tab);
1131
1132 if(event_viewer_data->event_fields_queue_tmp->length == 0 &&
1133 event_viewer_data->event_fields_queue->length == 0){
1134 event_viewer_data->shown = FALSE;
1135 return FALSE;
1136 }
1137
1138 if(event_viewer_data->shown == FALSE){
1139 event_viewer_data->shown = TRUE;
1140 update_raw_data_array(event_viewer_data,
1141 event_viewer_data->event_fields_queue_tmp->length);
1142
1143 get_data(event_viewer_data->vadjust_c->value,
1144 event_viewer_data->num_visible_events,
1145 event_viewer_data);
1146
1147 remove_context_hooks(event_viewer_data,tsc);
1148 }
1149
1150 return FALSE;
1151}
1152#endif //0
1153
1154
1155
1156
1157
1158
1159
1160static void get_events(double new_value, EventViewerData *event_viewer_data)
1161{
1162 GtkTreePath *tree_path;
1163 LttvTracesetStats *tss =
1164 lttvwindow_get_traceset_stats(event_viewer_data->tab);
1165 LttvTracesetContext *tsc = (LttvTracesetContext*)tss;
1166 guint i;
1167 gboolean seek_by_time;
1168
1169 double value = new_value - event_viewer_data->previous_value;
1170
1171 /* See where we have to scroll... */
1172 ScrollDirection direction;
1173 gint relative_position;
1174
1175 if(value < -0.8) {
1176 if(value >= -1.0) direction = SCROLL_STEP_UP;
1177 else {
1178 if(value >= -2.0) direction = SCROLL_PAGE_UP;
1179 else direction = SCROLL_JUMP;
1180 }
1181 } else if(value > 0.8) {
1182 if(value <= 1.0) direction = SCROLL_STEP_DOWN;
1183 else {
1184 if(value <= 2.0) direction = SCROLL_PAGE_DOWN;
1185 else direction = SCROLL_JUMP;
1186 }
1187 } else direction = SCROLL_NONE; /* 0.0 */
1188
1189
1190 switch(direction) {
1191 case SCROLL_STEP_UP:
1192 g_debug("get_events : SCROLL_STEP_UP");
1193 relative_position = -1;
1194 seek_by_time = 0;
1195 break;
1196 case SCROLL_STEP_DOWN:
1197 g_debug("get_events : SCROLL_STEP_DOWN");
1198 relative_position = 1;
1199 seek_by_time = 0;
1200 break;
1201 case SCROLL_PAGE_UP:
1202 g_debug("get_events : SCROLL_PAGE_UP");
1203 relative_position = -(event_viewer_data->num_visible_events);
1204 seek_by_time = 0;
1205 break;
1206 case SCROLL_PAGE_DOWN:
1207 g_debug("get_events : SCROLL_PAGE_DOWN");
1208 relative_position = event_viewer_data->num_visible_events;
1209 seek_by_time = 0;
1210 break;
1211 case SCROLL_JUMP:
1212 g_debug("get_events : SCROLL_JUMP");
1213 seek_by_time = 1;
1214 break;
1215 case SCROLL_NONE:
1216 g_debug("get_events : SCROLL_NONE");
1217 relative_position = 0;
1218 seek_by_time = 0;
1219 break;
1220 }
1221
1222 LttTime time = ltt_time_from_double(new_value);
1223 time = ltt_time_add(tsc->time_span.start_time, time);
1224
1225 if(!seek_by_time) {
1226
1227 LttvTracesetContextPosition *pos =
1228 lttv_traceset_context_position_new(tsc);
1229
1230 /* Remember the beginning position */
1231 if(event_viewer_data->pos->len > 0) {
1232 LttvTracesetContextPosition *first_pos =
1233 (LttvTracesetContextPosition*)g_ptr_array_index(
1234 event_viewer_data->pos,
1235 0);
1236 lttv_traceset_context_position_copy(pos, first_pos);
1237
1238 if(relative_position >= 0) {
1239 LttTime first_event_time =
1240 lttv_traceset_context_position_get_time(
1241 pos);
1242 lttv_state_traceset_seek_time_closest((LttvTracesetState*)tsc,
1243 first_event_time);
1244 lttv_process_traceset_middle(tsc, ltt_time_infinite,
1245 G_MAXUINT,
1246 pos);
1247
1248 } else if(relative_position < 0) {
1249 g_assert(lttv_process_traceset_seek_position(tsc, pos) == 0);
1250 }
1251 } else {
1252 /* There is nothing in the list : simply seek to the time value. */
1253 lttv_state_traceset_seek_time_closest((LttvTracesetState*)tsc,
1254 time);
1255 lttv_process_traceset_middle(tsc, time, G_MAXUINT,
1256 NULL);
1257 }
1258
1259 /* Note that, as we mess with the tsc position, this function CANNOT be called
1260 * from a hook inside the lttv_process_traceset_middle. */
1261 /* As the lttvwindow API keeps a sync_position inside the tsc to go back at
1262 * the right spot after being interrupted, it's ok to change the tsc position,
1263 * as long as we do not touch the sync_position. */
1264
1265 /* Get the beginning position of the read (with seek backward or seek forward)
1266 */
1267 if(relative_position > 0) {
1268 guint count;
1269 count = lttv_process_traceset_seek_n_forward(tsc, relative_position,
1270 event_viewer_data->main_win_filter);
1271 } else if(relative_position < 0) {
1272 guint count;
1273
1274 /* Get an idea of currently shown event dispersion */
1275 LttTime first_event_time =
1276 lttv_traceset_context_position_get_time(event_viewer_data->first_event);
1277 LttTime last_event_time =
1278 lttv_traceset_context_position_get_time(event_viewer_data->last_event);
1279 LttTime time_diff = ltt_time_sub(last_event_time, first_event_time);
1280 if(ltt_time_compare(time_diff, ltt_time_zero) == 0)
1281 time_diff = seek_back_default_offset;
1282 count = lttv_process_traceset_seek_n_backward(tsc, abs(relative_position),
1283 time_diff,
1284 (seek_time_fct)lttv_state_traceset_seek_time_closest,
1285 event_viewer_data->main_win_filter);
1286 } /* else 0 : do nothing : we are already at the beginning position */
1287
1288 lttv_traceset_context_position_destroy(pos);
1289
1290 /* Save the first event position */
1291 lttv_traceset_context_position_save(tsc, event_viewer_data->first_event);
1292
1293 time = lttv_traceset_context_position_get_time(
1294 event_viewer_data->first_event);
1295 //if(ltt_time_compare(time, tsc->time_span.end_time) > 0)
1296 // time = tsc->time_span.end_time;
1297
1298 LttTime time_val = ltt_time_sub(time,
1299 tsc->time_span.start_time);
1300 event_viewer_data->previous_value = ltt_time_to_double(time_val);
1301
1302 lttv_state_traceset_seek_time_closest((LttvTracesetState*)tsc, time);
1303 lttv_process_traceset_middle(tsc, ltt_time_infinite, G_MAXUINT,
1304 event_viewer_data->first_event);
1305
1306 } else {
1307 /* Seek by time */
1308 lttv_state_traceset_seek_time_closest((LttvTracesetState*)tsc,
1309 time);
1310 lttv_process_traceset_middle(tsc, time, G_MAXUINT,
1311 NULL);
1312 LttTime time_val = ltt_time_sub(time,
1313 tsc->time_span.start_time);
1314 event_viewer_data->previous_value = ltt_time_to_double(time_val);
1315 lttv_traceset_context_position_save(tsc, event_viewer_data->first_event);
1316 }
1317
1318 /* Clear the model (don't forget to free the TCS positions!) */
1319 gtk_list_store_clear(event_viewer_data->store_m);
1320 for(i=0;i<event_viewer_data->pos->len;i++) {
1321 LttvTracesetContextPosition *cur_pos =
1322 (LttvTracesetContextPosition*)g_ptr_array_index(event_viewer_data->pos,
1323 i);
1324 lttv_traceset_context_position_destroy(cur_pos);
1325 }
1326 g_ptr_array_set_size(event_viewer_data->pos, 0);
1327
1328
1329 /* Mathieu :
1330 * I make the choice not to use the mainwindow lttvwindow API here : the idle
1331 * loop might have a too low priority, and we want good update while
1332 * scrolling.
1333 */
1334
1335 lttv_process_traceset_begin(tsc,
1336 NULL, NULL, NULL, event_viewer_data->event_hooks, NULL);
1337
1338 lttv_process_traceset_middle(tsc, ltt_time_infinite, G_MAXUINT, NULL);
1339
1340 lttv_process_traceset_end(tsc,
1341 NULL, NULL, NULL, event_viewer_data->event_hooks, NULL);
1342
1343 /* Get the end position */
1344 if(event_viewer_data->pos->len > 0) {
1345 LttvTracesetContextPosition *cur_pos =
1346 (LttvTracesetContextPosition*)g_ptr_array_index(event_viewer_data->pos,
1347 event_viewer_data->pos->len - 1);
1348 lttv_traceset_context_position_copy(event_viewer_data->last_event,
1349 cur_pos);
1350 } else
1351 lttv_traceset_context_position_save(tsc, event_viewer_data->last_event);
1352
1353 gtk_adjustment_set_value(event_viewer_data->vadjust_c,
1354 event_viewer_data->previous_value);
1355
1356 //g_signal_emit_by_name(G_OBJECT (event_viewer_data->select_c),
1357 // "changed");
1358
1359 event_viewer_data->last_tree_update_time =
1360 gdk_x11_get_server_time(
1361 gtk_widget_get_parent_window(event_viewer_data->tree_v));
1362
1363 return;
1364}
1365
1366
1367
1368int event_hook(void *hook_data, void *call_data)
1369{
1370 EventViewerData *event_viewer_data = (EventViewerData*)hook_data;
1371 LttvTracefileContext *tfc = (LttvTracefileContext*)call_data;
1372 LttEvent *e = ltt_tracefile_get_event(tfc->tf);
1373
1374 LttvFilter *filter = event_viewer_data->main_win_filter;
1375 if(filter != NULL && filter->head != NULL)
1376 if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
1377 tfc->t_context->t,tfc))
1378 return FALSE;
1379
1380 LttFacility *facility = ltt_event_facility(e);
1381 LttEventType *event_type = ltt_event_eventtype(e);
1382 LttField *field = ltt_event_field(e);
1383 LttTime time = ltt_event_time(e);
1384
1385 guint cpu = ltt_tracefile_num(tfc->tf);
1386 LttvTraceState *ts = (LttvTraceState*)tfc->t_context;
1387 LttvProcessState *process = ts->running_process[cpu];
1388
1389 GtkTreeIter iter;
1390
1391 GString *desc = g_string_new("");
1392
1393 LttvTracesetContextPosition *pos =
1394 lttv_traceset_context_position_new(tfc->t_context->ts_context);
1395
1396 lttv_traceset_context_position_save(tfc->t_context->ts_context, pos);
1397
1398 lttv_event_to_string(e, desc, TRUE, TRUE, (LttvTracefileState*)tfc);
1399
1400 g_info("field : %s", desc->str);
1401
1402 gtk_list_store_append (event_viewer_data->store_m, &iter);
1403 gtk_list_store_set (event_viewer_data->store_m, &iter,
1404 TRACE_NAME_COLUMN, g_quark_to_string(ltt_trace_name(tfc->t_context->t)),
1405 TRACEFILE_NAME_COLUMN, g_quark_to_string(ltt_tracefile_name(tfc->tf)),
1406 CPUID_COLUMN, cpu,
1407 FACILITY_COLUMN, g_quark_to_string(ltt_facility_name(facility)),
1408 EVENT_COLUMN, g_quark_to_string(ltt_eventtype_name(event_type)),
1409 TIME_S_COLUMN, time.tv_sec,
1410 TIME_NS_COLUMN, time.tv_nsec,
1411 PID_COLUMN, process->pid,
1412 EVENT_DESCR_COLUMN, desc->str,
1413 POSITION_COLUMN, pos,
1414 -1);
1415
1416 g_ptr_array_add(event_viewer_data->pos, pos);
1417
1418 g_string_free(desc, TRUE);
1419
1420 if(event_viewer_data->update_cursor) {
1421 if(lttv_traceset_context_pos_pos_compare(pos,
1422 event_viewer_data->currently_selected_position) == 0) {
1423 GtkTreePath *path = gtk_tree_path_new_from_indices(
1424 event_viewer_data->pos->len - 1, -1);
1425 gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
1426 path, NULL, FALSE);
1427 gtk_tree_path_free(path);
1428 }
1429 }
1430
1431 if(event_viewer_data->pos->len >= event_viewer_data->num_visible_events )
1432 return TRUE;
1433 else
1434 return FALSE;
1435}
1436
1437
1438
1439static void event_update_selection(EventViewerData *event_viewer_data)
1440{
1441 guint i;
1442 GPtrArray *positions = event_viewer_data->pos;
1443 g_info("event_update_selection");
1444
1445 for(i=0;i<positions->len;i++) {
1446 LttvTracesetContextPosition *cur_pos =
1447 (LttvTracesetContextPosition*)g_ptr_array_index(positions, i);
1448 if(lttv_traceset_context_pos_pos_compare(cur_pos,
1449 event_viewer_data->currently_selected_position) == 0) {
1450 GtkTreePath *path = gtk_tree_path_new_from_indices(i, -1);
1451 gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v),
1452 path, NULL, FALSE);
1453 gtk_tree_path_free(path);
1454 }
1455 }
1456}
1457
1458static int current_time_get_first_event_hook(void *hook_data, void *call_data)
1459{
1460 EventViewerData *event_viewer_data = (EventViewerData*)hook_data;
1461 LttvTracefileContext *tfc = (LttvTracefileContext*)call_data;
1462 LttEvent *e = ltt_tracefile_get_event(tfc->tf);
1463
1464 LttvFilter *filter = event_viewer_data->main_win_filter;
1465 if(filter != NULL && filter->head != NULL)
1466 if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
1467 tfc->t_context->t,tfc))
1468 return FALSE;
1469
1470 lttv_traceset_context_position_save(tfc->t_context->ts_context,
1471 event_viewer_data->current_time_get_first);
1472 return TRUE;
1473}
1474
1475
1476gboolean update_current_time(void * hook_data, void * call_data)
1477{
1478 g_info("update_current_time");
1479 EventViewerData *event_viewer_data = (EventViewerData*) hook_data;
1480 const LttTime * current_time = (LttTime*)call_data;
1481 LttvTracesetContext * tsc =
1482 lttvwindow_get_traceset_context(event_viewer_data->tab);
1483 GtkTreePath *path;
1484
1485 /* If the currently selected event time != current time, set the first event
1486 * with this time as currently selected. */
1487 LttTime pos_time = lttv_traceset_context_position_get_time(
1488 event_viewer_data->currently_selected_position);
1489 if(ltt_time_compare(pos_time, *current_time) != 0) {
1490
1491 lttv_state_traceset_seek_time_closest((LttvTracesetState*)tsc,
1492 *current_time);
1493 lttv_process_traceset_middle(tsc, *current_time, G_MAXUINT,
1494 NULL);
1495
1496 /* Get the first event that passes in the filter */
1497 event_viewer_data->current_time_get_first =
1498 lttv_traceset_context_position_new(tsc);
1499 LttvHooks *hooks = lttv_hooks_new();
1500 lttv_hooks_add(hooks,
1501 current_time_get_first_event_hook,
1502 event_viewer_data,
1503 LTTV_PRIO_DEFAULT);
1504
1505 lttv_process_traceset_begin(tsc,
1506 NULL, NULL, NULL, hooks, NULL);
1507
1508 lttv_process_traceset_middle(tsc, ltt_time_infinite, G_MAXUINT, NULL);
1509
1510 lttv_process_traceset_end(tsc,
1511 NULL, NULL, NULL, hooks, NULL);
1512
1513 lttv_hooks_destroy(hooks);
1514
1515 lttv_traceset_context_position_copy(
1516 event_viewer_data->currently_selected_position,
1517 event_viewer_data->current_time_get_first);
1518 lttv_traceset_context_position_destroy(
1519 event_viewer_data->current_time_get_first);
1520 pos_time = lttv_traceset_context_position_get_time(
1521 event_viewer_data->currently_selected_position);
1522 }
1523
1524 LttTime time = ltt_time_sub(pos_time, tsc->time_span.start_time);
1525 double new_value = ltt_time_to_double(time);
1526
1527 event_viewer_data->report_position = FALSE;
1528 /* Change the viewed area if does not match */
1529 if(lttv_traceset_context_pos_pos_compare(
1530 event_viewer_data->currently_selected_position,
1531 event_viewer_data->first_event) < 0
1532 ||
1533 lttv_traceset_context_pos_pos_compare(
1534 event_viewer_data->currently_selected_position,
1535 event_viewer_data->last_event) > 0) {
1536 gtk_adjustment_set_value(event_viewer_data->vadjust_c, new_value);
1537 } else {
1538 /* Simply update the current time : it is in the list */
1539 event_update_selection(event_viewer_data);
1540 }
1541 event_viewer_data->report_position = TRUE;
1542
1543 return FALSE;
1544}
1545
1546gboolean update_current_position(void * hook_data, void * call_data)
1547{
1548 g_info("update_current_position");
1549 EventViewerData *event_viewer_data = (EventViewerData*) hook_data;
1550 const LttvTracesetContextPosition *current_pos =
1551 (LttvTracesetContextPosition*)call_data;
1552 LttvTracesetContext * tsc =
1553 lttvwindow_get_traceset_context(event_viewer_data->tab);
1554
1555 if(lttv_traceset_context_pos_pos_compare(
1556 event_viewer_data->currently_selected_position, current_pos) != 0) {
1557 lttv_traceset_context_position_copy(
1558 event_viewer_data->currently_selected_position, current_pos);
1559
1560 /* Change the viewed area if does not match */
1561 if(lttv_traceset_context_pos_pos_compare(
1562 event_viewer_data->currently_selected_position,
1563 event_viewer_data->first_event) < 0
1564 ||
1565 lttv_traceset_context_pos_pos_compare(
1566 event_viewer_data->currently_selected_position,
1567 event_viewer_data->last_event) > 0) {
1568 LttTime time = lttv_traceset_context_position_get_time(current_pos);
1569 time = ltt_time_sub(time, tsc->time_span.start_time);
1570 double new_value = ltt_time_to_double(time);
1571 gtk_adjustment_set_value(event_viewer_data->vadjust_c, new_value);
1572 } else {
1573 /* Simply update the current time : it is in the list */
1574 event_update_selection(event_viewer_data);
1575 }
1576
1577 }
1578
1579
1580 return FALSE;
1581}
1582
1583
1584
1585gboolean traceset_changed(void * hook_data, void * call_data)
1586{
1587 EventViewerData *event_viewer_data = (EventViewerData*) hook_data;
1588 LttvTracesetContext * tsc =
1589 lttvwindow_get_traceset_context(event_viewer_data->tab);
1590 TimeInterval time_span = tsc->time_span;
1591
1592 LttTime end;
1593 gtk_list_store_clear(event_viewer_data->store_m);
1594 g_ptr_array_set_size(event_viewer_data->pos, 0);
1595
1596 end = ltt_time_sub(time_span.end_time, time_span.start_time);
1597 event_viewer_data->vadjust_c->upper = ltt_time_to_double(end);
1598
1599 /* Reset the positions */
1600 lttv_traceset_context_position_destroy(
1601 event_viewer_data->currently_selected_position);
1602 lttv_traceset_context_position_destroy(
1603 event_viewer_data->first_event);
1604 lttv_traceset_context_position_destroy(
1605 event_viewer_data->last_event);
1606
1607 event_viewer_data->currently_selected_position =
1608 lttv_traceset_context_position_new(tsc);
1609 event_viewer_data->first_event =
1610 lttv_traceset_context_position_new(tsc);
1611 event_viewer_data->last_event =
1612 lttv_traceset_context_position_new(tsc);
1613
1614 get_events(event_viewer_data->vadjust_c->value, event_viewer_data);
1615 // event_viewer_data->vadjust_c->value = 0;
1616
1617 return FALSE;
1618}
1619
1620gboolean filter_changed(void * hook_data, void * call_data)
1621{
1622 EventViewerData *event_viewer_data = (EventViewerData*) hook_data;
1623 LttvTracesetContext * tsc =
1624 lttvwindow_get_traceset_context(event_viewer_data->tab);
1625
1626 event_viewer_data->main_win_filter =
1627 (LttvFilter*)call_data;
1628 get_events(event_viewer_data->vadjust_c->value, event_viewer_data);
1629
1630 return FALSE;
1631}
1632
1633
1634gint redraw_notify(void *hook_data, void *call_data)
1635{
1636 EventViewerData *event_viewer_data = (EventViewerData*) hook_data;
1637
1638 get_events(event_viewer_data->vadjust_c->value, event_viewer_data);
1639}
1640
1641void gui_events_free(EventViewerData *event_viewer_data)
1642{
1643 Tab *tab = event_viewer_data->tab;
1644 guint i;
1645
1646 if(event_viewer_data){
1647 lttv_hooks_remove(event_viewer_data->event_hooks,event_hook);
1648 lttv_hooks_destroy(event_viewer_data->event_hooks);
1649
1650 for(i=0;i<event_viewer_data->pos->len;i++) {
1651 LttvTracesetContextPosition *cur_pos =
1652 (LttvTracesetContextPosition*)g_ptr_array_index(event_viewer_data->pos,
1653 i);
1654 lttv_traceset_context_position_destroy(cur_pos);
1655 }
1656 lttv_traceset_context_position_destroy(
1657 event_viewer_data->currently_selected_position);
1658 lttv_traceset_context_position_destroy(
1659 event_viewer_data->first_event);
1660 lttv_traceset_context_position_destroy(
1661 event_viewer_data->last_event);
1662 g_ptr_array_free(event_viewer_data->pos, TRUE);
1663
1664 lttvwindow_unregister_current_time_notify(tab,
1665 update_current_time, event_viewer_data);
1666 lttvwindow_unregister_current_position_notify(tab,
1667 update_current_position, event_viewer_data);
1668 //lttvwindow_unregister_show_notify(tab,
1669 // show_event_detail, event_viewer_data);
1670 lttvwindow_unregister_traceset_notify(tab,
1671 traceset_changed, event_viewer_data);
1672 lttvwindow_unregister_filter_notify(tab,
1673 filter_changed, event_viewer_data);
1674 lttvwindow_unregister_redraw_notify(tab,
1675 redraw_notify, event_viewer_data);
1676
1677 lttvwindowtraces_background_notify_remove(event_viewer_data);
1678
1679 g_event_viewer_data_list = g_slist_remove(g_event_viewer_data_list,
1680 event_viewer_data);
1681 g_free(event_viewer_data);
1682 }
1683}
1684
1685
1686
1687void gui_events_destructor(EventViewerData *event_viewer_data)
1688{
1689 /* May already been done by GTK window closing */
1690 if(GTK_IS_WIDGET(event_viewer_data->hbox_v)){
1691 gtk_widget_destroy(event_viewer_data->hbox_v);
1692 }
1693}
1694
1695
1696
1697/**
1698 * plugin's init function
1699 *
1700 * This function initializes the Event Viewer functionnality through the
1701 * gtkTraceSet API.
1702 */
1703static void init() {
1704
1705 lttvwindow_register_constructor("guievents",
1706 "/",
1707 "Insert Event Viewer",
1708 hGuiEventsInsert_xpm,
1709 "Insert Event Viewer",
1710 h_gui_events);
1711}
1712
1713void event_destroy_walk(gpointer data, gpointer user_data)
1714{
1715 gui_events_destructor((EventViewerData*)data);
1716}
1717
1718/**
1719 * plugin's destroy function
1720 *
1721 * This function releases the memory reserved by the module and unregisters
1722 * everything that has been registered in the gtkTraceSet API.
1723 */
1724static void destroy() {
1725
1726 g_slist_foreach(g_event_viewer_data_list, event_destroy_walk, NULL );
1727 g_slist_free(g_event_viewer_data_list);
1728
1729 lttvwindow_unregister_constructor(h_gui_events);
1730
1731}
1732
1733
1734
1735
1736LTTV_MODULE("guievents", "Detailed events view", \
1737 "Graphical module to display a detailed event list", \
1738 init, destroy, "lttvwindow", "print")
LTTng 2.x Viewer (LTTV)
This page took 0.031867 seconds and 4 git commands to generate.