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