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