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