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