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