projects / lttv.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
git-svn-id: http://ltt.polymtl.ca/svn@250 04897980-b3bd-0310-b5e0-8ef037075253
[lttv.git] / ltt / branches / poly / lttv / modules / guiEvents.c
CommitLineData
fbbb2697 1//*! \defgroup GuiEvents libGuiEvents: The GUI Events display plugin */
5c7463ed 2/*\@{*/
3
fbbb2697 4/*! \file GuiEvents.c
5c7463ed 5 * \brief Graphical plugin for showing events.
6 *
17abcce3 7 * This plugin lists all the events contained in the current time interval
8 * in a list.
9 *
5c7463ed 10 * This plugin adds a Events Viewer functionnality to Linux TraceToolkit
11 * GUI when this plugin is loaded. The init and destroy functions add the
12 * viewer's insertion menu item and toolbar icon by calling gtkTraceSet's
13 * API functions. Then, when a viewer's object is created, the constructor
14 * creates ans register through API functions what is needed to interact
15 * with the TraceSet window.
16 *
fbbb2697 17 * Coding standard :
18 * pm : parameter
19 * l : local
20 * g : global
21 * s : static
22 * h : hook
23 *
fcdf0ec2 24 * Author : Karim Yaghmour
25 * Integrated to LTTng by Mathieu Desnoyers, June 2003
5c7463ed 26 */
27
b26121f4 28#include <math.h>
29
5c7463ed 30#include <glib.h>
31#include <gmodule.h>
fbbb2697 32#include <gtk/gtk.h>
33#include <gdk/gdk.h>
5c7463ed 34
35#include <lttv/module.h>
682c6edb 36#include <lttv/hook.h>
d1ebdadd 37#include <lttv/gtkTraceSet.h>
675f8f58 38#include <lttv/processTrace.h>
39#include <lttv/state.h>
40#include <ltt/ltt.h>
41#include <ltt/event.h>
42#include <ltt/type.h>
43#include <ltt/trace.h>
44#include <string.h>
45
d1ebdadd 46//#include "mw_api.h"
6601bf27 47#include "gtktreeprivate.h"
5c7463ed 48
fbbb2697 49#include "icons/hGuiEventsInsert.xpm"
5c7463ed 50
e921c965 51
675f8f58 52static LttvHooks *before_event;
53
fcdf0ec2 54/** Array containing instanced objects. Used when module is unloaded */
fbbb2697 55static GSList *sEvent_Viewer_Data_List = NULL ;
56
675f8f58 57/** hook functions for update time interval, current time ... */
58gboolean updateTimeInterval(void * hook_data, void * call_data);
59gboolean updateCurrentTime(void * hook_data, void * call_data);
b671bb09 60void remove_item_from_queue(GQueue * q, gboolean fromHead);
61void remove_all_items_from_queue(GQueue * q);
675f8f58 62
63typedef struct _RawTraceData{
64 unsigned cpu_id;
65 char * event_name;
66 LttTime time;
67 int pid;
68 unsigned entry_length;
69 char * event_description;
b671bb09 70 LttEventPosition ep;
675f8f58 71} RawTraceData;
72
b671bb09 73#define RESERVE_BIG_SIZE 1000
74#define RESERVE_SMALL_SIZE 100
e921c965 75
a60b01ef 76typedef enum _ScrollDirection{
b671bb09 77 SCROLL_STEP_UP,
78 SCROLL_STEP_DOWN,
79 SCROLL_PAGE_UP,
80 SCROLL_PAGE_DOWN,
81 SCROLL_JUMP,
82 SCROLL_NONE
a60b01ef 83} ScrollDirection;
84
fbbb2697 85typedef struct _EventViewerData {
86
e921c965 87 mainWindow * mw;
675f8f58 88 TimeInterval time_interval;
89 LttTime current_time;
675f8f58 90 LttvHooks * before_event_hooks;
91
b671bb09 92 gboolean append; //prepend or append item
93 GQueue * raw_trace_data_queue; //buf to contain raw trace data
94 GQueue * raw_trace_data_queue_tmp; //tmp buf to contain raw data
95 unsigned current_event_index;
96 double previous_value; //value of the slide
97 LttTime trace_start;
98 LttTime trace_end;
99 unsigned start_event_index; //the first event shown in the window
100 unsigned end_event_index; //the last event shown in the window
101
8b9fdc80 102 //scroll window containing Tree View
103 GtkWidget * Scroll_Win;
104
675f8f58 105 /* Model containing list data */
fbbb2697 106 GtkListStore *Store_M;
675f8f58 107
108 GtkWidget *HBox_V;
109 /* Widget to display the data in a columned list */
fbbb2697 110 GtkWidget *Tree_V;
111 GtkAdjustment *VTree_Adjust_C ;
675f8f58 112 GdkWindow *TreeWindow ;
113
114 /* Vertical scrollbar and it's adjustment */
115 GtkWidget *VScroll_VC;
fbbb2697 116 GtkAdjustment *VAdjust_C ;
117
675f8f58 118 /* Selection handler */
119 GtkTreeSelection *Select_C;
120
121 guint Num_Visible_Events;
122 guint First_Event, Last_Event;
123
124 /* TEST DATA, TO BE READ FROM THE TRACE */
125 gint Number_Of_Events ;
126 guint Currently_Selected_Event ;
127 gboolean Selected_Event ;
682c6edb 128
fbbb2697 129} EventViewerData ;
130
131//! Event Viewer's constructor hook
e921c965 132GtkWidget *hGuiEvents(mainWindow *pmParentWindow);
5c7463ed 133//! Event Viewer's constructor
e921c965 134EventViewerData *GuiEvents(mainWindow *pmParentWindow);
fbbb2697 135//! Event Viewer's destructor
136void GuiEvents_Destructor(EventViewerData *Event_Viewer_Data);
137
682c6edb 138static int Event_Selected_Hook(void *hook_data, void *call_data);
139
140void Tree_V_set_cursor(EventViewerData *Event_Viewer_Data);
141void Tree_V_get_cursor(EventViewerData *Event_Viewer_Data);
142
fbbb2697 143/* Prototype for selection handler callback */
144static void tree_selection_changed_cb (GtkTreeSelection *selection, gpointer data);
145static void v_scroll_cb (GtkAdjustment *adjustment, gpointer data);
146static void Tree_V_size_allocate_cb (GtkWidget *widget, GtkAllocation *alloc, gpointer data);
147static void Tree_V_size_request_cb (GtkWidget *widget, GtkRequisition *requisition, gpointer data);
b26121f4 148static void Tree_V_cursor_changed_cb (GtkWidget *widget, gpointer data);
149static void Tree_V_move_cursor_cb (GtkWidget *widget, GtkMovementStep arg1, gint arg2, gpointer data);
675f8f58 150static void Tree_V_grab_focus(GtkWidget *widget, gpointer data);
682c6edb 151
152
b671bb09 153static void get_test_data(double time, guint List_Height,
f2f6d498 154 EventViewerData *Event_Viewer_Data);
fbbb2697 155
156void add_test_data(EventViewerData *Event_Viewer_Data);
157
f2f6d498 158static void get_events(EventViewerData* Event_Viewer_Data, LttTime start,
b671bb09 159 LttTime end, unsigned maxNumEvents, unsigned * realNumEvent);
675f8f58 160static gboolean parse_event(void *hook_data, void *call_data);
161
5c7463ed 162/**
163 * plugin's init function
164 *
165 * This function initializes the Event Viewer functionnality through the
166 * gtkTraceSet API.
167 */
168G_MODULE_EXPORT void init() {
5c7463ed 169
675f8f58 170 g_critical("GUI Event Viewer init()");
171
172 /* Register the toolbar insert button */
173 ToolbarItemReg(hGuiEventsInsert_xpm, "Insert Event Viewer", hGuiEvents);
174
175 /* Register the menu item insert entry */
176 MenuItemReg("/", "Insert Event Viewer", hGuiEvents);
177
fbbb2697 178}
5c7463ed 179
fbbb2697 180void destroy_walk(gpointer data, gpointer user_data)
181{
675f8f58 182 GuiEvents_Destructor((EventViewerData*)data);
5c7463ed 183}
184
185/**
186 * plugin's destroy function
187 *
188 * This function releases the memory reserved by the module and unregisters
189 * everything that has been registered in the gtkTraceSet API.
190 */
191G_MODULE_EXPORT void destroy() {
675f8f58 192 int i;
193
194 EventViewerData *Event_Viewer_Data;
195
196 g_critical("GUI Event Viewer destroy()");
fbbb2697 197
675f8f58 198 g_slist_foreach(sEvent_Viewer_Data_List, destroy_walk, NULL );
fcdf0ec2 199
675f8f58 200 /* Unregister the toolbar insert button */
201 ToolbarItemUnreg(hGuiEvents);
fcdf0ec2 202
675f8f58 203 /* Unregister the menu item insert entry */
204 MenuItemUnreg(hGuiEvents);
5c7463ed 205}
206
fbbb2697 207/* Enumeration of the columns */
208enum
209{
675f8f58 210 CPUID_COLUMN,
211 EVENT_COLUMN,
212 TIME_COLUMN,
213 PID_COLUMN,
214 ENTRY_LEN_COLUMN,
215 EVENT_DESCR_COLUMN,
216 N_COLUMNS
fbbb2697 217};
218
219
5c7463ed 220/**
fbbb2697 221 * Event Viewer's constructor hook
5c7463ed 222 *
223 * This constructor is given as a parameter to the menuitem and toolbar button
fbbb2697 224 * registration. It creates the list.
225 * @param pmParentWindow A pointer to the parent window.
5c7463ed 226 * @return The widget created.
227 */
fbbb2697 228GtkWidget *
e921c965 229hGuiEvents(mainWindow * pmParentWindow)
fbbb2697 230{
675f8f58 231 EventViewerData* Event_Viewer_Data = GuiEvents(pmParentWindow) ;
fbbb2697 232
f9334f6f 233 if(Event_Viewer_Data)
234 return Event_Viewer_Data->HBox_V ;
235 else return NULL;
fbbb2697 236
237}
238
239/**
240 * Event Viewer's constructor
241 *
242 * This constructor is used to create EventViewerData data structure.
243 * @return The Event viewer data created.
244 */
245EventViewerData *
e921c965 246GuiEvents(mainWindow *pmParentWindow)
5c7463ed 247{
675f8f58 248 LttTime start, end;
249 GtkTreeViewColumn *column;
250 GtkCellRenderer *renderer;
251 EventViewerData* Event_Viewer_Data = g_new(EventViewerData,1) ;
675f8f58 252 RawTraceData * data;
b671bb09 253 double time_value;
254 unsigned size;
675f8f58 255
256 Event_Viewer_Data->mw = pmParentWindow;
257 GetTimeInterval(Event_Viewer_Data->mw, &Event_Viewer_Data->time_interval);
258 GetCurrentTime(Event_Viewer_Data->mw, &Event_Viewer_Data->current_time);
675f8f58 259
260 Event_Viewer_Data->before_event_hooks = lttv_hooks_new();
261 lttv_hooks_add(Event_Viewer_Data->before_event_hooks, parse_event, Event_Viewer_Data);
262
b671bb09 263 Event_Viewer_Data->raw_trace_data_queue = g_queue_new();
264 Event_Viewer_Data->raw_trace_data_queue_tmp = g_queue_new();
265
675f8f58 266 RegUpdateTimeInterval(updateTimeInterval,Event_Viewer_Data, Event_Viewer_Data->mw);
267 RegUpdateCurrentTime(updateCurrentTime,Event_Viewer_Data, Event_Viewer_Data->mw);
268
8b9fdc80 269 Event_Viewer_Data->Scroll_Win = gtk_scrolled_window_new (NULL, NULL);
270 gtk_widget_show ( Event_Viewer_Data->Scroll_Win);
271 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(Event_Viewer_Data->Scroll_Win),
272 GTK_POLICY_AUTOMATIC, GTK_POLICY_NEVER);
273
675f8f58 274 /* TEST DATA, TO BE READ FROM THE TRACE */
675f8f58 275 Event_Viewer_Data->Currently_Selected_Event = FALSE ;
276 Event_Viewer_Data->Selected_Event = 0;
277
278 /* Create a model for storing the data list */
fbbb2697 279 Event_Viewer_Data->Store_M = gtk_list_store_new (N_COLUMNS, /* Total number of columns */
675f8f58 280 G_TYPE_INT, /* CPUID */
281 G_TYPE_STRING, /* Event */
a60b01ef 282 G_TYPE_UINT64, /* Time */
675f8f58 283 G_TYPE_INT, /* PID */
284 G_TYPE_INT, /* Entry length */
285 G_TYPE_STRING); /* Event's description */
fbbb2697 286
675f8f58 287 /* Create the viewer widget for the columned list */
288 Event_Viewer_Data->Tree_V = gtk_tree_view_new_with_model (GTK_TREE_MODEL (Event_Viewer_Data->Store_M));
b26121f4 289
675f8f58 290 g_signal_connect (G_OBJECT (Event_Viewer_Data->Tree_V), "size-allocate",
291 G_CALLBACK (Tree_V_size_allocate_cb),
292 Event_Viewer_Data);
293 g_signal_connect (G_OBJECT (Event_Viewer_Data->Tree_V), "size-request",
294 G_CALLBACK (Tree_V_size_request_cb),
295 Event_Viewer_Data);
296
297 g_signal_connect (G_OBJECT (Event_Viewer_Data->Tree_V), "cursor-changed",
298 G_CALLBACK (Tree_V_cursor_changed_cb),
299 Event_Viewer_Data);
fbbb2697 300
675f8f58 301 g_signal_connect (G_OBJECT (Event_Viewer_Data->Tree_V), "move-cursor",
302 G_CALLBACK (Tree_V_move_cursor_cb),
303 Event_Viewer_Data);
304
305 g_signal_connect (G_OBJECT (Event_Viewer_Data->Tree_V), "grab-focus",
306 G_CALLBACK (Tree_V_grab_focus),
307 Event_Viewer_Data);
308
309 // Use on each column!
310 //gtk_tree_view_column_set_sizing(Event_Viewer_Data->Tree_V, GTK_TREE_VIEW_COLUMN_FIXED);
fcdf0ec2 311
675f8f58 312 /* The view now holds a reference. We can get rid of our own
313 * reference */
314 g_object_unref (G_OBJECT (Event_Viewer_Data->Store_M));
315
fcdf0ec2 316
fbbb2697 317 /* Create a column, associating the "text" attribute of the
318 * cell_renderer to the first column of the model */
675f8f58 319 /* Columns alignment : 0.0 : Left 0.5 : Center 1.0 : Right */
fbbb2697 320 renderer = gtk_cell_renderer_text_new ();
321 column = gtk_tree_view_column_new_with_attributes ("CPUID",
675f8f58 322 renderer,
323 "text", CPUID_COLUMN,
324 NULL);
325 gtk_tree_view_column_set_alignment (column, 0.0);
326 gtk_tree_view_column_set_fixed_width (column, 45);
fbbb2697 327 gtk_tree_view_append_column (GTK_TREE_VIEW (Event_Viewer_Data->Tree_V), column);
328
329 renderer = gtk_cell_renderer_text_new ();
330 column = gtk_tree_view_column_new_with_attributes ("Event",
675f8f58 331 renderer,
332 "text", EVENT_COLUMN,
333 NULL);
334 gtk_tree_view_column_set_alignment (column, 0.0);
335 gtk_tree_view_column_set_fixed_width (column, 120);
fbbb2697 336 gtk_tree_view_append_column (GTK_TREE_VIEW (Event_Viewer_Data->Tree_V), column);
337
338 renderer = gtk_cell_renderer_text_new ();
339 column = gtk_tree_view_column_new_with_attributes ("Time",
675f8f58 340 renderer,
341 "text", TIME_COLUMN,
342 NULL);
343 gtk_tree_view_column_set_alignment (column, 1.0);
344 gtk_tree_view_column_set_fixed_width (column, 120);
fbbb2697 345 gtk_tree_view_append_column (GTK_TREE_VIEW (Event_Viewer_Data->Tree_V), column);
346
347 renderer = gtk_cell_renderer_text_new ();
348 column = gtk_tree_view_column_new_with_attributes ("PID",
675f8f58 349 renderer,
350 "text", PID_COLUMN,
351 NULL);
352 gtk_tree_view_column_set_alignment (column, 1.0);
353 gtk_tree_view_column_set_fixed_width (column, 45);
fbbb2697 354 gtk_tree_view_append_column (GTK_TREE_VIEW (Event_Viewer_Data->Tree_V), column);
675f8f58 355
fbbb2697 356 renderer = gtk_cell_renderer_text_new ();
357 column = gtk_tree_view_column_new_with_attributes ("Entry Length",
675f8f58 358 renderer,
359 "text", ENTRY_LEN_COLUMN,
360 NULL);
361 gtk_tree_view_column_set_alignment (column, 1.0);
362 gtk_tree_view_column_set_fixed_width (column, 60);
fbbb2697 363 gtk_tree_view_append_column (GTK_TREE_VIEW (Event_Viewer_Data->Tree_V), column);
675f8f58 364
fbbb2697 365 renderer = gtk_cell_renderer_text_new ();
366 column = gtk_tree_view_column_new_with_attributes ("Event's Description",
675f8f58 367 renderer,
368 "text", EVENT_DESCR_COLUMN,
369 NULL);
370 gtk_tree_view_column_set_alignment (column, 0.0);
fbbb2697 371 gtk_tree_view_append_column (GTK_TREE_VIEW (Event_Viewer_Data->Tree_V), column);
372
373
675f8f58 374 /* Setup the selection handler */
375 Event_Viewer_Data->Select_C = gtk_tree_view_get_selection (GTK_TREE_VIEW (Event_Viewer_Data->Tree_V));
376 gtk_tree_selection_set_mode (Event_Viewer_Data->Select_C, GTK_SELECTION_SINGLE);
377 g_signal_connect (G_OBJECT (Event_Viewer_Data->Select_C), "changed",
378 G_CALLBACK (tree_selection_changed_cb),
379 Event_Viewer_Data);
fbbb2697 380
8b9fdc80 381 gtk_container_add (GTK_CONTAINER (Event_Viewer_Data->Scroll_Win), Event_Viewer_Data->Tree_V);
382
fbbb2697 383 Event_Viewer_Data->HBox_V = gtk_hbox_new(0, 0);
8b9fdc80 384 gtk_box_pack_start(GTK_BOX(Event_Viewer_Data->HBox_V), Event_Viewer_Data->Scroll_Win, TRUE, TRUE, 0);
fcdf0ec2 385
386 /* Create vertical scrollbar and pack it */
fbbb2697 387 Event_Viewer_Data->VScroll_VC = gtk_vscrollbar_new(NULL);
388 gtk_box_pack_start(GTK_BOX(Event_Viewer_Data->HBox_V), Event_Viewer_Data->VScroll_VC, FALSE, TRUE, 0);
675f8f58 389
fcdf0ec2 390 /* Get the vertical scrollbar's adjustment */
fbbb2697 391 Event_Viewer_Data->VAdjust_C = gtk_range_get_adjustment(GTK_RANGE(Event_Viewer_Data->VScroll_VC));
675f8f58 392 Event_Viewer_Data->VTree_Adjust_C = gtk_tree_view_get_vadjustment(
393 GTK_TREE_VIEW (Event_Viewer_Data->Tree_V));
394
395 g_signal_connect (G_OBJECT (Event_Viewer_Data->VAdjust_C), "value-changed",
396 G_CALLBACK (v_scroll_cb),
397 Event_Viewer_Data);
398 /* Set the upper bound to the last event number */
b671bb09 399 Event_Viewer_Data->previous_value = 0;
400 Event_Viewer_Data->VAdjust_C->lower = 0.0;
401 //Event_Viewer_Data->VAdjust_C->upper = Event_Viewer_Data->Number_Of_Events;
402 Event_Viewer_Data->VAdjust_C->value = 0.0;
403 Event_Viewer_Data->VAdjust_C->step_increment = 1.0;
404 Event_Viewer_Data->VAdjust_C->page_increment = 2.0;
405 // Event_Viewer_Data->VTree_Adjust_C->upper;
406 Event_Viewer_Data->VAdjust_C->page_size = 2.0;
407 // Event_Viewer_Data->VTree_Adjust_C->upper;
675f8f58 408 g_critical("value : %u",Event_Viewer_Data->VTree_Adjust_C->upper);
fbbb2697 409 /* Raw event trace */
410 gtk_widget_show(Event_Viewer_Data->HBox_V);
411 gtk_widget_show(Event_Viewer_Data->Tree_V);
412 gtk_widget_show(Event_Viewer_Data->VScroll_VC);
413
675f8f58 414 /* Add the object's information to the module's array */
e921c965 415 sEvent_Viewer_Data_List = g_slist_append(sEvent_Viewer_Data_List, Event_Viewer_Data);
fbbb2697 416
675f8f58 417 Event_Viewer_Data->First_Event = -1 ;
418 Event_Viewer_Data->Last_Event = 0 ;
419
420 Event_Viewer_Data->Num_Visible_Events = 1;
421
b671bb09 422 //get the life span of the traceset and set the upper of the scroll bar
423 getTracesetTimeSpan(Event_Viewer_Data->mw, &Event_Viewer_Data->trace_start,
424 &Event_Viewer_Data->trace_end);
425 time_value = Event_Viewer_Data->trace_end.tv_sec - Event_Viewer_Data->trace_start.tv_sec;
426 time_value *= NANSECOND_CONST;
427 time_value += (double)Event_Viewer_Data->trace_end.tv_nsec - Event_Viewer_Data->trace_start.tv_nsec;
428 Event_Viewer_Data->VAdjust_C->upper = time_value;
429
430 Event_Viewer_Data->append = TRUE;
431
675f8f58 432 start.tv_sec = 0;
433 start.tv_nsec = 0;
f2f6d498 434 end.tv_sec = G_MAXULONG;
435 end.tv_nsec = G_MAXULONG;
675f8f58 436
b671bb09 437 get_events(Event_Viewer_Data, start,end, RESERVE_SMALL_SIZE, &size);
f9334f6f 438
b671bb09 439 Event_Viewer_Data->start_event_index = 0;
440 Event_Viewer_Data->end_event_index = Event_Viewer_Data->Num_Visible_Events - 1;
675f8f58 441
442 // Test data
b671bb09 443 get_test_data(Event_Viewer_Data->VAdjust_C->value,
675f8f58 444 Event_Viewer_Data->Num_Visible_Events,
445 Event_Viewer_Data);
446
447 /* Set the Selected Event */
b671bb09 448 // Tree_V_set_cursor(Event_Viewer_Data);
675f8f58 449
450 return Event_Viewer_Data;
fbbb2697 451}
fcdf0ec2 452
682c6edb 453void Tree_V_set_cursor(EventViewerData *Event_Viewer_Data)
454{
675f8f58 455 GtkTreePath *path;
456
457 if(Event_Viewer_Data->Selected_Event && Event_Viewer_Data->First_Event != -1)
458 {
b671bb09 459 // gtk_adjustment_set_value(Event_Viewer_Data->VAdjust_C,
460 // Event_Viewer_Data->Currently_Selected_Event);
675f8f58 461
462 path = gtk_tree_path_new_from_indices(
463 Event_Viewer_Data->Currently_Selected_Event-
464 Event_Viewer_Data->First_Event,
465 -1);
466
467 gtk_tree_view_set_cursor(GTK_TREE_VIEW(Event_Viewer_Data->Tree_V), path, NULL, FALSE);
468 gtk_tree_path_free(path);
469 }
682c6edb 470}
471
472void Tree_V_get_cursor(EventViewerData *Event_Viewer_Data)
473{
675f8f58 474 GtkTreePath *path;
475 gint *indices;
682c6edb 476
675f8f58 477 gtk_tree_view_get_cursor(GTK_TREE_VIEW(Event_Viewer_Data->Tree_V), &path, NULL);
478 indices = gtk_tree_path_get_indices(path);
479
480 if(indices != NULL)
481 {
482 Event_Viewer_Data->Selected_Event = TRUE;
483 Event_Viewer_Data->Currently_Selected_Event =
484 Event_Viewer_Data->First_Event + indices[0];
485
486 } else {
487 Event_Viewer_Data->Selected_Event = FALSE;
488 Event_Viewer_Data->Currently_Selected_Event = 0;
489 }
490 g_critical("DEBUG : Event Selected : %i , num: %u", Event_Viewer_Data->Selected_Event, Event_Viewer_Data->Currently_Selected_Event) ;
491
492 gtk_tree_path_free(path);
682c6edb 493
494}
495
496
497
b26121f4 498void Tree_V_move_cursor_cb (GtkWidget *widget, GtkMovementStep arg1, gint arg2, gpointer data)
fbbb2697 499{
675f8f58 500 GtkTreePath *path; // = gtk_tree_path_new();
501 gint *indices;
502 gdouble value;
503 EventViewerData *Event_Viewer_Data = (EventViewerData*)data;
504
505 gtk_tree_view_get_cursor(GTK_TREE_VIEW(Event_Viewer_Data->Tree_V), &path, NULL);
506 if(path == NULL)
507 {
508 /* No prior cursor, put it at beginning of page and let the execution do */
509 path = gtk_tree_path_new_from_indices(0, -1);
510 gtk_tree_view_set_cursor(GTK_TREE_VIEW(Event_Viewer_Data->Tree_V), path, NULL, FALSE);
511 }
512
513 indices = gtk_tree_path_get_indices(path);
514
515 g_critical("DEBUG : move cursor step : %u , int : %i , indice : %i", (guint)arg1, arg2, indices[0]) ;
516
517 value = gtk_adjustment_get_value(Event_Viewer_Data->VAdjust_C);
518
519 if(arg1 == GTK_MOVEMENT_DISPLAY_LINES)
520 {
521 /* Move one line */
522 if(arg2 == 1)
b26121f4 523 {
675f8f58 524 /* move one line down */
525 if(indices[0] == Event_Viewer_Data->Num_Visible_Events - 1)
526 {
527 if(value + Event_Viewer_Data->Num_Visible_Events <=
528 Event_Viewer_Data->Number_Of_Events -1)
b26121f4 529 {
675f8f58 530 g_critical("need 1 event down") ;
531 Event_Viewer_Data->Currently_Selected_Event += 1;
b671bb09 532 // gtk_adjustment_set_value(Event_Viewer_Data->VAdjust_C, value+1);
675f8f58 533 //gtk_tree_path_free(path);
534 //path = gtk_tree_path_new_from_indices(Event_Viewer_Data->Num_Visible_Events-1, -1);
535 //gtk_tree_view_set_cursor(GTK_TREE_VIEW(Event_Viewer_Data->Tree_V), path, NULL, FALSE);
536 g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
b26121f4 537 }
675f8f58 538 }
539 } else {
540 /* Move one line up */
541 if(indices[0] == 0)
542 {
543 if(value - 1 >= 0 )
544 {
545 g_critical("need 1 event up") ;
546 Event_Viewer_Data->Currently_Selected_Event -= 1;
b671bb09 547 // gtk_adjustment_set_value(Event_Viewer_Data->VAdjust_C, value-1);
675f8f58 548 //gtk_tree_path_free(path);
549 //path = gtk_tree_path_new_from_indices(0, -1);
550 //gtk_tree_view_set_cursor(GTK_TREE_VIEW(Event_Viewer_Data->Tree_V), path, NULL, FALSE);
551 g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
552 }
553
554 }
b26121f4 555 }
675f8f58 556
557 }
558
559 if(arg1 == GTK_MOVEMENT_PAGES)
560 {
561 /* Move one page */
562 if(arg2 == 1)
b26121f4 563 {
675f8f58 564 if(Event_Viewer_Data->Num_Visible_Events == 1)
565 value += 1 ;
566 /* move one page down */
567 if(value + Event_Viewer_Data->Num_Visible_Events-1 <=
568 Event_Viewer_Data->Number_Of_Events )
569 {
570 g_critical("need 1 page down") ;
571
572 Event_Viewer_Data->Currently_Selected_Event += Event_Viewer_Data->Num_Visible_Events-1;
b671bb09 573 // gtk_adjustment_set_value(Event_Viewer_Data->VAdjust_C,
574 // value+(Event_Viewer_Data->Num_Visible_Events-1));
675f8f58 575 //gtk_tree_path_free(path);
576 //path = gtk_tree_path_new_from_indices(0, -1);
577 //gtk_tree_view_set_cursor(GTK_TREE_VIEW(Event_Viewer_Data->Tree_V), path, NULL, FALSE);
578 g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
579 }
580 } else {
581 /* Move one page up */
582 if(Event_Viewer_Data->Num_Visible_Events == 1)
583 value -= 1 ;
584
585 if(indices[0] < Event_Viewer_Data->Num_Visible_Events - 2 )
586 {
587 if(value - (Event_Viewer_Data->Num_Visible_Events-1) >= 0)
b26121f4 588 {
675f8f58 589 g_critical("need 1 page up") ;
590
591 Event_Viewer_Data->Currently_Selected_Event -= Event_Viewer_Data->Num_Visible_Events-1;
592
b671bb09 593 // gtk_adjustment_set_value(Event_Viewer_Data->VAdjust_C,
594 // value-(Event_Viewer_Data->Num_Visible_Events-1));
675f8f58 595 //gtk_tree_path_free(path);
596 //path = gtk_tree_path_new_from_indices(0, -1);
597 //gtk_tree_view_set_cursor(GTK_TREE_VIEW(Event_Viewer_Data->Tree_V), path, NULL, FALSE);
598 g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
599
b26121f4 600 } else {
675f8f58 601 /* Go to first Event */
602 g_critical("need 1 page up") ;
603
604 Event_Viewer_Data->Currently_Selected_Event == 0 ;
b671bb09 605 // gtk_adjustment_set_value(Event_Viewer_Data->VAdjust_C,
606 // 0);
675f8f58 607 //gtk_tree_path_free(path);
608 //path = gtk_tree_path_new_from_indices(0, -1);
609 //gtk_tree_view_set_cursor(GTK_TREE_VIEW(Event_Viewer_Data->Tree_V), path, NULL, FALSE);
610 g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
611
b26121f4 612 }
675f8f58 613 }
614
b26121f4 615 }
675f8f58 616
617 }
618
619 if(arg1 == GTK_MOVEMENT_BUFFER_ENDS)
620 {
621 /* Move to the ends of the buffer */
622 if(arg2 == 1)
b26121f4 623 {
675f8f58 624 /* move end of buffer */
625 g_critical("End of buffer") ;
626 Event_Viewer_Data->Currently_Selected_Event = Event_Viewer_Data->Number_Of_Events-1 ;
b671bb09 627 // gtk_adjustment_set_value(Event_Viewer_Data->VAdjust_C,
628 // Event_Viewer_Data->Number_Of_Events -
629 // Event_Viewer_Data->Num_Visible_Events);
675f8f58 630 //gtk_tree_path_free(path);
631 //path = gtk_tree_path_new_from_indices(Event_Viewer_Data->Num_Visible_Events-1, -1);
632 //gtk_tree_view_set_cursor(GTK_TREE_VIEW(Event_Viewer_Data->Tree_V), path, NULL, FALSE);
633 g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
634 } else {
635 /* Move beginning of buffer */
636 g_critical("Beginning of buffer") ;
637 Event_Viewer_Data->Currently_Selected_Event = 0 ;
b671bb09 638 // gtk_adjustment_set_value(Event_Viewer_Data->VAdjust_C, 0);
682c6edb 639 //gtk_tree_path_free(path);
640 //path = gtk_tree_path_new_from_indices(0, -1);
641 //gtk_tree_view_set_cursor(GTK_TREE_VIEW(Event_Viewer_Data->Tree_V), path, NULL, FALSE);
675f8f58 642 g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
b26121f4 643 }
675f8f58 644
645 }
646
647
648 gtk_tree_path_free(path);
b26121f4 649}
650
651void Tree_V_cursor_changed_cb (GtkWidget *widget, gpointer data)
652{
675f8f58 653 EventViewerData *Event_Viewer_Data = (EventViewerData*) data;
654 LttTime ltt_time;
a60b01ef 655 guint64 time;
675f8f58 656 GtkTreeIter iter;
657 GtkTreeModel* model = GTK_TREE_MODEL(Event_Viewer_Data->Store_M);
658 GtkTreePath *path;
659
660 g_critical("DEBUG : cursor change");
661 /* On cursor change, modify the currently selected event by calling
662 * the right API function */
663 Tree_V_get_cursor(Event_Viewer_Data);
664/*
665 gtk_tree_view_get_cursor(GTK_TREE_VIEW(Event_Viewer_Data->Tree_V), &path, NULL);
666 if(gtk_tree_model_get_iter(model,&iter,path)){
667 gtk_tree_model_get(model, &iter, TIME_COLUMN, &time, -1);
b671bb09 668 ltt_time.tv_sec = time / NANSECOND_CONST;
669 ltt_time.tv_nsec = time % NANSECOND_CONST;
675f8f58 670
671 if(ltt_time.tv_sec != Event_Viewer_Data->current_time.tv_sec ||
672 ltt_time.tv_nsec != Event_Viewer_Data->current_time.tv_nsec)
673 SetCurrentTime(Event_Viewer_Data->mw,&ltt_time);
674 }else{
675 g_warning("Can not get iter\n");
676 }
677*/
b26121f4 678}
679
680
681void v_scroll_cb (GtkAdjustment *adjustment, gpointer data)
682{
675f8f58 683 EventViewerData *Event_Viewer_Data = (EventViewerData*)data;
684 GtkTreePath *Tree_Path;
685
686 g_critical("DEBUG : scroll signal, value : %f", adjustment->value);
687
b671bb09 688 get_test_data(adjustment->value, Event_Viewer_Data->Num_Visible_Events,
675f8f58 689 Event_Viewer_Data);
690
691
692 if(Event_Viewer_Data->Currently_Selected_Event
693 >= Event_Viewer_Data->First_Event
694 &&
695 Event_Viewer_Data->Currently_Selected_Event
696 <= Event_Viewer_Data->Last_Event
697 &&
698 Event_Viewer_Data->Selected_Event)
699 {
700
701 Tree_Path = gtk_tree_path_new_from_indices(
702 Event_Viewer_Data->Currently_Selected_Event-
703 Event_Viewer_Data->First_Event,
704 -1);
705
706 gtk_tree_view_set_cursor(GTK_TREE_VIEW(Event_Viewer_Data->Tree_V), Tree_Path,
707 NULL, FALSE);
708 gtk_tree_path_free(Tree_Path);
709 }
b671bb09 710
675f8f58 711
fbbb2697 712}
fcdf0ec2 713
6601bf27 714gint get_cell_height(GtkTreeView *TreeView)
715{
675f8f58 716 gint height, width;
717 GtkTreeViewColumn *Column = gtk_tree_view_get_column(TreeView, 0);
718 GList *Render_List = gtk_tree_view_column_get_cell_renderers(Column);
719 GtkCellRenderer *Renderer = g_list_first(Render_List)->data;
720
721 gtk_tree_view_column_cell_get_size(Column, NULL, NULL, NULL, NULL, &height);
722 g_critical("cell 0 height : %u",height);
723
724 return height;
6601bf27 725}
726
fbbb2697 727void Tree_V_size_allocate_cb (GtkWidget *widget, GtkAllocation *alloc, gpointer data)
728{
675f8f58 729 EventViewerData *Event_Viewer_Data = (EventViewerData*)data;
730 gint Cell_Height = get_cell_height(GTK_TREE_VIEW(Event_Viewer_Data->Tree_V));
731 gint Last_Num_Visible_Events = Event_Viewer_Data->Num_Visible_Events;
732 gdouble Exact_Num_Visible;
733
734 g_critical("size-allocate");
735
736 Exact_Num_Visible = ( alloc->height -
6601bf27 737 TREE_VIEW_HEADER_HEIGHT (GTK_TREE_VIEW(Event_Viewer_Data->Tree_V)) )
675f8f58 738 / (double)Cell_Height ;
739
740 Event_Viewer_Data->Num_Visible_Events = ceil(Exact_Num_Visible) ;
741
742 g_critical("number of events shown : %u",Event_Viewer_Data->Num_Visible_Events);
743 g_critical("ex number of events shown : %f",Exact_Num_Visible);
744
b671bb09 745/*
675f8f58 746 Event_Viewer_Data->VAdjust_C->page_increment =
747 floor(Exact_Num_Visible);
748 Event_Viewer_Data->VAdjust_C->page_size =
749 floor(Exact_Num_Visible);
b671bb09 750*/
675f8f58 751
752 if(Event_Viewer_Data->Num_Visible_Events != Last_Num_Visible_Events)
753 {
b671bb09 754 get_test_data(Event_Viewer_Data->VAdjust_C->value,
675f8f58 755 Event_Viewer_Data->Num_Visible_Events,
756 Event_Viewer_Data);
757 }
758
6601bf27 759
fbbb2697 760}
761
762void Tree_V_size_request_cb (GtkWidget *widget, GtkRequisition *requisition, gpointer data)
763{
675f8f58 764 gint h;
765 EventViewerData *Event_Viewer_Data = (EventViewerData*)data;
766 gint Cell_Height = get_cell_height(GTK_TREE_VIEW(Event_Viewer_Data->Tree_V));
fbbb2697 767
675f8f58 768 g_critical("size-request");
fbbb2697 769
675f8f58 770 h = Cell_Height + TREE_VIEW_HEADER_HEIGHT
771 (GTK_TREE_VIEW(Event_Viewer_Data->Tree_V));
772 requisition->height = h;
fbbb2697 773
fcdf0ec2 774}
775
b671bb09 776void get_test_data(double time_value, guint List_Height,
675f8f58 777 EventViewerData *Event_Viewer_Data)
b26121f4 778{
675f8f58 779 GtkTreeIter iter;
b671bb09 780 int i;
675f8f58 781 GtkTreeModel *model = GTK_TREE_MODEL(Event_Viewer_Data->Store_M);
782 GtkTreePath *Tree_Path;
675f8f58 783 RawTraceData * raw_data;
b671bb09 784 ScrollDirection direction = SCROLL_NONE;
785 GList * first;
786 int Event_Number;
787 double value = Event_Viewer_Data->previous_value - time_value;
788 LttTime start, end, time;
789 LttEvent * ev;
790 unsigned backward_num, minNum, maxNum;
791 LttTracefile * tf;
792 unsigned block_num, event_num;
793 unsigned size = 1, count = 0;
794 gboolean needBackwardAgain, backward;
795
796 g_warning("DEBUG : get_test_data, time value %f\n", time_value);
797
675f8f58 798 // if(Event_Number > Event_Viewer_Data->Last_Event ||
799 // Event_Number + List_Height-1 < Event_Viewer_Data->First_Event ||
800 // Event_Viewer_Data->First_Event == -1)
801 {
802 /* no event can be reused, clear and start from nothing */
b671bb09 803 if(value == -1.0) direction = SCROLL_STEP_DOWN;
804 else if(value == 1.0 ) direction = SCROLL_STEP_UP;
805 else if(value == -2.0) direction = SCROLL_PAGE_DOWN;
806 else if(value == 2.0 ) direction = SCROLL_PAGE_UP;
807 else if(value == 0.0 ) direction = SCROLL_NONE;
808 else direction = SCROLL_JUMP;
809
810 switch(direction){
811 case SCROLL_STEP_UP:
812 case SCROLL_PAGE_UP:
813 if(direction == SCROLL_PAGE_UP){
814 backward = List_Height>Event_Viewer_Data->start_event_index ? TRUE : FALSE;
a60b01ef 815 }else{
b671bb09 816 backward = Event_Viewer_Data->start_event_index == 0 ? TRUE : FALSE;
a60b01ef 817 }
b671bb09 818 if(backward){
819 Event_Viewer_Data->append = FALSE;
820 do{
821 if(direction == SCROLL_PAGE_UP){
822 minNum = List_Height - Event_Viewer_Data->start_event_index ;
823 }else{
824 minNum = 1;
825 }
826
827 first = Event_Viewer_Data->raw_trace_data_queue->head;
828 raw_data = (RawTraceData*)g_list_nth_data(first,0);
829 end = raw_data->time;
830 end.tv_nsec--;
831 ltt_event_position_get(&raw_data->ep, &block_num, &event_num, &tf);
832 if(size !=0){
833 if(event_num > minNum){
834 backward_num = event_num > RESERVE_SMALL_SIZE
835 ? event_num - RESERVE_SMALL_SIZE : 1;
836 ltt_event_position_set(&raw_data->ep, block_num, backward_num);
837 ltt_tracefile_seek_position(tf, &raw_data->ep);
838 ev = ltt_tracefile_read(tf);
839 start = ltt_event_time(ev);
840 maxNum = G_MAXULONG;
841 }else{
842 if(block_num > 1){
843 ltt_event_position_set(&raw_data->ep, block_num-1, 1);
844 ltt_tracefile_seek_position(tf, &raw_data->ep);
845 ev = ltt_tracefile_read(tf);
846 start = ltt_event_time(ev);
847 }else{
848 start.tv_sec = 0;
849 start.tv_nsec = 0;
850 }
851 maxNum = G_MAXULONG;
852 }
853 }else{
854 if(block_num > count){
855 ltt_event_position_set(&raw_data->ep, block_num-count, 1);
856 ltt_tracefile_seek_position(tf, &raw_data->ep);
857 ev = ltt_tracefile_read(tf);
858 start = ltt_event_time(ev);
859 }else{
860 start.tv_sec = 0;
861 start.tv_nsec = 0;
862 }
863 maxNum = G_MAXULONG;
864 }
865
866 Event_Viewer_Data->current_event_index = Event_Viewer_Data->start_event_index;
867 get_events(Event_Viewer_Data, start, end, maxNum, &size);
868 Event_Viewer_Data->start_event_index = Event_Viewer_Data->current_event_index;
869
870 if(size < minNum && (start.tv_sec !=0 || start.tv_nsec !=0))
871 needBackwardAgain = TRUE;
872 else needBackwardAgain = FALSE;
873 if(size == 0){
874 count++;
875 }else{
876 count = 0;
877 }
878 }while(needBackwardAgain);
a60b01ef 879 }
b671bb09 880 if(direction == SCROLL_STEP_UP)
881 Event_Number = Event_Viewer_Data->start_event_index - 1;
882 else
883 Event_Number = Event_Viewer_Data->start_event_index - List_Height;
884 break;
885 case SCROLL_STEP_DOWN:
886 if(Event_Viewer_Data->end_event_index == Event_Viewer_Data->Number_Of_Events - 1){
887 Event_Viewer_Data->append = TRUE;
888 first = Event_Viewer_Data->raw_trace_data_queue->head;
889 raw_data = (RawTraceData*)g_list_nth_data(first,Event_Viewer_Data->Number_Of_Events - 1);
890 start = raw_data->time;
891 start.tv_nsec++;
892 end.tv_sec = G_MAXULONG;
893 end.tv_nsec = G_MAXULONG;
894 get_events(Event_Viewer_Data, start, end, RESERVE_SMALL_SIZE, &size);
895 }else size = 1;
896 if(size > 0) Event_Number = Event_Viewer_Data->start_event_index + 1;
897 else Event_Number = Event_Viewer_Data->start_event_index;
898 break;
899 case SCROLL_PAGE_DOWN:
900 if(Event_Viewer_Data->end_event_index >= Event_Viewer_Data->Number_Of_Events - 1 - List_Height){
901 Event_Viewer_Data->append = TRUE;
902 first = Event_Viewer_Data->raw_trace_data_queue->head;
903 raw_data = (RawTraceData*)g_list_nth_data(first,Event_Viewer_Data->Number_Of_Events - 1);
904 start = raw_data->time;
905 start.tv_nsec++;
906 end.tv_sec = G_MAXULONG;
907 end.tv_nsec = G_MAXULONG;
908 get_events(Event_Viewer_Data, start, end, RESERVE_SMALL_SIZE,&size);
a60b01ef 909 }
b671bb09 910 if(List_Height <= Event_Viewer_Data->Number_Of_Events - 1 - Event_Viewer_Data->end_event_index)
911 Event_Number = Event_Viewer_Data->start_event_index + List_Height - 1;
912 else
913 Event_Number = Event_Viewer_Data->Number_Of_Events - 1 - List_Height;
914 break;
915 case SCROLL_JUMP:
916 Event_Viewer_Data->append = TRUE;
917 remove_all_items_from_queue(Event_Viewer_Data->raw_trace_data_queue);
918 end.tv_sec = G_MAXULONG;
919 end.tv_nsec = G_MAXULONG;
920 start = Event_Viewer_Data->trace_start;
921 value = (int)(time_value / NANSECOND_CONST);
922 start.tv_sec += value;
923 value = time_value / NANSECOND_CONST - value;
924 value *= NANSECOND_CONST;
925 start.tv_nsec += value;
926 if(start.tv_nsec > NANSECOND_CONST){
927 start.tv_sec++;
928 start.tv_nsec -= NANSECOND_CONST;
a60b01ef 929 }
b671bb09 930 Event_Viewer_Data->previous_value = time_value;
931 get_events(Event_Viewer_Data, start, end, RESERVE_SMALL_SIZE,&size);
932 if(size < List_Height){
933 Event_Viewer_Data->append = FALSE;
934 first = Event_Viewer_Data->raw_trace_data_queue->head;
935 raw_data = (RawTraceData*)g_list_nth_data(first,0);
936 end = raw_data->time;
937 end.tv_nsec--;
938 ltt_event_position_get(&raw_data->ep, &block_num, &event_num, &tf);
939
940 if(event_num > List_Height - size){
941 backward_num = event_num > RESERVE_SMALL_SIZE
942 ? event_num - RESERVE_SMALL_SIZE : 1;
943 ltt_event_position_set(&raw_data->ep, block_num, backward_num);
944 ltt_tracefile_seek_position(tf, &raw_data->ep);
945 ev = ltt_tracefile_read(tf);
946 start = ltt_event_time(ev);
947 maxNum = G_MAXULONG;
948 Event_Viewer_Data->current_event_index = 0;
949 get_events(Event_Viewer_Data, start, end, maxNum, &size);
950 Event_Viewer_Data->start_event_index = Event_Viewer_Data->current_event_index;
951 }
50ca4ac7 952 Event_Number = Event_Viewer_Data->raw_trace_data_queue->length - List_Height;
953 }else{
954 Event_Number = 0;
a60b01ef 955 }
b671bb09 956 break;
957 case SCROLL_NONE:
958 Event_Number = Event_Viewer_Data->current_event_index;
959 break;
960 default:
961 break;
962 }
675f8f58 963
b671bb09 964 //update the value of the scroll bar
965 if(direction != SCROLL_NONE && direction != SCROLL_JUMP){
966 first = Event_Viewer_Data->raw_trace_data_queue->head;
967 raw_data = (RawTraceData*)g_list_nth_data(first,Event_Number);
968 value = raw_data->time.tv_sec;
969 value -= Event_Viewer_Data->trace_start.tv_sec;
970 value *= NANSECOND_CONST;
971 value -= Event_Viewer_Data->trace_start.tv_nsec;
972 value += raw_data->time.tv_nsec;
973 Event_Viewer_Data->VAdjust_C->value = value;
974 g_signal_stop_emission_by_name(G_OBJECT(Event_Viewer_Data->VAdjust_C), "value-changed");
975 Event_Viewer_Data->previous_value = value;
675f8f58 976 }
977
675f8f58 978
b671bb09 979 Event_Viewer_Data->start_event_index = Event_Number;
980 Event_Viewer_Data->end_event_index = Event_Number + List_Height - 1;
981
982 first = Event_Viewer_Data->raw_trace_data_queue->head;
675f8f58 983 gtk_list_store_clear(Event_Viewer_Data->Store_M);
984 for(i=Event_Number; i<Event_Number+List_Height; i++)
985 {
a60b01ef 986 guint64 real_data;
987
675f8f58 988 if(i>=Event_Viewer_Data->Number_Of_Events) break;
b671bb09 989
990 raw_data = (RawTraceData*)g_list_nth_data(first, i);
675f8f58 991
b671bb09 992 // Add a new row to the model
a60b01ef 993 real_data = raw_data->time.tv_sec;
b671bb09 994 real_data *= NANSECOND_CONST;
a60b01ef 995 real_data += raw_data->time.tv_nsec;
675f8f58 996 gtk_list_store_append (Event_Viewer_Data->Store_M, &iter);
997 gtk_list_store_set (Event_Viewer_Data->Store_M, &iter,
998 CPUID_COLUMN, raw_data->cpu_id,
999 EVENT_COLUMN, raw_data->event_name,
a60b01ef 1000 TIME_COLUMN, real_data,
675f8f58 1001 PID_COLUMN, raw_data->pid,
1002 ENTRY_LEN_COLUMN, raw_data->entry_length,
1003 EVENT_DESCR_COLUMN, raw_data->event_description,
1004 -1);
1005/*
b671bb09 1006 gtk_list_store_append (Event_Viewer_Data->Store_M, &iter);
675f8f58 1007 gtk_list_store_set (Event_Viewer_Data->Store_M, &iter,
1008 CPUID_COLUMN, 0,
1009 EVENT_COLUMN, "event irq",
1010 TIME_COLUMN, i,
1011 PID_COLUMN, 100,
1012 ENTRY_LEN_COLUMN, 17,
1013 EVENT_DESCR_COLUMN, "Detailed information",
1014 -1);
1015*/
1016 }
1017 }
1018#ifdef DEBUG //do not use this, it's slower and broken
1019 // } else {
1020 /* Some events will be reused */
1021 if(Event_Number < Event_Viewer_Data->First_Event)
1022 {
1023 /* scrolling up, prepend events */
1024 Tree_Path = gtk_tree_path_new_from_indices
1025 (Event_Number+List_Height-1 -
1026 Event_Viewer_Data->First_Event + 1,
1027 -1);
1028 for(i=0; i<Event_Viewer_Data->Last_Event-(Event_Number+List_Height-1);
1029 i++)
b26121f4 1030 {
675f8f58 1031 /* Remove the last events from the list */
1032 if(gtk_tree_model_get_iter(model, &iter, Tree_Path))
1033 gtk_list_store_remove(Event_Viewer_Data->Store_M, &iter);
b26121f4 1034 }
675f8f58 1035
1036 for(i=Event_Viewer_Data->First_Event-1; i>=Event_Number; i--)
1037 {
1038 if(i>=Event_Viewer_Data->Number_Of_Events) break;
1039 /* Prepend new events */
1040 gtk_list_store_prepend (Event_Viewer_Data->Store_M, &iter);
1041 gtk_list_store_set (Event_Viewer_Data->Store_M, &iter,
1042 CPUID_COLUMN, 0,
1043 EVENT_COLUMN, "event irq",
1044 TIME_COLUMN, i,
1045 PID_COLUMN, 100,
1046 ENTRY_LEN_COLUMN, 17,
1047 EVENT_DESCR_COLUMN, "Detailed information",
1048 -1);
b26121f4 1049 }
675f8f58 1050 } else {
1051 /* Scrolling down, append events */
1052 for(i=Event_Viewer_Data->First_Event; i<Event_Number; i++)
1053 {
1054 /* Remove these events from the list */
1055 gtk_tree_model_get_iter_first(model, &iter);
1056 gtk_list_store_remove(Event_Viewer_Data->Store_M, &iter);
1057 }
1058 for(i=Event_Viewer_Data->Last_Event+1; i<Event_Number+List_Height; i++)
1059 {
1060 if(i>=Event_Viewer_Data->Number_Of_Events) break;
1061 /* Append new events */
1062 gtk_list_store_append (Event_Viewer_Data->Store_M, &iter);
1063 gtk_list_store_set (Event_Viewer_Data->Store_M, &iter,
1064 CPUID_COLUMN, 0,
1065 EVENT_COLUMN, "event irq",
1066 TIME_COLUMN, i,
1067 PID_COLUMN, 100,
1068 ENTRY_LEN_COLUMN, 17,
1069 EVENT_DESCR_COLUMN, "Detailed information",
1070 -1);
1071 }
1072
1073 }
1074 //}
b26121f4 1075#endif //DEBUG
b671bb09 1076 Event_Viewer_Data->First_Event = Event_Viewer_Data->start_event_index ;
1077 Event_Viewer_Data->Last_Event = Event_Viewer_Data->end_event_index ;
675f8f58 1078
682c6edb 1079
1080
b26121f4 1081}
1082
fbbb2697 1083
1084void add_test_data(EventViewerData *Event_Viewer_Data)
fcdf0ec2 1085{
675f8f58 1086 GtkTreeIter iter;
1087 int i;
1088
1089 for(i=0; i<10; i++)
1090 {
1091 /* Add a new row to the model */
1092 gtk_list_store_append (Event_Viewer_Data->Store_M, &iter);
1093 gtk_list_store_set (Event_Viewer_Data->Store_M, &iter,
1094 CPUID_COLUMN, 0,
1095 EVENT_COLUMN, "event irq",
1096 TIME_COLUMN, i,
1097 PID_COLUMN, 100,
1098 ENTRY_LEN_COLUMN, 17,
1099 EVENT_DESCR_COLUMN, "Detailed information",
1100 -1);
1101 }
1102
fbbb2697 1103}
1104
fcdf0ec2 1105
fbbb2697 1106void
1107GuiEvents_Destructor(EventViewerData *Event_Viewer_Data)
1108{
675f8f58 1109 guint index;
1110
1111 /* May already been done by GTK window closing */
1112 if(GTK_IS_WIDGET(Event_Viewer_Data->HBox_V))
1113 gtk_widget_destroy(Event_Viewer_Data->HBox_V);
1114
1115 /* Destroy the Tree View */
1116 //gtk_widget_destroy(Event_Viewer_Data->Tree_V);
1117
fbbb2697 1118 /* Clear raw event list */
675f8f58 1119 //gtk_list_store_clear(Event_Viewer_Data->Store_M);
1120 //gtk_widget_destroy(GTK_WIDGET(Event_Viewer_Data->Store_M));
1121
1122 g_slist_remove(sEvent_Viewer_Data_List,Event_Viewer_Data);
1123 g_free(Event_Viewer_Data);
fcdf0ec2 1124}
1125
fbbb2697 1126//FIXME : call hGuiEvents_Destructor for corresponding data upon widget destroy
1127
1128static void
1129tree_selection_changed_cb (GtkTreeSelection *selection, gpointer data)
1130{
675f8f58 1131 EventViewerData *Event_Viewer_Data = (EventViewerData*)data;
1132 GtkTreeIter iter;
1133 GtkTreeModel *model = GTK_TREE_MODEL(Event_Viewer_Data->Store_M);
1134 gchar *Event;
1135
1136 if (gtk_tree_selection_get_selected (selection, &model, &iter))
1137 {
1138 gtk_tree_model_get (model, &iter, EVENT_COLUMN, &Event, -1);
1139
1140 g_print ("Event selected : %s\n", Event);
1141
1142 g_free (Event);
1143 }
1144}
fbbb2697 1145
fbbb2697 1146
675f8f58 1147int Event_Selected_Hook(void *hook_data, void *call_data)
1148{
1149 EventViewerData *Event_Viewer_Data = (EventViewerData*) hook_data;
1150 guint *Event_Number = (guint*) call_data;
1151
1152 g_critical("DEBUG : event selected by main window : %u", *Event_Number);
1153
1154 Event_Viewer_Data->Currently_Selected_Event = *Event_Number;
1155 Event_Viewer_Data->Selected_Event = TRUE ;
1156
1157 Tree_V_set_cursor(Event_Viewer_Data);
fbbb2697 1158
fbbb2697 1159}
fcdf0ec2 1160
fcdf0ec2 1161
675f8f58 1162gboolean updateTimeInterval(void * hook_data, void * call_data)
682c6edb 1163{
675f8f58 1164 EventViewerData *Event_Viewer_Data = (EventViewerData*) hook_data;
1165 Event_Viewer_Data->time_interval = *(TimeInterval*)call_data;
682c6edb 1166
675f8f58 1167 return FALSE;
1168}
1169
1170gboolean updateCurrentTime(void * hook_data, void * call_data)
1171{
1172 EventViewerData *Event_Viewer_Data = (EventViewerData*) hook_data;
1173 Event_Viewer_Data->current_time = *(LttTime*)call_data;
b671bb09 1174 uint64_t nsec = Event_Viewer_Data->current_time.tv_sec * NANSECOND_CONST
1175 + Event_Viewer_Data->current_time.tv_nsec;
675f8f58 1176 GtkTreeIter iter;
b671bb09 1177 uint64_t time;
675f8f58 1178 int count = 0;
1179 GtkTreeModel* model = (GtkTreeModel*)Event_Viewer_Data->Store_M;
1180
1181
1182 if(gtk_tree_model_get_iter_first(model, &iter)){
1183 while(1){
1184 gtk_tree_model_get(model, &iter, TIME_COLUMN, &time, -1);
1185 if(time < nsec){
1186 if(!gtk_tree_model_iter_next(model, &iter)){
1187 return TRUE;
1188 }
1189 count++;
1190 }else{
1191 break;
1192 }
1193 }
1194 // Event_Selected_Hook(Event_Viewer_Data, &count);
1195 }
1196
1197 return FALSE;
1198}
1199
1200void Tree_V_grab_focus(GtkWidget *widget, gpointer data){
1201 EventViewerData *Event_Viewer_Data = (EventViewerData *)data;
1202 mainWindow * mw = Event_Viewer_Data->mw;
1203 SetFocusedPane(mw, gtk_widget_get_parent(Event_Viewer_Data->HBox_V));
1204}
682c6edb 1205
f2f6d498 1206void get_events(EventViewerData* Event_Viewer_Data, LttTime start,
b671bb09 1207 LttTime end,unsigned maxNumEvents, unsigned * realNumEvent)
675f8f58 1208{
b671bb09 1209 int size;
1210 RawTraceData * data;
675f8f58 1211 contextAddHooks(Event_Viewer_Data->mw, NULL, NULL, NULL, NULL, NULL, NULL,
1212 NULL, NULL, NULL,Event_Viewer_Data->before_event_hooks,NULL);
f2f6d498 1213 processTraceset(Event_Viewer_Data->mw, start, end, maxNumEvents);
675f8f58 1214 contextRemoveHooks(Event_Viewer_Data->mw, NULL, NULL, NULL, NULL, NULL, NULL,
1215 NULL, NULL, NULL,Event_Viewer_Data->before_event_hooks,NULL);
b671bb09 1216
1217 size = Event_Viewer_Data->raw_trace_data_queue_tmp->length;
1218 *realNumEvent = size;
1219 if(size > 0){
1220 int pid, tmpPid, i;
1221 GList * list, *tmpList;
1222
1223 //if the queue is full, remove some data, keep the size of the queue constant
1224 while(Event_Viewer_Data->raw_trace_data_queue->length + size > RESERVE_BIG_SIZE){
1225 remove_item_from_queue(Event_Viewer_Data->raw_trace_data_queue,
1226 Event_Viewer_Data->append);
1227 }
1228
1229 //update pid if it is not known
1230 if(Event_Viewer_Data->raw_trace_data_queue->length > 0){
1231 list = Event_Viewer_Data->raw_trace_data_queue->head;
1232 tmpList = Event_Viewer_Data->raw_trace_data_queue_tmp->head;
1233 if(Event_Viewer_Data->append){
1234 data = (RawTraceData*)g_list_nth_data(list, Event_Viewer_Data->raw_trace_data_queue->length-1);
1235 pid = data->pid;
1236 data = (RawTraceData*)g_list_nth_data(tmpList, 0);
1237 tmpPid = data->pid;
1238 }else{
1239 data = (RawTraceData*)g_list_nth_data(list, 0);
1240 pid = data->pid;
1241 data = (RawTraceData*)g_list_nth_data(tmpList, Event_Viewer_Data->raw_trace_data_queue_tmp->length-1);
1242 tmpPid = data->pid;
1243 }
1244
1245 if(pid == -1 && tmpPid != -1){
1246 for(i=0;i<Event_Viewer_Data->raw_trace_data_queue->length;i++){
1247 data = (RawTraceData*)g_list_nth_data(list,i);
1248 if(data->pid == -1) data->pid = tmpPid;
1249 }
1250 }else if(pid != -1 && tmpPid == -1){
1251 for(i=0;i<Event_Viewer_Data->raw_trace_data_queue_tmp->length;i++){
1252 data = (RawTraceData*)g_list_nth_data(tmpList,i);
1253 if(data->pid == -1) data->pid = tmpPid;
1254 }
1255 }
1256 }
1257
1258 //add data from tmp queue into the queue
1259 Event_Viewer_Data->Number_Of_Events = Event_Viewer_Data->raw_trace_data_queue->length
1260 + Event_Viewer_Data->raw_trace_data_queue_tmp->length;
1261 if(Event_Viewer_Data->append){
1262 if(Event_Viewer_Data->raw_trace_data_queue->length > 0)
1263 Event_Viewer_Data->current_event_index = Event_Viewer_Data->raw_trace_data_queue->length - 1;
1264 else Event_Viewer_Data->current_event_index = 0;
1265 while((data = g_queue_pop_head(Event_Viewer_Data->raw_trace_data_queue_tmp)) != NULL){
1266 g_queue_push_tail(Event_Viewer_Data->raw_trace_data_queue, data);
1267 }
1268 }else{
1269 Event_Viewer_Data->current_event_index += Event_Viewer_Data->raw_trace_data_queue_tmp->length;
1270 while((data = g_queue_pop_tail(Event_Viewer_Data->raw_trace_data_queue_tmp)) != NULL){
1271 g_queue_push_head(Event_Viewer_Data->raw_trace_data_queue, data);
1272 }
1273 }
1274 }
682c6edb 1275}
1276
675f8f58 1277static void get_event_detail(LttEvent *e, LttField *f, GString * s)
1278{
1279 LttType *type;
1280 LttField *element;
1281 char *name;
1282 int nb, i;
1283
1284 type = ltt_field_type(f);
1285 switch(ltt_type_class(type)) {
1286 case LTT_INT:
1287 g_string_append_printf(s, " %ld", ltt_event_get_long_int(e,f));
1288 break;
1289
1290 case LTT_UINT:
1291 g_string_append_printf(s, " %lu", ltt_event_get_long_unsigned(e,f));
1292 break;
1293
1294 case LTT_FLOAT:
1295 g_string_append_printf(s, " %g", ltt_event_get_double(e,f));
1296 break;
1297
1298 case LTT_STRING:
1299 g_string_append_printf(s, " \"%s\"", ltt_event_get_string(e,f));
1300 break;
1301
1302 case LTT_ENUM:
1303 g_string_append_printf(s, " %s", ltt_enum_string_get(type,
1304 ltt_event_get_unsigned(e,f)-1));
1305 break;
1306
1307 case LTT_ARRAY:
1308 case LTT_SEQUENCE:
1309 g_string_append_printf(s, " {");
1310 nb = ltt_event_field_element_number(e,f);
1311 element = ltt_field_element(f);
1312 for(i = 0 ; i < nb ; i++) {
1313 ltt_event_field_element_select(e,f,i);
1314 get_event_detail(e, element, s);
1315 }
1316 g_string_append_printf(s, " }");
1317 break;
1318
1319 case LTT_STRUCT:
1320 g_string_append_printf(s, " {");
1321 nb = ltt_type_member_number(type);
1322 for(i = 0 ; i < nb ; i++) {
1323 element = ltt_field_member(f,i);
1324 ltt_type_member_type(type, i, &name);
1325 g_string_append_printf(s, " %s = ", name);
1326 get_event_detail(e, element, s);
1327 }
1328 g_string_append_printf(s, " }");
1329 break;
1330 }
1331
1332}
682c6edb 1333
675f8f58 1334static void get_pid(unsigned * in, unsigned * out, char * s)
1335{
1336 char * str;
1337 str = strstr(s, "out =");
1338 if (str){
1339 str = str + 5;
1340 sscanf(str,"%d", out);
1341 }else{
1342 g_warning("Can not find out pid\n");
1343 }
1344
1345 str = strstr(s,"in =");
1346 if (str){
1347 str = str + 4;
1348 sscanf(str,"%d", in);
1349 }else{
1350 g_warning("Can not find in pid\n");
1351 }
1352}
682c6edb 1353
675f8f58 1354gboolean parse_event(void *hook_data, void *call_data)
1355{
1356 EventViewerData *Event_Viewer_Data = (EventViewerData *)hook_data;
1357 LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
1358 LttvTracefileState *tfs = (LttvTracefileState *)call_data;
1359
1360 RawTraceData * tmpRawTraceData,*prevRawTraceData = NULL, *data=NULL;
1361 LttEvent *e;
1362 LttTime time;
1363 LttField * field;
1364 unsigned in=0, out=0;
1365 int i;
1366 GString * detailEvent = g_string_new("");
b671bb09 1367 GList * list;
1368
675f8f58 1369 e = tfc->e;
1370 field = ltt_event_field(e);
1371 time = ltt_event_time(e);
1372
b671bb09 1373 if(Event_Viewer_Data->raw_trace_data_queue_tmp->length){
1374 list = g_list_last(Event_Viewer_Data->raw_trace_data_queue_tmp->head);
1375 prevRawTraceData = (RawTraceData *)(list->data);
675f8f58 1376 }
1377
1378 tmpRawTraceData = g_new(RawTraceData,1);
1379 tmpRawTraceData->cpu_id = ltt_event_cpu_id(e);
1380 tmpRawTraceData->event_name = g_strdup(ltt_eventtype_name(ltt_event_eventtype(e)));
1381 tmpRawTraceData->time = time;
1382
1383 if(prevRawTraceData) tmpRawTraceData->pid = prevRawTraceData->pid;
1384 else tmpRawTraceData->pid = -1;
1385
1386 tmpRawTraceData->entry_length = field == NULL ? 0 : field->field_size;
1387 if(field) get_event_detail(e, field, detailEvent);
1388 tmpRawTraceData->event_description = g_strdup(detailEvent->str);
1389
1390 if(strcmp(tmpRawTraceData->event_name, "schedchange") == 0){
1391 get_pid(&in, &out, detailEvent->str);
1392 }
1393
b671bb09 1394
675f8f58 1395 if(in != 0 || out != 0){
1396 tmpRawTraceData->pid = in;
1397 if(prevRawTraceData && prevRawTraceData->pid == -1){
b671bb09 1398 list = Event_Viewer_Data->raw_trace_data_queue_tmp->head;
1399 for(i=0;i<Event_Viewer_Data->raw_trace_data_queue_tmp->length;i++){
1400 data = (RawTraceData *)g_list_nth_data(list,i);
675f8f58 1401 data->pid = out;
1402 }
1403 }
1404 }
1405
b671bb09 1406 ltt_event_position(e, &tmpRawTraceData->ep);
1407
1408 if(Event_Viewer_Data->raw_trace_data_queue_tmp->length >= RESERVE_SMALL_SIZE){
1409 if(Event_Viewer_Data->append){
1410 list = g_list_last(Event_Viewer_Data->raw_trace_data_queue_tmp->head);
1411 data = (RawTraceData *)(list->data);
1412 if(data->time.tv_sec == time.tv_sec &&
1413 data->time.tv_nsec == time.tv_nsec){
1414 g_queue_push_tail(Event_Viewer_Data->raw_trace_data_queue_tmp,tmpRawTraceData);
1415 }else{
1416 g_free(tmpRawTraceData);
1417 }
1418 }else{
1419 remove_item_from_queue(Event_Viewer_Data->raw_trace_data_queue_tmp,TRUE);
1420 g_queue_push_tail(Event_Viewer_Data->raw_trace_data_queue_tmp,tmpRawTraceData);
1421 }
1422 }else{
1423 g_queue_push_tail (Event_Viewer_Data->raw_trace_data_queue_tmp,tmpRawTraceData);
1424 }
675f8f58 1425
1426 g_string_free(detailEvent, TRUE);
1427
1428 return FALSE;
1429}
682c6edb 1430
b671bb09 1431void remove_item_from_queue(GQueue * q, gboolean fromHead)
a60b01ef 1432{
b671bb09 1433 RawTraceData *data1, *data2 = NULL;
1434 GList * list;
1435
1436 if(fromHead){
1437 data1 = (RawTraceData *)g_queue_pop_head(q);
1438 list = g_list_first(q->head);
1439 if(list)
1440 data2 = (RawTraceData *)(list->data);
1441 }else{
1442 data1 = (RawTraceData *)g_queue_pop_tail(q);
1443 list = g_list_last(q->head);
1444 if(list)
1445 data2 = (RawTraceData *)(list->data);
1446 }
1447
1448 if(data2){
1449 if(data1->time.tv_sec == data2->time.tv_sec &&
1450 data1->time.tv_nsec == data2->time.tv_nsec){
1451 remove_item_from_queue(q, fromHead);
1452 }
a60b01ef 1453 }
b671bb09 1454
1455 g_free(data1);
1456
1457 return;
1458}
1459
1460void remove_all_items_from_queue(GQueue *q)
1461{
1462 RawTraceData *data;
1463 while((data = (RawTraceData *)g_queue_pop_head(q)) != NULL){
1464 g_free(data);
1465 }
a60b01ef 1466}
682c6edb 1467
1468
fbbb2697 1469
1470/* Imported code from LTT 0.9.6pre2 tracevisualizer */
1471#ifdef DEBUG
1472
fcdf0ec2 1473/******************************************************************
1474 * Function :
1475 * WDI_gtk_clist_set_last_row_data_full()
1476 * Description :
1477 * Appends data to the last row of a GtkClist.
1478 * Parameters :
1479 * Return values :
1480 * NONE.
1481 * History :
1482 * J.H.D., 27/08/99, Initial typing.
1483 * Note :
1484 * Based on gtk_clist_set_row_data_full() version 1.2.3.
1485 * Much faster than using gtk_clist_set_row_data_full().
1486 ******************************************************************/
fbbb2697 1487static void WDI_gtk_clist_set_last_row_data_full(GtkCList* pmClist,
fcdf0ec2 1488 gpointer pmData,
1489 GtkDestroyNotify pmDestroy)
1490{
1491 GtkCListRow *pClistRow;
5c7463ed 1492
fcdf0ec2 1493 g_return_if_fail (pmClist != NULL);
1494 g_return_if_fail (GTK_IS_CLIST (pmClist));
1495 g_return_if_fail (pmClist->row_list_end != NULL);
5c7463ed 1496
fcdf0ec2 1497 pClistRow = pmClist->row_list_end->data;
1498 pClistRow->data = pmData;
1499 pClistRow->destroy = pmDestroy;
5c7463ed 1500}
1501
1502
fcdf0ec2 1503/******************************************************************
1504 * Function :
1505 * SHRTEventSelect()
1506 * Description :
1507 * Parameters :
1508 * Return values :
1509 * History :
1510 * Note :
1511 ******************************************************************/
fbbb2697 1512static void SHRTEventSelect(GtkWidget* pmCList,
fcdf0ec2 1513 gint pmRow,
1514 gint pmColumn,
1515 GdkEventButton* pmEvent,
1516 gpointer pmData)
1517{
1518 systemView* pSysView; /* The system being displayed */
1519
1520 /* Do we have anything meaningfull */
1521 if((pSysView = (systemView*) pmData) == NULL)
1522 return;
1523
1524 /* Store the selected event */
1525 pSysView->Window->LastSelectedEvent = *(event*) gtk_clist_get_row_data(GTK_CLIST(pmCList), pmRow);
1526 pSysView->Window->EventSelected = TRUE;
1527}
1528
1529/******************************************************************
1530 * Function :
1531 * SHRTEventButtonPress()
1532 * Description :
1533 * Parameters :
1534 * Return values :
1535 * History :
1536 * Note :
1537 ******************************************************************/
fbbb2697 1538static void SHRTEventButtonPress(GtkWidget* pmCList,
fcdf0ec2 1539 GdkEventButton* pmEvent,
1540 gpointer pmData)
1541{
1542 systemView* pSysView; /* The system being displayed */
1543 gint row, column; /* The clicked row and column */
1544
1545 /* Do we have anything meaningfull */
1546 if((pSysView = (systemView*) pmData) == NULL)
1547 return;
1548
1549 /* if we have a right-click event */
1550 if(pmEvent->button == 3)
1551 /* If we clicked on an item, get its row and column values */
1552 if(gtk_clist_get_selection_info(GTK_CLIST(pmCList), pmEvent->x, pmEvent->y, &row, &column))
1553 {
1554 /* Highlight the selected row */
1555 gtk_clist_select_row(GTK_CLIST(pmCList), row, column);
1556
1557 /* Store the selected event */
1558 pSysView->Window->LastSelectedEvent = *(event*) gtk_clist_get_row_data(GTK_CLIST(pmCList), row);
1559 pSysView->Window->EventSelected = TRUE;
1560
1561 /* Display the popup menu */
1562 gtk_menu_popup(GTK_MENU(pSysView->Window->RawEventPopup),
1563 NULL, NULL, NULL, NULL,
1564 pmEvent->button, GDK_CURRENT_TIME);
1565 }
1566}
1567
1568
1569/******************************************************************
1570 * Function :
1571 * SHRTVAdjustValueChanged()
1572 * Description :
1573 * Parameters :
1574 * Return values :
1575 * History :
1576 * Note :
1577 ******************************************************************/
fbbb2697 1578static void SHRTVAdjustValueChanged(GtkAdjustment* pmVAdjust,
fcdf0ec2 1579 gpointer pmData)
1580{
1581 event lEvent; /* Event used for searching */
1582 guint32 lPosition; /* The position to scroll to */
1583 systemView* pSysView; /* The system being displayed */
1584
1585 /* Do we have anything meaningfull */
1586 if((pSysView = (systemView*) pmData) == NULL)
1587 return;
1588
1589 /* Is there an event database? */
1590 if(pSysView->EventDB == NULL)
1591 return;
1592
1593 /* Set the pointer to the first event */
1594 if(pSysView->EventDB->TraceStart == NULL)
1595 return;
1596
1597 /* Are we closer to the beginning? */
1598 if((pmVAdjust->value - (pmVAdjust->upper / 2)) < 0)
1599 {
1600 /* Set the navigation pointer to the beginning of the list */
1601 lEvent = pSysView->EventDB->FirstEvent;
1602
1603 /* Calculate distance from beginning */
1604 lPosition = (guint32) pmVAdjust->value;
1605
1606 /* Find the event in the event database */
1607 while(lPosition > 0)
1608 {
1609 lPosition--;
1610 if(DBEventNext(pSysView->EventDB, &lEvent) != TRUE)
1611 break;
1612 }
1613 }
1614 else
1615 {
1616 /* Set the navigation pointer to the end of the list */
1617 lEvent = pSysView->EventDB->LastEvent;
1618
1619 /* Calculate distance from end */
1620 lPosition = (guint32) (pmVAdjust->upper - pmVAdjust->value);
1621
1622 /* Find the event in the event database */
1623 while(lPosition > 0)
1624 {
1625 lPosition--;
1626 if(DBEventPrev(pSysView->EventDB, &lEvent) != TRUE)
1627 break;
1628 }
1629 }
1630
1631 /* Fill the event list according to what was found */
1632 WDFillEventList(pSysView->Window->RTCList,
1633 pSysView->EventDB,
1634 pSysView->System,
1635 &lEvent,
1636 &(pSysView->Window->LastSelectedEvent));
1637}
1638
1639
1640
1641/******************************************************************
1642 * Function :
1643 * WDConnectSignals()
1644 * Description :
1645 * Attaches signal handlers to the window items.
1646 * Parameters :
1647 * pmSysView, System view for which signals have to be connected
1648 * Return values :
1649 * NONE
1650 * History :
1651 * Note :
1652 * This function attaches a pointer to the main window during
1653 * the connect. This means that the handlers will get a pointer
1654 * to the window in the data argument.
1655 ******************************************************************/
fbbb2697 1656static void WDConnectSignals(systemView* pmSysView)
fcdf0ec2 1657{
1658 /* Raw event Popup menu */
1659 gtk_signal_connect(GTK_OBJECT(pmSysView->Window->RawGotoProcess),
1660 "activate",
1661 GTK_SIGNAL_FUNC(SHGotoProcAnalysis),
1662 pmSysView);
1663 gtk_signal_connect(GTK_OBJECT(pmSysView->Window->RawViewEvent),
1664 "activate",
1665 GTK_SIGNAL_FUNC(SHViewEventInEG),
1666 pmSysView);
1667
1668 /* Set event list callbacks */
1669 gtk_signal_connect(GTK_OBJECT(pmSysView->Window->RTCList),
1670 "select_row",
1671 GTK_SIGNAL_FUNC(SHRTEventSelect),
1672 pmSysView);
1673 gtk_signal_connect(GTK_OBJECT(pmSysView->Window->RTCList),
1674 "button-press-event",
1675 GTK_SIGNAL_FUNC(SHRTEventButtonPress),
1676 pmSysView);
1677 gtk_signal_connect(GTK_OBJECT(pmSysView->Window->RTVAdjust),
1678 "value-changed",
1679 GTK_SIGNAL_FUNC(SHRTVAdjustValueChanged),
1680 pmSysView);
1681
1682
1683}
1684
1685
1686/******************************************************************
1687 * Function :
1688 * WDFillEventList()
1689 * Description :
1690 * Fills the window's event list using the trace database.
1691 * Parameters :
1692 * pmList, The list to be filled.
1693 * pmTraceDB, The database of events.
1694 * pmSystem, The system to which this list belongs.
1695 * pmEvent, Event from which we start drawing.
1696 * pmSelectedEvent, Event selected if any.
1697 * Return values :
1698 * NONE.
1699 * History :
1700 * K.Y., 18/06/99, Initial typing.
1701 * Note :
1702 ******************************************************************/
fbbb2697 1703static void WDFillEventList(GtkWidget* pmList,
fcdf0ec2 1704 db* pmTraceDB,
1705 systemInfo* pmSystem,
1706 event* pmEvent,
1707 event* pmSelectedEvent)
1708{
1709 gint i = 0; /* Generic index */
1710 event lEvent; /* Generic event */
1711 gchar lTimeStr[TIME_STR_LEN]; /* Time of event */
1712 static gchar* lString[RTCLIST_NB_COLUMNS]={'\0'}; /* Strings describing event */
1713 process* pProcess; /* Generic process pointer */
1714#if SUPP_RTAI
1715 RTAItask* pTask = NULL; /* Generic task pointer */
1716#endif /* SUPP_RTAI */
1717 eventDescription lEventDesc; /* Description of event */
1718
1719 /* Did we allocate space for strings */
1720 if(lString[0] == NULL)
1721 /* Allocate space for strings */
1722 for (i = 0; i < RTCLIST_NB_COLUMNS - 1; i++)
1723 lString[i] = (char*) g_malloc(MW_DEFAULT_STRLEN);
1724
1725 /* Allocate space for description string */
1726 lString[RTCLIST_NB_COLUMNS - 1] = (char*) g_malloc(MW_LONG_STRLEN);
1727
1728 /* If no event was supplied, start at the beginning */
1729 if(pmEvent == NULL)
1730 lEvent = pmTraceDB->FirstEvent;
1731 else
1732 lEvent = *pmEvent;
1733
1734 /* Freeze and clear clist */
1735 gtk_clist_freeze(GTK_CLIST(pmList));
1736 gtk_clist_clear(GTK_CLIST(pmList));
1737
1738 /* Reset index */
1739 i = 0;
1740
1741 /* Go through the event list */
1742 do
1743 {
1744 /* Get the event description */
1745 DBEventDescription(pmTraceDB, &lEvent, TRUE, &lEventDesc);
1746
1747 /* Get the event's process */
1748 pProcess = DBEventProcess(pmTraceDB, &lEvent, pmSystem, FALSE);
1749
1750#if SUPP_RTAI
1751 /* Does this trace contain RTAI information */
1752 if(pmTraceDB->SystemType == TRACE_SYS_TYPE_RTAI_LINUX)
1753 /* Get the RTAI task to which this event belongs */
1754 pTask = RTAIDBEventTask(pmTraceDB, &lEvent, pmSystem, FALSE);
1755#endif /* SUPP_RTAI */
1756
1757 /* Set the event's entry in the list of raw events displayed */
1758 sRawEventsDisplayed[i] = lEvent;
1759
1760 /* Add text describing the event */
1761 /* The CPU ID */
1762 if(pmTraceDB->LogCPUID == TRUE)
1763 snprintf(lString[0], MW_DEFAULT_STRLEN, "%d", lEventDesc.CPUID);
1764 else
1765 snprintf(lString[0], MW_DEFAULT_STRLEN, "0");
1766
1767 /* The event ID */
1768 snprintf(lString[1], MW_DEFAULT_STRLEN, "%s", pmTraceDB->EventString(pmTraceDB, lEventDesc.ID, &lEvent));
1769
1770 /* The event's time of occurence */
1771 DBFormatTimeInReadableString(lTimeStr,
1772 lEventDesc.Time.tv_sec,
1773 lEventDesc.Time.tv_usec);
1774 snprintf(lString[2], MW_DEFAULT_STRLEN, "%s", lTimeStr);
1775
1776 /* Is this an RT event */
1777 if(lEventDesc.ID <= TRACE_MAX)
1778 {
1779 /* The PID of the process to which the event belongs */
1780 if(pProcess != NULL)
1781 snprintf(lString[3], MW_DEFAULT_STRLEN, "%d", pProcess->PID);
1782 else
1783 snprintf(lString[3], MW_DEFAULT_STRLEN, "N/A");
1784 }
1785#if SUPP_RTAI
1786 else
1787 {
1788 /* The TID of the task to which the event belongs */
1789 if(pTask != NULL)
1790 snprintf(lString[3], MW_DEFAULT_STRLEN, "RT:%d", pTask->TID);
1791 else
1792 snprintf(lString[3], MW_DEFAULT_STRLEN, "RT:N/A");
1793 }
1794#endif /* SUPP_RTAI */
1795
1796 /* The size of the entry */
1797 snprintf(lString[4], MW_DEFAULT_STRLEN, "%d", lEventDesc.Size);
1798
1799 /* The string describing the event */
1800 snprintf(lString[5], MW_LONG_STRLEN, "%s", lEventDesc.String);
1801
1802 /* Insert the entry into the list */
1803 gtk_clist_append(GTK_CLIST(pmList), lString);
1804
1805 /* Set the row's data to point to the current event */
1806 WDI_gtk_clist_set_last_row_data_full(GTK_CLIST(pmList), (gpointer) &(sRawEventsDisplayed[i]), NULL);
1807
1808 /* Was this the last selected event */
1809 if(DBEventsEqual(lEvent, (*pmSelectedEvent)))
1810 gtk_clist_select_row(GTK_CLIST(pmList), i, 0);
1811
1812 /* Go to next row */
1813 i++;
1814 } while((DBEventNext(pmTraceDB, &lEvent) == TRUE) && (i < RTCLIST_NB_ROWS));
1815
1816 /* Resize the list's length */
1817 gtk_widget_queue_resize(pmList);
1818
1819 /* Thaw the clist */
1820 gtk_clist_thaw(GTK_CLIST(pmList));
1821}
1822
fbbb2697 1823#endif //DEBUG
1824
1825static void destroy_cb( GtkWidget *widget,
1826 gpointer data )
1827{
1828 gtk_main_quit ();
1829}
1830
1831
e921c965 1832/*
fbbb2697 1833int main(int argc, char **argv)
1834{
1835 GtkWidget *Window;
1836 GtkWidget *ListViewer;
1837 GtkWidget *VBox_V;
1838 EventViewerData *Event_Viewer_Data;
682c6edb 1839 guint ev_sel = 444 ;
1840
e921c965 1841 // Initialize i18n support
fbbb2697 1842 gtk_set_locale ();
1843
e921c965 1844 // Initialize the widget set
fbbb2697 1845 gtk_init (&argc, &argv);
1846
1847 init();
fcdf0ec2 1848
fbbb2697 1849 Window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1850 gtk_window_set_title (GTK_WINDOW (Window), ("Test Window"));
1851
1852 g_signal_connect (G_OBJECT (Window), "destroy",
1853 G_CALLBACK (destroy_cb), NULL);
1854
1855
1856 VBox_V = gtk_vbox_new(0, 0);
1857 gtk_container_add (GTK_CONTAINER (Window), VBox_V);
1858
e921c965 1859 //ListViewer = hGuiEvents(Window);
682c6edb 1860 //gtk_box_pack_start(GTK_BOX(VBox_V), ListViewer, TRUE, TRUE, 0);
fbbb2697 1861
6601bf27 1862 //ListViewer = hGuiEvents(Window);
1863 //gtk_box_pack_start(GTK_BOX(VBox_V), ListViewer, FALSE, TRUE, 0);
682c6edb 1864
e921c965 1865 Event_Viewer_Data = GuiEvents(g_new(mainWindow,1));
682c6edb 1866 ListViewer = Event_Viewer_Data->HBox_V;
e921c965 1867 gtk_box_pack_start(GTK_BOX(VBox_V), ListViewer, TRUE, TRUE, 0);
1868
fbbb2697 1869 gtk_widget_show (VBox_V);
1870 gtk_widget_show (Window);
1871
e921c965 1872 // Event_Selected_Hook(Event_Viewer_Data, &ev_sel);
682c6edb 1873
fbbb2697 1874 gtk_main ();
1875
1876 g_critical("main loop finished");
1877
1878 //hGuiEvents_Destructor(ListViewer);
1879
1880 //g_critical("GuiEvents Destructor finished");
1881 destroy();
1882
1883 return 0;
1884}
e921c965 1885*/
17abcce3 1886
5c7463ed 1887/*\@}*/
fbbb2697 1888
LTTng 2.x Viewer (LTTV)
This page took 0.111226 seconds and 4 git commands to generate.