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