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