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