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