projects / lttv.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
quit menu complete
[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 if(Event_Viewer_Data){
1131 lttv_hooks_remove(Event_Viewer_Data->before_event_hooks,parse_event);
1132 lttv_hooks_destroy(Event_Viewer_Data->before_event_hooks);
1133
1134 remove_all_items_from_queue (Event_Viewer_Data->raw_trace_data_queue);
1135 g_queue_free(Event_Viewer_Data->raw_trace_data_queue);
1136 g_queue_free(Event_Viewer_Data->raw_trace_data_queue_tmp);
1137
1138 UnregUpdateTimeInterval(updateTimeInterval,Event_Viewer_Data, Event_Viewer_Data->mw);
1139 UnregUpdateCurrentTime(updateCurrentTime,Event_Viewer_Data, Event_Viewer_Data->mw);
1140
1141 sEvent_Viewer_Data_List = g_slist_remove(sEvent_Viewer_Data_List, Event_Viewer_Data);
1142 g_warning("Delete Event data\n");
1143 g_free(Event_Viewer_Data);
1144 }
1145 }
1146
1147 void
1148 GuiEvents_Destructor(EventViewerData *Event_Viewer_Data)
1149 {
1150 guint index;
1151
1152 /* May already been done by GTK window closing */
1153 if(GTK_IS_WIDGET(Event_Viewer_Data->HBox_V)){
1154 gtk_widget_destroy(Event_Viewer_Data->HBox_V);
1155 Event_Viewer_Data = NULL;
1156 }
1157
1158 /* Destroy the Tree View */
1159 //gtk_widget_destroy(Event_Viewer_Data->Tree_V);
1160
1161 /* Clear raw event list */
1162 //gtk_list_store_clear(Event_Viewer_Data->Store_M);
1163 //gtk_widget_destroy(GTK_WIDGET(Event_Viewer_Data->Store_M));
1164
1165 g_warning("Delete Event data from destroy\n");
1166 GuiEvents_free(Event_Viewer_Data);
1167 }
1168
1169 //FIXME : call hGuiEvents_Destructor for corresponding data upon widget destroy
1170
1171 static void
1172 tree_selection_changed_cb (GtkTreeSelection *selection, gpointer data)
1173 {
1174 EventViewerData *Event_Viewer_Data = (EventViewerData*)data;
1175 GtkTreeIter iter;
1176 GtkTreeModel *model = GTK_TREE_MODEL(Event_Viewer_Data->Store_M);
1177 gchar *Event;
1178
1179 if (gtk_tree_selection_get_selected (selection, &model, &iter))
1180 {
1181 gtk_tree_model_get (model, &iter, EVENT_COLUMN, &Event, -1);
1182
1183 g_print ("Event selected : %s\n", Event);
1184
1185 g_free (Event);
1186 }
1187 }
1188
1189
1190 int Event_Selected_Hook(void *hook_data, void *call_data)
1191 {
1192 EventViewerData *Event_Viewer_Data = (EventViewerData*) hook_data;
1193 guint *Event_Number = (guint*) call_data;
1194
1195 g_critical("DEBUG : event selected by main window : %u", *Event_Number);
1196
1197 Event_Viewer_Data->Currently_Selected_Event = *Event_Number;
1198 Event_Viewer_Data->Selected_Event = TRUE ;
1199
1200 Tree_V_set_cursor(Event_Viewer_Data);
1201
1202 }
1203
1204
1205 gboolean updateTimeInterval(void * hook_data, void * call_data)
1206 {
1207 EventViewerData *Event_Viewer_Data = (EventViewerData*) hook_data;
1208 Event_Viewer_Data->time_interval = *(TimeInterval*)call_data;
1209
1210 return FALSE;
1211 }
1212
1213 gboolean updateCurrentTime(void * hook_data, void * call_data)
1214 {
1215 EventViewerData *Event_Viewer_Data = (EventViewerData*) hook_data;
1216 Event_Viewer_Data->current_time = *(LttTime*)call_data;
1217 uint64_t nsec = Event_Viewer_Data->current_time.tv_sec * NANSECOND_CONST
1218 + Event_Viewer_Data->current_time.tv_nsec;
1219 GtkTreeIter iter;
1220 uint64_t time;
1221 int count = 0;
1222 GtkTreeModel* model = (GtkTreeModel*)Event_Viewer_Data->Store_M;
1223
1224
1225 if(gtk_tree_model_get_iter_first(model, &iter)){
1226 while(1){
1227 gtk_tree_model_get(model, &iter, TIME_COLUMN, &time, -1);
1228 if(time < nsec){
1229 if(!gtk_tree_model_iter_next(model, &iter)){
1230 return TRUE;
1231 }
1232 count++;
1233 }else{
1234 break;
1235 }
1236 }
1237 // Event_Selected_Hook(Event_Viewer_Data, &count);
1238 }
1239
1240 return FALSE;
1241 }
1242
1243 void Tree_V_grab_focus(GtkWidget *widget, gpointer data){
1244 EventViewerData *Event_Viewer_Data = (EventViewerData *)data;
1245 mainWindow * mw = Event_Viewer_Data->mw;
1246 SetFocusedPane(mw, gtk_widget_get_parent(Event_Viewer_Data->HBox_V));
1247 }
1248
1249 void get_events(EventViewerData* Event_Viewer_Data, LttTime start,
1250 LttTime end,unsigned maxNumEvents, unsigned * realNumEvent)
1251 {
1252 int size;
1253 RawTraceData * data;
1254 contextAddHooks(Event_Viewer_Data->mw, NULL, NULL, NULL, NULL, NULL, NULL,
1255 NULL, NULL, NULL,Event_Viewer_Data->before_event_hooks,NULL);
1256 processTraceset(Event_Viewer_Data->mw, start, end, maxNumEvents);
1257 contextRemoveHooks(Event_Viewer_Data->mw, NULL, NULL, NULL, NULL, NULL, NULL,
1258 NULL, NULL, NULL,Event_Viewer_Data->before_event_hooks,NULL);
1259
1260 size = Event_Viewer_Data->raw_trace_data_queue_tmp->length;
1261 *realNumEvent = size;
1262 if(size > 0){
1263 int pid, tmpPid, i;
1264 GList * list, *tmpList;
1265
1266 //if the queue is full, remove some data, keep the size of the queue constant
1267 while(Event_Viewer_Data->raw_trace_data_queue->length + size > RESERVE_BIG_SIZE){
1268 remove_item_from_queue(Event_Viewer_Data->raw_trace_data_queue,
1269 Event_Viewer_Data->append);
1270 }
1271
1272 //update pid if it is not known
1273 if(Event_Viewer_Data->raw_trace_data_queue->length > 0){
1274 list = Event_Viewer_Data->raw_trace_data_queue->head;
1275 tmpList = Event_Viewer_Data->raw_trace_data_queue_tmp->head;
1276 if(Event_Viewer_Data->append){
1277 data = (RawTraceData*)g_list_nth_data(list, Event_Viewer_Data->raw_trace_data_queue->length-1);
1278 pid = data->pid;
1279 data = (RawTraceData*)g_list_nth_data(tmpList, 0);
1280 tmpPid = data->pid;
1281 }else{
1282 data = (RawTraceData*)g_list_nth_data(list, 0);
1283 pid = data->pid;
1284 data = (RawTraceData*)g_list_nth_data(tmpList, Event_Viewer_Data->raw_trace_data_queue_tmp->length-1);
1285 tmpPid = data->pid;
1286 }
1287
1288 if(pid == -1 && tmpPid != -1){
1289 for(i=0;i<Event_Viewer_Data->raw_trace_data_queue->length;i++){
1290 data = (RawTraceData*)g_list_nth_data(list,i);
1291 if(data->pid == -1) data->pid = tmpPid;
1292 }
1293 }else if(pid != -1 && tmpPid == -1){
1294 for(i=0;i<Event_Viewer_Data->raw_trace_data_queue_tmp->length;i++){
1295 data = (RawTraceData*)g_list_nth_data(tmpList,i);
1296 if(data->pid == -1) data->pid = tmpPid;
1297 }
1298 }
1299 }
1300
1301 //add data from tmp queue into the queue
1302 Event_Viewer_Data->Number_Of_Events = Event_Viewer_Data->raw_trace_data_queue->length
1303 + Event_Viewer_Data->raw_trace_data_queue_tmp->length;
1304 if(Event_Viewer_Data->append){
1305 if(Event_Viewer_Data->raw_trace_data_queue->length > 0)
1306 Event_Viewer_Data->current_event_index = Event_Viewer_Data->raw_trace_data_queue->length - 1;
1307 else Event_Viewer_Data->current_event_index = 0;
1308 while((data = g_queue_pop_head(Event_Viewer_Data->raw_trace_data_queue_tmp)) != NULL){
1309 g_queue_push_tail(Event_Viewer_Data->raw_trace_data_queue, data);
1310 }
1311 }else{
1312 Event_Viewer_Data->current_event_index += Event_Viewer_Data->raw_trace_data_queue_tmp->length;
1313 while((data = g_queue_pop_tail(Event_Viewer_Data->raw_trace_data_queue_tmp)) != NULL){
1314 g_queue_push_head(Event_Viewer_Data->raw_trace_data_queue, data);
1315 }
1316 }
1317 }
1318 }
1319
1320 static void get_event_detail(LttEvent *e, LttField *f, GString * s)
1321 {
1322 LttType *type;
1323 LttField *element;
1324 char *name;
1325 int nb, i;
1326
1327 type = ltt_field_type(f);
1328 switch(ltt_type_class(type)) {
1329 case LTT_INT:
1330 g_string_append_printf(s, " %ld", ltt_event_get_long_int(e,f));
1331 break;
1332
1333 case LTT_UINT:
1334 g_string_append_printf(s, " %lu", ltt_event_get_long_unsigned(e,f));
1335 break;
1336
1337 case LTT_FLOAT:
1338 g_string_append_printf(s, " %g", ltt_event_get_double(e,f));
1339 break;
1340
1341 case LTT_STRING:
1342 g_string_append_printf(s, " \"%s\"", ltt_event_get_string(e,f));
1343 break;
1344
1345 case LTT_ENUM:
1346 g_string_append_printf(s, " %s", ltt_enum_string_get(type,
1347 ltt_event_get_unsigned(e,f)-1));
1348 break;
1349
1350 case LTT_ARRAY:
1351 case LTT_SEQUENCE:
1352 g_string_append_printf(s, " {");
1353 nb = ltt_event_field_element_number(e,f);
1354 element = ltt_field_element(f);
1355 for(i = 0 ; i < nb ; i++) {
1356 ltt_event_field_element_select(e,f,i);
1357 get_event_detail(e, element, s);
1358 }
1359 g_string_append_printf(s, " }");
1360 break;
1361
1362 case LTT_STRUCT:
1363 g_string_append_printf(s, " {");
1364 nb = ltt_type_member_number(type);
1365 for(i = 0 ; i < nb ; i++) {
1366 element = ltt_field_member(f,i);
1367 ltt_type_member_type(type, i, &name);
1368 g_string_append_printf(s, " %s = ", name);
1369 get_event_detail(e, element, s);
1370 }
1371 g_string_append_printf(s, " }");
1372 break;
1373 }
1374
1375 }
1376
1377 static void get_pid(unsigned * in, unsigned * out, char * s)
1378 {
1379 char * str;
1380 str = strstr(s, "out =");
1381 if (str){
1382 str = str + 5;
1383 sscanf(str,"%d", out);
1384 }else{
1385 g_warning("Can not find out pid\n");
1386 }
1387
1388 str = strstr(s,"in =");
1389 if (str){
1390 str = str + 4;
1391 sscanf(str,"%d", in);
1392 }else{
1393 g_warning("Can not find in pid\n");
1394 }
1395 }
1396
1397 gboolean parse_event(void *hook_data, void *call_data)
1398 {
1399 EventViewerData *Event_Viewer_Data = (EventViewerData *)hook_data;
1400 LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
1401 LttvTracefileState *tfs = (LttvTracefileState *)call_data;
1402
1403 RawTraceData * tmpRawTraceData,*prevRawTraceData = NULL, *data=NULL;
1404 LttEvent *e;
1405 LttTime time;
1406 LttField * field;
1407 unsigned in=0, out=0;
1408 int i;
1409 GString * detailEvent = g_string_new("");
1410 GList * list;
1411
1412 e = tfc->e;
1413 field = ltt_event_field(e);
1414 time = ltt_event_time(e);
1415
1416 if(Event_Viewer_Data->raw_trace_data_queue_tmp->length){
1417 list = g_list_last(Event_Viewer_Data->raw_trace_data_queue_tmp->head);
1418 prevRawTraceData = (RawTraceData *)(list->data);
1419 }
1420
1421 tmpRawTraceData = g_new(RawTraceData,1);
1422 tmpRawTraceData->cpu_id = ltt_event_cpu_id(e);
1423 tmpRawTraceData->event_name = g_strdup(ltt_eventtype_name(ltt_event_eventtype(e)));
1424 tmpRawTraceData->time = time;
1425
1426 if(prevRawTraceData) tmpRawTraceData->pid = prevRawTraceData->pid;
1427 else tmpRawTraceData->pid = -1;
1428
1429 tmpRawTraceData->entry_length = field == NULL ? 0 : field->field_size;
1430 if(field) get_event_detail(e, field, detailEvent);
1431 tmpRawTraceData->event_description = g_strdup(detailEvent->str);
1432
1433 if(strcmp(tmpRawTraceData->event_name, "schedchange") == 0){
1434 get_pid(&in, &out, detailEvent->str);
1435 }
1436
1437
1438 if(in != 0 || out != 0){
1439 tmpRawTraceData->pid = in;
1440 if(prevRawTraceData && prevRawTraceData->pid == -1){
1441 list = Event_Viewer_Data->raw_trace_data_queue_tmp->head;
1442 for(i=0;i<Event_Viewer_Data->raw_trace_data_queue_tmp->length;i++){
1443 data = (RawTraceData *)g_list_nth_data(list,i);
1444 data->pid = out;
1445 }
1446 }
1447 }
1448
1449 ltt_event_position(e, &tmpRawTraceData->ep);
1450
1451 if(Event_Viewer_Data->raw_trace_data_queue_tmp->length >= RESERVE_SMALL_SIZE){
1452 if(Event_Viewer_Data->append){
1453 list = g_list_last(Event_Viewer_Data->raw_trace_data_queue_tmp->head);
1454 data = (RawTraceData *)(list->data);
1455 if(data->time.tv_sec == time.tv_sec &&
1456 data->time.tv_nsec == time.tv_nsec){
1457 g_queue_push_tail(Event_Viewer_Data->raw_trace_data_queue_tmp,tmpRawTraceData);
1458 }else{
1459 g_free(tmpRawTraceData);
1460 }
1461 }else{
1462 remove_item_from_queue(Event_Viewer_Data->raw_trace_data_queue_tmp,TRUE);
1463 g_queue_push_tail(Event_Viewer_Data->raw_trace_data_queue_tmp,tmpRawTraceData);
1464 }
1465 }else{
1466 g_queue_push_tail (Event_Viewer_Data->raw_trace_data_queue_tmp,tmpRawTraceData);
1467 }
1468
1469 g_string_free(detailEvent, TRUE);
1470
1471 return FALSE;
1472 }
1473
1474 void remove_item_from_queue(GQueue * q, gboolean fromHead)
1475 {
1476 RawTraceData *data1, *data2 = NULL;
1477 GList * list;
1478
1479 if(fromHead){
1480 data1 = (RawTraceData *)g_queue_pop_head(q);
1481 list = g_list_first(q->head);
1482 if(list)
1483 data2 = (RawTraceData *)(list->data);
1484 }else{
1485 data1 = (RawTraceData *)g_queue_pop_tail(q);
1486 list = g_list_last(q->head);
1487 if(list)
1488 data2 = (RawTraceData *)(list->data);
1489 }
1490
1491 if(data2){
1492 if(data1->time.tv_sec == data2->time.tv_sec &&
1493 data1->time.tv_nsec == data2->time.tv_nsec){
1494 remove_item_from_queue(q, fromHead);
1495 }
1496 }
1497
1498 g_free(data1);
1499
1500 return;
1501 }
1502
1503 void remove_all_items_from_queue(GQueue *q)
1504 {
1505 RawTraceData *data;
1506 while((data = (RawTraceData *)g_queue_pop_head(q)) != NULL){
1507 g_free(data);
1508 }
1509 }
1510
1511
1512
1513
1514
1515 /* Imported code from LTT 0.9.6pre2 tracevisualizer */
1516 #ifdef DEBUG
1517
1518 /******************************************************************
1519 * Function :
1520 * WDI_gtk_clist_set_last_row_data_full()
1521 * Description :
1522 * Appends data to the last row of a GtkClist.
1523 * Parameters :
1524 * Return values :
1525 * NONE.
1526 * History :
1527 * J.H.D., 27/08/99, Initial typing.
1528 * Note :
1529 * Based on gtk_clist_set_row_data_full() version 1.2.3.
1530 * Much faster than using gtk_clist_set_row_data_full().
1531 ******************************************************************/
1532 static void WDI_gtk_clist_set_last_row_data_full(GtkCList* pmClist,
1533 gpointer pmData,
1534 GtkDestroyNotify pmDestroy)
1535 {
1536 GtkCListRow *pClistRow;
1537
1538 g_return_if_fail (pmClist != NULL);
1539 g_return_if_fail (GTK_IS_CLIST (pmClist));
1540 g_return_if_fail (pmClist->row_list_end != NULL);
1541
1542 pClistRow = pmClist->row_list_end->data;
1543 pClistRow->data = pmData;
1544 pClistRow->destroy = pmDestroy;
1545 }
1546
1547
1548 /******************************************************************
1549 * Function :
1550 * SHRTEventSelect()
1551 * Description :
1552 * Parameters :
1553 * Return values :
1554 * History :
1555 * Note :
1556 ******************************************************************/
1557 static void SHRTEventSelect(GtkWidget* pmCList,
1558 gint pmRow,
1559 gint pmColumn,
1560 GdkEventButton* pmEvent,
1561 gpointer pmData)
1562 {
1563 systemView* pSysView; /* The system being displayed */
1564
1565 /* Do we have anything meaningfull */
1566 if((pSysView = (systemView*) pmData) == NULL)
1567 return;
1568
1569 /* Store the selected event */
1570 pSysView->Window->LastSelectedEvent = *(event*) gtk_clist_get_row_data(GTK_CLIST(pmCList), pmRow);
1571 pSysView->Window->EventSelected = TRUE;
1572 }
1573
1574 /******************************************************************
1575 * Function :
1576 * SHRTEventButtonPress()
1577 * Description :
1578 * Parameters :
1579 * Return values :
1580 * History :
1581 * Note :
1582 ******************************************************************/
1583 static void SHRTEventButtonPress(GtkWidget* pmCList,
1584 GdkEventButton* pmEvent,
1585 gpointer pmData)
1586 {
1587 systemView* pSysView; /* The system being displayed */
1588 gint row, column; /* The clicked row and column */
1589
1590 /* Do we have anything meaningfull */
1591 if((pSysView = (systemView*) pmData) == NULL)
1592 return;
1593
1594 /* if we have a right-click event */
1595 if(pmEvent->button == 3)
1596 /* If we clicked on an item, get its row and column values */
1597 if(gtk_clist_get_selection_info(GTK_CLIST(pmCList), pmEvent->x, pmEvent->y, &row, &column))
1598 {
1599 /* Highlight the selected row */
1600 gtk_clist_select_row(GTK_CLIST(pmCList), row, column);
1601
1602 /* Store the selected event */
1603 pSysView->Window->LastSelectedEvent = *(event*) gtk_clist_get_row_data(GTK_CLIST(pmCList), row);
1604 pSysView->Window->EventSelected = TRUE;
1605
1606 /* Display the popup menu */
1607 gtk_menu_popup(GTK_MENU(pSysView->Window->RawEventPopup),
1608 NULL, NULL, NULL, NULL,
1609 pmEvent->button, GDK_CURRENT_TIME);
1610 }
1611 }
1612
1613
1614 /******************************************************************
1615 * Function :
1616 * SHRTVAdjustValueChanged()
1617 * Description :
1618 * Parameters :
1619 * Return values :
1620 * History :
1621 * Note :
1622 ******************************************************************/
1623 static void SHRTVAdjustValueChanged(GtkAdjustment* pmVAdjust,
1624 gpointer pmData)
1625 {
1626 event lEvent; /* Event used for searching */
1627 guint32 lPosition; /* The position to scroll to */
1628 systemView* pSysView; /* The system being displayed */
1629
1630 /* Do we have anything meaningfull */
1631 if((pSysView = (systemView*) pmData) == NULL)
1632 return;
1633
1634 /* Is there an event database? */
1635 if(pSysView->EventDB == NULL)
1636 return;
1637
1638 /* Set the pointer to the first event */
1639 if(pSysView->EventDB->TraceStart == NULL)
1640 return;
1641
1642 /* Are we closer to the beginning? */
1643 if((pmVAdjust->value - (pmVAdjust->upper / 2)) < 0)
1644 {
1645 /* Set the navigation pointer to the beginning of the list */
1646 lEvent = pSysView->EventDB->FirstEvent;
1647
1648 /* Calculate distance from beginning */
1649 lPosition = (guint32) pmVAdjust->value;
1650
1651 /* Find the event in the event database */
1652 while(lPosition > 0)
1653 {
1654 lPosition--;
1655 if(DBEventNext(pSysView->EventDB, &lEvent) != TRUE)
1656 break;
1657 }
1658 }
1659 else
1660 {
1661 /* Set the navigation pointer to the end of the list */
1662 lEvent = pSysView->EventDB->LastEvent;
1663
1664 /* Calculate distance from end */
1665 lPosition = (guint32) (pmVAdjust->upper - pmVAdjust->value);
1666
1667 /* Find the event in the event database */
1668 while(lPosition > 0)
1669 {
1670 lPosition--;
1671 if(DBEventPrev(pSysView->EventDB, &lEvent) != TRUE)
1672 break;
1673 }
1674 }
1675
1676 /* Fill the event list according to what was found */
1677 WDFillEventList(pSysView->Window->RTCList,
1678 pSysView->EventDB,
1679 pSysView->System,
1680 &lEvent,
1681 &(pSysView->Window->LastSelectedEvent));
1682 }
1683
1684
1685
1686 /******************************************************************
1687 * Function :
1688 * WDConnectSignals()
1689 * Description :
1690 * Attaches signal handlers to the window items.
1691 * Parameters :
1692 * pmSysView, System view for which signals have to be connected
1693 * Return values :
1694 * NONE
1695 * History :
1696 * Note :
1697 * This function attaches a pointer to the main window during
1698 * the connect. This means that the handlers will get a pointer
1699 * to the window in the data argument.
1700 ******************************************************************/
1701 static void WDConnectSignals(systemView* pmSysView)
1702 {
1703 /* Raw event Popup menu */
1704 gtk_signal_connect(GTK_OBJECT(pmSysView->Window->RawGotoProcess),
1705 "activate",
1706 GTK_SIGNAL_FUNC(SHGotoProcAnalysis),
1707 pmSysView);
1708 gtk_signal_connect(GTK_OBJECT(pmSysView->Window->RawViewEvent),
1709 "activate",
1710 GTK_SIGNAL_FUNC(SHViewEventInEG),
1711 pmSysView);
1712
1713 /* Set event list callbacks */
1714 gtk_signal_connect(GTK_OBJECT(pmSysView->Window->RTCList),
1715 "select_row",
1716 GTK_SIGNAL_FUNC(SHRTEventSelect),
1717 pmSysView);
1718 gtk_signal_connect(GTK_OBJECT(pmSysView->Window->RTCList),
1719 "button-press-event",
1720 GTK_SIGNAL_FUNC(SHRTEventButtonPress),
1721 pmSysView);
1722 gtk_signal_connect(GTK_OBJECT(pmSysView->Window->RTVAdjust),
1723 "value-changed",
1724 GTK_SIGNAL_FUNC(SHRTVAdjustValueChanged),
1725 pmSysView);
1726
1727
1728 }
1729
1730
1731 /******************************************************************
1732 * Function :
1733 * WDFillEventList()
1734 * Description :
1735 * Fills the window's event list using the trace database.
1736 * Parameters :
1737 * pmList, The list to be filled.
1738 * pmTraceDB, The database of events.
1739 * pmSystem, The system to which this list belongs.
1740 * pmEvent, Event from which we start drawing.
1741 * pmSelectedEvent, Event selected if any.
1742 * Return values :
1743 * NONE.
1744 * History :
1745 * K.Y., 18/06/99, Initial typing.
1746 * Note :
1747 ******************************************************************/
1748 static void WDFillEventList(GtkWidget* pmList,
1749 db* pmTraceDB,
1750 systemInfo* pmSystem,
1751 event* pmEvent,
1752 event* pmSelectedEvent)
1753 {
1754 gint i = 0; /* Generic index */
1755 event lEvent; /* Generic event */
1756 gchar lTimeStr[TIME_STR_LEN]; /* Time of event */
1757 static gchar* lString[RTCLIST_NB_COLUMNS]={'\0'}; /* Strings describing event */
1758 process* pProcess; /* Generic process pointer */
1759 #if SUPP_RTAI
1760 RTAItask* pTask = NULL; /* Generic task pointer */
1761 #endif /* SUPP_RTAI */
1762 eventDescription lEventDesc; /* Description of event */
1763
1764 /* Did we allocate space for strings */
1765 if(lString[0] == NULL)
1766 /* Allocate space for strings */
1767 for (i = 0; i < RTCLIST_NB_COLUMNS - 1; i++)
1768 lString[i] = (char*) g_malloc(MW_DEFAULT_STRLEN);
1769
1770 /* Allocate space for description string */
1771 lString[RTCLIST_NB_COLUMNS - 1] = (char*) g_malloc(MW_LONG_STRLEN);
1772
1773 /* If no event was supplied, start at the beginning */
1774 if(pmEvent == NULL)
1775 lEvent = pmTraceDB->FirstEvent;
1776 else
1777 lEvent = *pmEvent;
1778
1779 /* Freeze and clear clist */
1780 gtk_clist_freeze(GTK_CLIST(pmList));
1781 gtk_clist_clear(GTK_CLIST(pmList));
1782
1783 /* Reset index */
1784 i = 0;
1785
1786 /* Go through the event list */
1787 do
1788 {
1789 /* Get the event description */
1790 DBEventDescription(pmTraceDB, &lEvent, TRUE, &lEventDesc);
1791
1792 /* Get the event's process */
1793 pProcess = DBEventProcess(pmTraceDB, &lEvent, pmSystem, FALSE);
1794
1795 #if SUPP_RTAI
1796 /* Does this trace contain RTAI information */
1797 if(pmTraceDB->SystemType == TRACE_SYS_TYPE_RTAI_LINUX)
1798 /* Get the RTAI task to which this event belongs */
1799 pTask = RTAIDBEventTask(pmTraceDB, &lEvent, pmSystem, FALSE);
1800 #endif /* SUPP_RTAI */
1801
1802 /* Set the event's entry in the list of raw events displayed */
1803 sRawEventsDisplayed[i] = lEvent;
1804
1805 /* Add text describing the event */
1806 /* The CPU ID */
1807 if(pmTraceDB->LogCPUID == TRUE)
1808 snprintf(lString[0], MW_DEFAULT_STRLEN, "%d", lEventDesc.CPUID);
1809 else
1810 snprintf(lString[0], MW_DEFAULT_STRLEN, "0");
1811
1812 /* The event ID */
1813 snprintf(lString[1], MW_DEFAULT_STRLEN, "%s", pmTraceDB->EventString(pmTraceDB, lEventDesc.ID, &lEvent));
1814
1815 /* The event's time of occurence */
1816 DBFormatTimeInReadableString(lTimeStr,
1817 lEventDesc.Time.tv_sec,
1818 lEventDesc.Time.tv_usec);
1819 snprintf(lString[2], MW_DEFAULT_STRLEN, "%s", lTimeStr);
1820
1821 /* Is this an RT event */
1822 if(lEventDesc.ID <= TRACE_MAX)
1823 {
1824 /* The PID of the process to which the event belongs */
1825 if(pProcess != NULL)
1826 snprintf(lString[3], MW_DEFAULT_STRLEN, "%d", pProcess->PID);
1827 else
1828 snprintf(lString[3], MW_DEFAULT_STRLEN, "N/A");
1829 }
1830 #if SUPP_RTAI
1831 else
1832 {
1833 /* The TID of the task to which the event belongs */
1834 if(pTask != NULL)
1835 snprintf(lString[3], MW_DEFAULT_STRLEN, "RT:%d", pTask->TID);
1836 else
1837 snprintf(lString[3], MW_DEFAULT_STRLEN, "RT:N/A");
1838 }
1839 #endif /* SUPP_RTAI */
1840
1841 /* The size of the entry */
1842 snprintf(lString[4], MW_DEFAULT_STRLEN, "%d", lEventDesc.Size);
1843
1844 /* The string describing the event */
1845 snprintf(lString[5], MW_LONG_STRLEN, "%s", lEventDesc.String);
1846
1847 /* Insert the entry into the list */
1848 gtk_clist_append(GTK_CLIST(pmList), lString);
1849
1850 /* Set the row's data to point to the current event */
1851 WDI_gtk_clist_set_last_row_data_full(GTK_CLIST(pmList), (gpointer) &(sRawEventsDisplayed[i]), NULL);
1852
1853 /* Was this the last selected event */
1854 if(DBEventsEqual(lEvent, (*pmSelectedEvent)))
1855 gtk_clist_select_row(GTK_CLIST(pmList), i, 0);
1856
1857 /* Go to next row */
1858 i++;
1859 } while((DBEventNext(pmTraceDB, &lEvent) == TRUE) && (i < RTCLIST_NB_ROWS));
1860
1861 /* Resize the list's length */
1862 gtk_widget_queue_resize(pmList);
1863
1864 /* Thaw the clist */
1865 gtk_clist_thaw(GTK_CLIST(pmList));
1866 }
1867
1868 #endif //DEBUG
1869
1870 static void destroy_cb( GtkWidget *widget,
1871 gpointer data )
1872 {
1873 gtk_main_quit ();
1874 }
1875
1876
1877 /*
1878 int main(int argc, char **argv)
1879 {
1880 GtkWidget *Window;
1881 GtkWidget *ListViewer;
1882 GtkWidget *VBox_V;
1883 EventViewerData *Event_Viewer_Data;
1884 guint ev_sel = 444 ;
1885
1886 // Initialize i18n support
1887 gtk_set_locale ();
1888
1889 // Initialize the widget set
1890 gtk_init (&argc, &argv);
1891
1892 init();
1893
1894 Window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1895 gtk_window_set_title (GTK_WINDOW (Window), ("Test Window"));
1896
1897 g_signal_connect (G_OBJECT (Window), "destroy",
1898 G_CALLBACK (destroy_cb), NULL);
1899
1900
1901 VBox_V = gtk_vbox_new(0, 0);
1902 gtk_container_add (GTK_CONTAINER (Window), VBox_V);
1903
1904 //ListViewer = hGuiEvents(Window);
1905 //gtk_box_pack_start(GTK_BOX(VBox_V), ListViewer, TRUE, TRUE, 0);
1906
1907 //ListViewer = hGuiEvents(Window);
1908 //gtk_box_pack_start(GTK_BOX(VBox_V), ListViewer, FALSE, TRUE, 0);
1909
1910 Event_Viewer_Data = GuiEvents(g_new(mainWindow,1));
1911 ListViewer = Event_Viewer_Data->HBox_V;
1912 gtk_box_pack_start(GTK_BOX(VBox_V), ListViewer, TRUE, TRUE, 0);
1913
1914 gtk_widget_show (VBox_V);
1915 gtk_widget_show (Window);
1916
1917 // Event_Selected_Hook(Event_Viewer_Data, &ev_sel);
1918
1919 gtk_main ();
1920
1921 g_critical("main loop finished");
1922
1923 //hGuiEvents_Destructor(ListViewer);
1924
1925 //g_critical("GuiEvents Destructor finished");
1926 destroy();
1927
1928 return 0;
1929 }
1930 */
1931
1932 /*\@}*/
1933
LTTng 2.x Viewer (LTTV)
This page took 0.072438 seconds and 5 git commands to generate.