projects / lttv.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
quit menu complete
[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);
b671bb09 60void remove_item_from_queue(GQueue * q, gboolean fromHead);
61void remove_all_items_from_queue(GQueue * q);
675f8f58 62
63typedef struct _RawTraceData{
64 unsigned cpu_id;
65 char * event_name;
66 LttTime time;
67 int pid;
68 unsigned entry_length;
69 char * event_description;
b671bb09 70 LttEventPosition ep;
675f8f58 71} RawTraceData;
72
b671bb09 73#define RESERVE_BIG_SIZE 1000
74#define RESERVE_SMALL_SIZE 100
e921c965 75
a60b01ef 76typedef enum _ScrollDirection{
b671bb09 77 SCROLL_STEP_UP,
78 SCROLL_STEP_DOWN,
79 SCROLL_PAGE_UP,
80 SCROLL_PAGE_DOWN,
81 SCROLL_JUMP,
82 SCROLL_NONE
a60b01ef 83} ScrollDirection;
84
fbbb2697 85typedef struct _EventViewerData {
86
e921c965 87 mainWindow * mw;
675f8f58 88 TimeInterval time_interval;
89 LttTime current_time;
675f8f58 90 LttvHooks * before_event_hooks;
91
b671bb09 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
8b9fdc80 102 //scroll window containing Tree View
103 GtkWidget * Scroll_Win;
104
675f8f58 105 /* Model containing list data */
fbbb2697 106 GtkListStore *Store_M;
675f8f58 107
108 GtkWidget *HBox_V;
109 /* Widget to display the data in a columned list */
fbbb2697 110 GtkWidget *Tree_V;
111 GtkAdjustment *VTree_Adjust_C ;
675f8f58 112 GdkWindow *TreeWindow ;
113
114 /* Vertical scrollbar and it's adjustment */
115 GtkWidget *VScroll_VC;
fbbb2697 116 GtkAdjustment *VAdjust_C ;
117
675f8f58 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 ;
682c6edb 128
fbbb2697 129} EventViewerData ;
130
131//! Event Viewer's constructor hook
e921c965 132GtkWidget *hGuiEvents(mainWindow *pmParentWindow);
5c7463ed 133//! Event Viewer's constructor
e921c965 134EventViewerData *GuiEvents(mainWindow *pmParentWindow);
fbbb2697 135//! Event Viewer's destructor
136void GuiEvents_Destructor(EventViewerData *Event_Viewer_Data);
8af8e4c5 137void GuiEvents_free(EventViewerData *Event_Viewer_Data);
fbbb2697 138
682c6edb 139static int Event_Selected_Hook(void *hook_data, void *call_data);
140
141void Tree_V_set_cursor(EventViewerData *Event_Viewer_Data);
142void Tree_V_get_cursor(EventViewerData *Event_Viewer_Data);
143
fbbb2697 144/* Prototype for selection handler callback */
145static void tree_selection_changed_cb (GtkTreeSelection *selection, gpointer data);
146static void v_scroll_cb (GtkAdjustment *adjustment, gpointer data);
147static void Tree_V_size_allocate_cb (GtkWidget *widget, GtkAllocation *alloc, gpointer data);
148static void Tree_V_size_request_cb (GtkWidget *widget, GtkRequisition *requisition, gpointer data);
b26121f4 149static void Tree_V_cursor_changed_cb (GtkWidget *widget, gpointer data);
150static void Tree_V_move_cursor_cb (GtkWidget *widget, GtkMovementStep arg1, gint arg2, gpointer data);
675f8f58 151static void Tree_V_grab_focus(GtkWidget *widget, gpointer data);
682c6edb 152
153
b671bb09 154static void get_test_data(double time, guint List_Height,
f2f6d498 155 EventViewerData *Event_Viewer_Data);
fbbb2697 156
157void add_test_data(EventViewerData *Event_Viewer_Data);
158
f2f6d498 159static void get_events(EventViewerData* Event_Viewer_Data, LttTime start,
b671bb09 160 LttTime end, unsigned maxNumEvents, unsigned * realNumEvent);
675f8f58 161static gboolean parse_event(void *hook_data, void *call_data);
162
ae4e77e0 163static LttvModule *Main_Win_Module;
164
5c7463ed 165/**
166 * plugin's init function
167 *
168 * This function initializes the Event Viewer functionnality through the
169 * gtkTraceSet API.
170 */
ae4e77e0 171G_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
5c7463ed 181
675f8f58 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
fbbb2697 190}
5c7463ed 191
fbbb2697 192void destroy_walk(gpointer data, gpointer user_data)
193{
675f8f58 194 GuiEvents_Destructor((EventViewerData*)data);
5c7463ed 195}
196
197/**
198 * plugin's destroy function
199 *
200 * This function releases the memory reserved by the module and unregisters
201 * everything that has been registered in the gtkTraceSet API.
202 */
203G_MODULE_EXPORT void destroy() {
675f8f58 204 int i;
205
206 EventViewerData *Event_Viewer_Data;
207
208 g_critical("GUI Event Viewer destroy()");
fbbb2697 209
675f8f58 210 g_slist_foreach(sEvent_Viewer_Data_List, destroy_walk, NULL );
c46519c8 211
212 g_slist_free(sEvent_Viewer_Data_List);
213
675f8f58 214 /* Unregister the toolbar insert button */
215 ToolbarItemUnreg(hGuiEvents);
fcdf0ec2 216
675f8f58 217 /* Unregister the menu item insert entry */
218 MenuItemUnreg(hGuiEvents);
5c7463ed 219}
220
fbbb2697 221/* Enumeration of the columns */
222enum
223{
675f8f58 224 CPUID_COLUMN,
225 EVENT_COLUMN,
226 TIME_COLUMN,
227 PID_COLUMN,
228 ENTRY_LEN_COLUMN,
229 EVENT_DESCR_COLUMN,
230 N_COLUMNS
fbbb2697 231};
232
233
5c7463ed 234/**
fbbb2697 235 * Event Viewer's constructor hook
5c7463ed 236 *
237 * This constructor is given as a parameter to the menuitem and toolbar button
fbbb2697 238 * registration. It creates the list.
239 * @param pmParentWindow A pointer to the parent window.
5c7463ed 240 * @return The widget created.
241 */
fbbb2697 242GtkWidget *
e921c965 243hGuiEvents(mainWindow * pmParentWindow)
fbbb2697 244{
675f8f58 245 EventViewerData* Event_Viewer_Data = GuiEvents(pmParentWindow) ;
fbbb2697 246
f9334f6f 247 if(Event_Viewer_Data)
8af8e4c5 248 return Event_Viewer_Data->HBox_V;
f9334f6f 249 else return NULL;
fbbb2697 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 */
259EventViewerData *
e921c965 260GuiEvents(mainWindow *pmParentWindow)
5c7463ed 261{
675f8f58 262 LttTime start, end;
263 GtkTreeViewColumn *column;
264 GtkCellRenderer *renderer;
265 EventViewerData* Event_Viewer_Data = g_new(EventViewerData,1) ;
675f8f58 266 RawTraceData * data;
b671bb09 267 double time_value;
268 unsigned size;
675f8f58 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);
675f8f58 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
b671bb09 277 Event_Viewer_Data->raw_trace_data_queue = g_queue_new();
278 Event_Viewer_Data->raw_trace_data_queue_tmp = g_queue_new();
279
675f8f58 280 RegUpdateTimeInterval(updateTimeInterval,Event_Viewer_Data, Event_Viewer_Data->mw);
281 RegUpdateCurrentTime(updateCurrentTime,Event_Viewer_Data, Event_Viewer_Data->mw);
282
8b9fdc80 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
675f8f58 288 /* TEST DATA, TO BE READ FROM THE TRACE */
675f8f58 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 */
091d11c7 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 */
fbbb2697 301
675f8f58 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));
b26121f4 304
675f8f58 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);
fbbb2697 315
675f8f58 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);
fcdf0ec2 326
675f8f58 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
fcdf0ec2 331
fbbb2697 332 /* Create a column, associating the "text" attribute of the
333 * cell_renderer to the first column of the model */
675f8f58 334 /* Columns alignment : 0.0 : Left 0.5 : Center 1.0 : Right */
fbbb2697 335 renderer = gtk_cell_renderer_text_new ();
336 column = gtk_tree_view_column_new_with_attributes ("CPUID",
675f8f58 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);
fbbb2697 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",
675f8f58 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);
fbbb2697 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",
675f8f58 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);
fbbb2697 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",
675f8f58 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);
fbbb2697 369 gtk_tree_view_append_column (GTK_TREE_VIEW (Event_Viewer_Data->Tree_V), column);
675f8f58 370
fbbb2697 371 renderer = gtk_cell_renderer_text_new ();
372 column = gtk_tree_view_column_new_with_attributes ("Entry Length",
675f8f58 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);
fbbb2697 378 gtk_tree_view_append_column (GTK_TREE_VIEW (Event_Viewer_Data->Tree_V), column);
675f8f58 379
fbbb2697 380 renderer = gtk_cell_renderer_text_new ();
381 column = gtk_tree_view_column_new_with_attributes ("Event's Description",
675f8f58 382 renderer,
383 "text", EVENT_DESCR_COLUMN,
384 NULL);
385 gtk_tree_view_column_set_alignment (column, 0.0);
fbbb2697 386 gtk_tree_view_append_column (GTK_TREE_VIEW (Event_Viewer_Data->Tree_V), column);
387
388
675f8f58 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);
fbbb2697 395
8b9fdc80 396 gtk_container_add (GTK_CONTAINER (Event_Viewer_Data->Scroll_Win), Event_Viewer_Data->Tree_V);
397
fbbb2697 398 Event_Viewer_Data->HBox_V = gtk_hbox_new(0, 0);
8b9fdc80 399 gtk_box_pack_start(GTK_BOX(Event_Viewer_Data->HBox_V), Event_Viewer_Data->Scroll_Win, TRUE, TRUE, 0);
fcdf0ec2 400
401 /* Create vertical scrollbar and pack it */
fbbb2697 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);
675f8f58 404
fcdf0ec2 405 /* Get the vertical scrollbar's adjustment */
fbbb2697 406 Event_Viewer_Data->VAdjust_C = gtk_range_get_adjustment(GTK_RANGE(Event_Viewer_Data->VScroll_VC));
675f8f58 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 */
b671bb09 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;
675f8f58 423 g_critical("value : %u",Event_Viewer_Data->VTree_Adjust_C->upper);
fbbb2697 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
675f8f58 429 /* Add the object's information to the module's array */
e921c965 430 sEvent_Viewer_Data_List = g_slist_append(sEvent_Viewer_Data_List, Event_Viewer_Data);
fbbb2697 431
675f8f58 432 Event_Viewer_Data->First_Event = -1 ;
433 Event_Viewer_Data->Last_Event = 0 ;
434
435 Event_Viewer_Data->Num_Visible_Events = 1;
436
b671bb09 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
675f8f58 447 start.tv_sec = 0;
448 start.tv_nsec = 0;
f2f6d498 449 end.tv_sec = G_MAXULONG;
450 end.tv_nsec = G_MAXULONG;
675f8f58 451
b671bb09 452 get_events(Event_Viewer_Data, start,end, RESERVE_SMALL_SIZE, &size);
f9334f6f 453
b671bb09 454 Event_Viewer_Data->start_event_index = 0;
455 Event_Viewer_Data->end_event_index = Event_Viewer_Data->Num_Visible_Events - 1;
675f8f58 456
457 // Test data
b671bb09 458 get_test_data(Event_Viewer_Data->VAdjust_C->value,
675f8f58 459 Event_Viewer_Data->Num_Visible_Events,
460 Event_Viewer_Data);
461
462 /* Set the Selected Event */
b671bb09 463 // Tree_V_set_cursor(Event_Viewer_Data);
8af8e4c5 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);
675f8f58 471
472 return Event_Viewer_Data;
fbbb2697 473}
fcdf0ec2 474
682c6edb 475void Tree_V_set_cursor(EventViewerData *Event_Viewer_Data)
476{
675f8f58 477 GtkTreePath *path;
478
479 if(Event_Viewer_Data->Selected_Event && Event_Viewer_Data->First_Event != -1)
480 {
b671bb09 481 // gtk_adjustment_set_value(Event_Viewer_Data->VAdjust_C,
482 // Event_Viewer_Data->Currently_Selected_Event);
675f8f58 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 }
682c6edb 492}
493
494void Tree_V_get_cursor(EventViewerData *Event_Viewer_Data)
495{
675f8f58 496 GtkTreePath *path;
497 gint *indices;
682c6edb 498
675f8f58 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);
682c6edb 515
516}
517
518
519
b26121f4 520void Tree_V_move_cursor_cb (GtkWidget *widget, GtkMovementStep arg1, gint arg2, gpointer data)
fbbb2697 521{
675f8f58 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)
b26121f4 545 {
675f8f58 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)
b26121f4 551 {
675f8f58 552 g_critical("need 1 event down") ;
553 Event_Viewer_Data->Currently_Selected_Event += 1;
b671bb09 554 // gtk_adjustment_set_value(Event_Viewer_Data->VAdjust_C, value+1);
675f8f58 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");
b26121f4 559 }
675f8f58 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;
b671bb09 569 // gtk_adjustment_set_value(Event_Viewer_Data->VAdjust_C, value-1);
675f8f58 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 }
b26121f4 577 }
675f8f58 578
579 }
580
581 if(arg1 == GTK_MOVEMENT_PAGES)
582 {
583 /* Move one page */
584 if(arg2 == 1)
b26121f4 585 {
675f8f58 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;
b671bb09 595 // gtk_adjustment_set_value(Event_Viewer_Data->VAdjust_C,
596 // value+(Event_Viewer_Data->Num_Visible_Events-1));
675f8f58 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)
b26121f4 610 {
675f8f58 611 g_critical("need 1 page up") ;
612
613 Event_Viewer_Data->Currently_Selected_Event -= Event_Viewer_Data->Num_Visible_Events-1;
614
b671bb09 615 // gtk_adjustment_set_value(Event_Viewer_Data->VAdjust_C,
616 // value-(Event_Viewer_Data->Num_Visible_Events-1));
675f8f58 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
b26121f4 622 } else {
675f8f58 623 /* Go to first Event */
624 g_critical("need 1 page up") ;
625
626 Event_Viewer_Data->Currently_Selected_Event == 0 ;
b671bb09 627 // gtk_adjustment_set_value(Event_Viewer_Data->VAdjust_C,
628 // 0);
675f8f58 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
b26121f4 634 }
675f8f58 635 }
636
b26121f4 637 }
675f8f58 638
639 }
640
641 if(arg1 == GTK_MOVEMENT_BUFFER_ENDS)
642 {
643 /* Move to the ends of the buffer */
644 if(arg2 == 1)
b26121f4 645 {
675f8f58 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 ;
b671bb09 649 // gtk_adjustment_set_value(Event_Viewer_Data->VAdjust_C,
650 // Event_Viewer_Data->Number_Of_Events -
651 // Event_Viewer_Data->Num_Visible_Events);
675f8f58 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 ;
b671bb09 660 // gtk_adjustment_set_value(Event_Viewer_Data->VAdjust_C, 0);
682c6edb 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);
675f8f58 664 g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
b26121f4 665 }
675f8f58 666
667 }
668
669
670 gtk_tree_path_free(path);
b26121f4 671}
672
673void Tree_V_cursor_changed_cb (GtkWidget *widget, gpointer data)
674{
675f8f58 675 EventViewerData *Event_Viewer_Data = (EventViewerData*) data;
676 LttTime ltt_time;
a60b01ef 677 guint64 time;
675f8f58 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);
b671bb09 690 ltt_time.tv_sec = time / NANSECOND_CONST;
691 ltt_time.tv_nsec = time % NANSECOND_CONST;
675f8f58 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*/
b26121f4 700}
701
702
703void v_scroll_cb (GtkAdjustment *adjustment, gpointer data)
704{
675f8f58 705 EventViewerData *Event_Viewer_Data = (EventViewerData*)data;
706 GtkTreePath *Tree_Path;
707
708 g_critical("DEBUG : scroll signal, value : %f", adjustment->value);
709
b671bb09 710 get_test_data(adjustment->value, Event_Viewer_Data->Num_Visible_Events,
675f8f58 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 }
b671bb09 732
675f8f58 733
fbbb2697 734}
fcdf0ec2 735
6601bf27 736gint get_cell_height(GtkTreeView *TreeView)
737{
675f8f58 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;
6601bf27 747}
748
fbbb2697 749void Tree_V_size_allocate_cb (GtkWidget *widget, GtkAllocation *alloc, gpointer data)
750{
675f8f58 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 -
6601bf27 759 TREE_VIEW_HEADER_HEIGHT (GTK_TREE_VIEW(Event_Viewer_Data->Tree_V)) )
675f8f58 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
b671bb09 767/*
675f8f58 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);
b671bb09 772*/
675f8f58 773
774 if(Event_Viewer_Data->Num_Visible_Events != Last_Num_Visible_Events)
775 {
b671bb09 776 get_test_data(Event_Viewer_Data->VAdjust_C->value,
675f8f58 777 Event_Viewer_Data->Num_Visible_Events,
778 Event_Viewer_Data);
779 }
780
6601bf27 781
fbbb2697 782}
783
784void Tree_V_size_request_cb (GtkWidget *widget, GtkRequisition *requisition, gpointer data)
785{
675f8f58 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));
fbbb2697 789
675f8f58 790 g_critical("size-request");
fbbb2697 791
675f8f58 792 h = Cell_Height + TREE_VIEW_HEADER_HEIGHT
793 (GTK_TREE_VIEW(Event_Viewer_Data->Tree_V));
794 requisition->height = h;
fbbb2697 795
fcdf0ec2 796}
797
b671bb09 798void get_test_data(double time_value, guint List_Height,
675f8f58 799 EventViewerData *Event_Viewer_Data)
b26121f4 800{
675f8f58 801 GtkTreeIter iter;
b671bb09 802 int i;
675f8f58 803 GtkTreeModel *model = GTK_TREE_MODEL(Event_Viewer_Data->Store_M);
804 GtkTreePath *Tree_Path;
675f8f58 805 RawTraceData * raw_data;
b671bb09 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
675f8f58 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 */
b671bb09 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;
a60b01ef 837 }else{
b671bb09 838 backward = Event_Viewer_Data->start_event_index == 0 ? TRUE : FALSE;
a60b01ef 839 }
b671bb09 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);
a60b01ef 901 }
b671bb09 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);
a60b01ef 931 }
b671bb09 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;
a60b01ef 951 }
b671bb09 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 }
50ca4ac7 974 Event_Number = Event_Viewer_Data->raw_trace_data_queue->length - List_Height;
975 }else{
976 Event_Number = 0;
a60b01ef 977 }
b671bb09 978 break;
979 case SCROLL_NONE:
980 Event_Number = Event_Viewer_Data->current_event_index;
981 break;
982 default:
983 break;
984 }
675f8f58 985
b671bb09 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;
675f8f58 998 }
999
675f8f58 1000
b671bb09 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;
675f8f58 1005 gtk_list_store_clear(Event_Viewer_Data->Store_M);
1006 for(i=Event_Number; i<Event_Number+List_Height; i++)
1007 {
a60b01ef 1008 guint64 real_data;
1009
675f8f58 1010 if(i>=Event_Viewer_Data->Number_Of_Events) break;
b671bb09 1011
1012 raw_data = (RawTraceData*)g_list_nth_data(first, i);
675f8f58 1013
b671bb09 1014 // Add a new row to the model
a60b01ef 1015 real_data = raw_data->time.tv_sec;
b671bb09 1016 real_data *= NANSECOND_CONST;
a60b01ef 1017 real_data += raw_data->time.tv_nsec;
675f8f58 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,
a60b01ef 1022 TIME_COLUMN, real_data,
675f8f58 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/*
b671bb09 1028 gtk_list_store_append (Event_Viewer_Data->Store_M, &iter);
675f8f58 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++)
b26121f4 1052 {
675f8f58 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);
b26121f4 1056 }
675f8f58 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);
b26121f4 1071 }
675f8f58 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 //}
b26121f4 1097#endif //DEBUG
b671bb09 1098 Event_Viewer_Data->First_Event = Event_Viewer_Data->start_event_index ;
1099 Event_Viewer_Data->Last_Event = Event_Viewer_Data->end_event_index ;
675f8f58 1100
682c6edb 1101
1102
b26121f4 1103}
1104
fbbb2697 1105
1106void add_test_data(EventViewerData *Event_Viewer_Data)
fcdf0ec2 1107{
675f8f58 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
fbbb2697 1125}
1126
f1d41644 1127void
1128GuiEvents_free(EventViewerData *Event_Viewer_Data)
1129{
7a859036 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);
f1d41644 1137
7a859036 1138 UnregUpdateTimeInterval(updateTimeInterval,Event_Viewer_Data, Event_Viewer_Data->mw);
1139 UnregUpdateCurrentTime(updateCurrentTime,Event_Viewer_Data, Event_Viewer_Data->mw);
f1d41644 1140
7a859036 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 }
f1d41644 1145}
fcdf0ec2 1146
fbbb2697 1147void
1148GuiEvents_Destructor(EventViewerData *Event_Viewer_Data)
1149{
675f8f58 1150 guint index;
1151
1152 /* May already been done by GTK window closing */
7a859036 1153 if(GTK_IS_WIDGET(Event_Viewer_Data->HBox_V)){
8af8e4c5 1154 gtk_widget_destroy(Event_Viewer_Data->HBox_V);
7a859036 1155 Event_Viewer_Data = NULL;
1156 }
675f8f58 1157
1158 /* Destroy the Tree View */
1159 //gtk_widget_destroy(Event_Viewer_Data->Tree_V);
1160
fbbb2697 1161 /* Clear raw event list */
675f8f58 1162 //gtk_list_store_clear(Event_Viewer_Data->Store_M);
1163 //gtk_widget_destroy(GTK_WIDGET(Event_Viewer_Data->Store_M));
1164
8af8e4c5 1165 g_warning("Delete Event data from destroy\n");
f1d41644 1166 GuiEvents_free(Event_Viewer_Data);
fcdf0ec2 1167}
1168
fbbb2697 1169//FIXME : call hGuiEvents_Destructor for corresponding data upon widget destroy
1170
1171static void
1172tree_selection_changed_cb (GtkTreeSelection *selection, gpointer data)
1173{
675f8f58 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}
fbbb2697 1188
fbbb2697 1189
675f8f58 1190int 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);
fbbb2697 1201
fbbb2697 1202}
fcdf0ec2 1203
fcdf0ec2 1204
675f8f58 1205gboolean updateTimeInterval(void * hook_data, void * call_data)
682c6edb 1206{
675f8f58 1207 EventViewerData *Event_Viewer_Data = (EventViewerData*) hook_data;
1208 Event_Viewer_Data->time_interval = *(TimeInterval*)call_data;
682c6edb 1209
675f8f58 1210 return FALSE;
1211}
1212
1213gboolean 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;
b671bb09 1217 uint64_t nsec = Event_Viewer_Data->current_time.tv_sec * NANSECOND_CONST
1218 + Event_Viewer_Data->current_time.tv_nsec;
675f8f58 1219 GtkTreeIter iter;
b671bb09 1220 uint64_t time;
675f8f58 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 }
c46519c8 1239
675f8f58 1240 return FALSE;
1241}
1242
1243void Tree_V_grab_focus(GtkWidget *widget, gpointer data){
1244 EventViewerData *Event_Viewer_Data = (EventViewerData *)data;
1245 mainWindow * mw = Event_Viewer_Data->mw;
8af8e4c5 1246 SetFocusedPane(mw, gtk_widget_get_parent(Event_Viewer_Data->HBox_V));
675f8f58 1247}
682c6edb 1248
f2f6d498 1249void get_events(EventViewerData* Event_Viewer_Data, LttTime start,
b671bb09 1250 LttTime end,unsigned maxNumEvents, unsigned * realNumEvent)
675f8f58 1251{
b671bb09 1252 int size;
1253 RawTraceData * data;
675f8f58 1254 contextAddHooks(Event_Viewer_Data->mw, NULL, NULL, NULL, NULL, NULL, NULL,
1255 NULL, NULL, NULL,Event_Viewer_Data->before_event_hooks,NULL);
f2f6d498 1256 processTraceset(Event_Viewer_Data->mw, start, end, maxNumEvents);
675f8f58 1257 contextRemoveHooks(Event_Viewer_Data->mw, NULL, NULL, NULL, NULL, NULL, NULL,
1258 NULL, NULL, NULL,Event_Viewer_Data->before_event_hooks,NULL);
b671bb09 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 }
682c6edb 1318}
1319
675f8f58 1320static 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}
682c6edb 1376
675f8f58 1377static 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}
682c6edb 1396
675f8f58 1397gboolean 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("");
b671bb09 1410 GList * list;
1411
675f8f58 1412 e = tfc->e;
1413 field = ltt_event_field(e);
1414 time = ltt_event_time(e);
1415
b671bb09 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);
675f8f58 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
b671bb09 1437
675f8f58 1438 if(in != 0 || out != 0){
1439 tmpRawTraceData->pid = in;
1440 if(prevRawTraceData && prevRawTraceData->pid == -1){
b671bb09 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);
675f8f58 1444 data->pid = out;
1445 }
1446 }
1447 }
1448
b671bb09 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 }
675f8f58 1468
1469 g_string_free(detailEvent, TRUE);
1470
1471 return FALSE;
1472}
682c6edb 1473
b671bb09 1474void remove_item_from_queue(GQueue * q, gboolean fromHead)
a60b01ef 1475{
b671bb09 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 }
a60b01ef 1496 }
b671bb09 1497
1498 g_free(data1);
1499
1500 return;
1501}
1502
1503void 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 }
a60b01ef 1509}
682c6edb 1510
c46519c8 1511
1512
682c6edb 1513
fbbb2697 1514
1515/* Imported code from LTT 0.9.6pre2 tracevisualizer */
1516#ifdef DEBUG
1517
fcdf0ec2 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 ******************************************************************/
fbbb2697 1532static void WDI_gtk_clist_set_last_row_data_full(GtkCList* pmClist,
fcdf0ec2 1533 gpointer pmData,
1534 GtkDestroyNotify pmDestroy)
1535{
1536 GtkCListRow *pClistRow;
5c7463ed 1537
fcdf0ec2 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);
5c7463ed 1541
fcdf0ec2 1542 pClistRow = pmClist->row_list_end->data;
1543 pClistRow->data = pmData;
1544 pClistRow->destroy = pmDestroy;
5c7463ed 1545}
1546
1547
fcdf0ec2 1548/******************************************************************
1549 * Function :
1550 * SHRTEventSelect()
1551 * Description :
1552 * Parameters :
1553 * Return values :
1554 * History :
1555 * Note :
1556 ******************************************************************/
fbbb2697 1557static void SHRTEventSelect(GtkWidget* pmCList,
fcdf0ec2 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 ******************************************************************/
fbbb2697 1583static void SHRTEventButtonPress(GtkWidget* pmCList,
fcdf0ec2 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 ******************************************************************/
fbbb2697 1623static void SHRTVAdjustValueChanged(GtkAdjustment* pmVAdjust,
fcdf0ec2 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 ******************************************************************/
fbbb2697 1701static void WDConnectSignals(systemView* pmSysView)
fcdf0ec2 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 ******************************************************************/
fbbb2697 1748static void WDFillEventList(GtkWidget* pmList,
fcdf0ec2 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
fbbb2697 1868#endif //DEBUG
1869
1870static void destroy_cb( GtkWidget *widget,
1871 gpointer data )
1872{
1873 gtk_main_quit ();
1874}
1875
1876
e921c965 1877/*
fbbb2697 1878int main(int argc, char **argv)
1879{
1880 GtkWidget *Window;
1881 GtkWidget *ListViewer;
1882 GtkWidget *VBox_V;
1883 EventViewerData *Event_Viewer_Data;
682c6edb 1884 guint ev_sel = 444 ;
1885
e921c965 1886 // Initialize i18n support
fbbb2697 1887 gtk_set_locale ();
1888
e921c965 1889 // Initialize the widget set
fbbb2697 1890 gtk_init (&argc, &argv);
1891
1892 init();
fcdf0ec2 1893
fbbb2697 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
e921c965 1904 //ListViewer = hGuiEvents(Window);
682c6edb 1905 //gtk_box_pack_start(GTK_BOX(VBox_V), ListViewer, TRUE, TRUE, 0);
fbbb2697 1906
6601bf27 1907 //ListViewer = hGuiEvents(Window);
1908 //gtk_box_pack_start(GTK_BOX(VBox_V), ListViewer, FALSE, TRUE, 0);
682c6edb 1909
e921c965 1910 Event_Viewer_Data = GuiEvents(g_new(mainWindow,1));
682c6edb 1911 ListViewer = Event_Viewer_Data->HBox_V;
e921c965 1912 gtk_box_pack_start(GTK_BOX(VBox_V), ListViewer, TRUE, TRUE, 0);
1913
fbbb2697 1914 gtk_widget_show (VBox_V);
1915 gtk_widget_show (Window);
1916
e921c965 1917 // Event_Selected_Hook(Event_Viewer_Data, &ev_sel);
682c6edb 1918
fbbb2697 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}
e921c965 1930*/
17abcce3 1931
5c7463ed 1932/*\@}*/
fbbb2697 1933
LTTng 2.x Viewer (LTTV)
This page took 0.123451 seconds and 4 git commands to generate.