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