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