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