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