projects / lttv.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
lttv_process_trace function takes another parameters: maxNumEvents
[lttv.git] / ltt / branches / poly / lttv / modules / guiEvents.c
1 //*! \defgroup GuiEvents libGuiEvents: The GUI Events display plugin */
2 /*\@{*/
3
4 /*! \file GuiEvents.c
5 * \brief Graphical plugin for showing events.
6 *
7 * This plugin lists all the events contained in the current time interval
8 * in a list.
9 *
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 *
17 * Coding standard :
18 * pm : parameter
19 * l : local
20 * g : global
21 * s : static
22 * h : hook
23 *
24 * Author : Karim Yaghmour
25 * Integrated to LTTng by Mathieu Desnoyers, June 2003
26 */
27
28 #include <math.h>
29
30 #include <glib.h>
31 #include <gmodule.h>
32 #include <gtk/gtk.h>
33 #include <gdk/gdk.h>
34
35 #include <lttv/module.h>
36 #include <lttv/hook.h>
37 #include <lttv/gtkTraceSet.h>
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
46 //#include "mw_api.h"
47 #include "gtktreeprivate.h"
48
49 #include "icons/hGuiEventsInsert.xpm"
50
51
52 static LttvHooks *before_event;
53
54 /** Array containing instanced objects. Used when module is unloaded */
55 static GSList *sEvent_Viewer_Data_List = NULL ;
56
57 /** hook functions for update time interval, current time ... */
58 gboolean updateTimeInterval(void * hook_data, void * call_data);
59 gboolean updateCurrentTime(void * hook_data, void * call_data);
60 void free_ptr_array(GPtrArray * raw_tarce_data);
61
62 typedef 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
71 typedef struct _TimePeriod{
72 LttTime start;
73 LttTime end;
74 unsigned start_event_number;
75 unsigned end_event_number;
76 } TimePeriod;
77
78 #define RESERVE_SIZE 1000
79
80 typedef 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
88 typedef struct _EventViewerData {
89
90 mainWindow * mw;
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
102 //scroll window containing Tree View
103 GtkWidget * Scroll_Win;
104
105 /* Model containing list data */
106 GtkListStore *Store_M;
107
108 GtkWidget *HBox_V;
109 /* Widget to display the data in a columned list */
110 GtkWidget *Tree_V;
111 GtkAdjustment *VTree_Adjust_C ;
112 GdkWindow *TreeWindow ;
113
114 /* Vertical scrollbar and it's adjustment */
115 GtkWidget *VScroll_VC;
116 GtkAdjustment *VAdjust_C ;
117
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 ;
128
129 } EventViewerData ;
130
131 //! Event Viewer's constructor hook
132 GtkWidget *hGuiEvents(mainWindow *pmParentWindow);
133 //! Event Viewer's constructor
134 EventViewerData *GuiEvents(mainWindow *pmParentWindow);
135 //! Event Viewer's destructor
136 void GuiEvents_Destructor(EventViewerData *Event_Viewer_Data);
137
138 static int Event_Selected_Hook(void *hook_data, void *call_data);
139
140 void Tree_V_set_cursor(EventViewerData *Event_Viewer_Data);
141 void Tree_V_get_cursor(EventViewerData *Event_Viewer_Data);
142
143 /* Prototype for selection handler callback */
144 static void tree_selection_changed_cb (GtkTreeSelection *selection, gpointer data);
145 static void v_scroll_cb (GtkAdjustment *adjustment, gpointer data);
146 static void Tree_V_size_allocate_cb (GtkWidget *widget, GtkAllocation *alloc, gpointer data);
147 static void Tree_V_size_request_cb (GtkWidget *widget, GtkRequisition *requisition, gpointer data);
148 static void Tree_V_cursor_changed_cb (GtkWidget *widget, gpointer data);
149 static void Tree_V_move_cursor_cb (GtkWidget *widget, GtkMovementStep arg1, gint arg2, gpointer data);
150 static void Tree_V_grab_focus(GtkWidget *widget, gpointer data);
151
152
153 static void get_test_data(guint Event_Number, guint List_Height,
154 EventViewerData *Event_Viewer_Data);
155
156 void add_test_data(EventViewerData *Event_Viewer_Data);
157
158 static void get_events(EventViewerData* Event_Viewer_Data, LttTime start,
159 LttTime end, unsigned maxNumEvents);
160 static gboolean parse_event(void *hook_data, void *call_data);
161
162 /**
163 * plugin's init function
164 *
165 * This function initializes the Event Viewer functionnality through the
166 * gtkTraceSet API.
167 */
168 G_MODULE_EXPORT void init() {
169
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
178 }
179
180 void destroy_walk(gpointer data, gpointer user_data)
181 {
182 GuiEvents_Destructor((EventViewerData*)data);
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 */
191 G_MODULE_EXPORT void destroy() {
192 int i;
193
194 EventViewerData *Event_Viewer_Data;
195
196 g_critical("GUI Event Viewer destroy()");
197
198 g_slist_foreach(sEvent_Viewer_Data_List, destroy_walk, NULL );
199
200 /* Unregister the toolbar insert button */
201 ToolbarItemUnreg(hGuiEvents);
202
203 /* Unregister the menu item insert entry */
204 MenuItemUnreg(hGuiEvents);
205 }
206
207 /* Enumeration of the columns */
208 enum
209 {
210 CPUID_COLUMN,
211 EVENT_COLUMN,
212 TIME_COLUMN,
213 PID_COLUMN,
214 ENTRY_LEN_COLUMN,
215 EVENT_DESCR_COLUMN,
216 N_COLUMNS
217 };
218
219
220 /**
221 * Event Viewer's constructor hook
222 *
223 * This constructor is given as a parameter to the menuitem and toolbar button
224 * registration. It creates the list.
225 * @param pmParentWindow A pointer to the parent window.
226 * @return The widget created.
227 */
228 GtkWidget *
229 hGuiEvents(mainWindow * pmParentWindow)
230 {
231 EventViewerData* Event_Viewer_Data = GuiEvents(pmParentWindow) ;
232
233 return Event_Viewer_Data->HBox_V ;
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 */
243 EventViewerData *
244 GuiEvents(mainWindow *pmParentWindow)
245 {
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
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
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 */
277 Event_Viewer_Data->Store_M = gtk_list_store_new (N_COLUMNS, /* Total number of columns */
278 G_TYPE_INT, /* CPUID */
279 G_TYPE_STRING, /* Event */
280 G_TYPE_UINT64, /* Time */
281 G_TYPE_INT, /* PID */
282 G_TYPE_INT, /* Entry length */
283 G_TYPE_STRING); /* Event's description */
284
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));
287
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);
298
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);
309
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
314
315 /* Create a column, associating the "text" attribute of the
316 * cell_renderer to the first column of the model */
317 /* Columns alignment : 0.0 : Left 0.5 : Center 1.0 : Right */
318 renderer = gtk_cell_renderer_text_new ();
319 column = gtk_tree_view_column_new_with_attributes ("CPUID",
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);
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",
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);
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",
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);
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",
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);
352 gtk_tree_view_append_column (GTK_TREE_VIEW (Event_Viewer_Data->Tree_V), column);
353
354 renderer = gtk_cell_renderer_text_new ();
355 column = gtk_tree_view_column_new_with_attributes ("Entry Length",
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);
361 gtk_tree_view_append_column (GTK_TREE_VIEW (Event_Viewer_Data->Tree_V), column);
362
363 renderer = gtk_cell_renderer_text_new ();
364 column = gtk_tree_view_column_new_with_attributes ("Event's Description",
365 renderer,
366 "text", EVENT_DESCR_COLUMN,
367 NULL);
368 gtk_tree_view_column_set_alignment (column, 0.0);
369 gtk_tree_view_append_column (GTK_TREE_VIEW (Event_Viewer_Data->Tree_V), column);
370
371
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);
378
379 gtk_container_add (GTK_CONTAINER (Event_Viewer_Data->Scroll_Win), Event_Viewer_Data->Tree_V);
380
381 Event_Viewer_Data->HBox_V = gtk_hbox_new(0, 0);
382 gtk_box_pack_start(GTK_BOX(Event_Viewer_Data->HBox_V), Event_Viewer_Data->Scroll_Win, TRUE, TRUE, 0);
383
384 /* Create vertical scrollbar and pack it */
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);
387
388 /* Get the vertical scrollbar's adjustment */
389 Event_Viewer_Data->VAdjust_C = gtk_range_get_adjustment(GTK_RANGE(Event_Viewer_Data->VScroll_VC));
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);
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
411 /* Add the object's information to the module's array */
412 sEvent_Viewer_Data_List = g_slist_append(sEvent_Viewer_Data_List, Event_Viewer_Data);
413
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;
421 end.tv_sec = G_MAXULONG;
422 end.tv_nsec = G_MAXULONG;
423
424 Event_Viewer_Data->raw_trace_data = Event_Viewer_Data->raw_trace_data_first;
425 get_events(Event_Viewer_Data, start,end, RESERVE_SIZE);
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;
434 time_period->start_event_number = 0;
435 time_period->end_event_number = Event_Viewer_Data->raw_trace_data->len - 1;
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;
443 get_events(Event_Viewer_Data, start,end, RESERVE_SIZE);
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;
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;
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;
460 Event_Viewer_Data->end_event_number = Event_Viewer_Data->Number_Of_Events - 1;
461
462 Event_Viewer_Data->VAdjust_C->upper = Event_Viewer_Data->Number_Of_Events;
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;
473 }
474
475 void Tree_V_set_cursor(EventViewerData *Event_Viewer_Data)
476 {
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 }
492 }
493
494 void Tree_V_get_cursor(EventViewerData *Event_Viewer_Data)
495 {
496 GtkTreePath *path;
497 gint *indices;
498
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);
515
516 }
517
518
519
520 void Tree_V_move_cursor_cb (GtkWidget *widget, GtkMovementStep arg1, gint arg2, gpointer data)
521 {
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)
545 {
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)
551 {
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");
559 }
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 }
577 }
578
579 }
580
581 if(arg1 == GTK_MOVEMENT_PAGES)
582 {
583 /* Move one page */
584 if(arg2 == 1)
585 {
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)
610 {
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
622 } else {
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
634 }
635 }
636
637 }
638
639 }
640
641 if(arg1 == GTK_MOVEMENT_BUFFER_ENDS)
642 {
643 /* Move to the ends of the buffer */
644 if(arg2 == 1)
645 {
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);
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);
664 g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
665 }
666
667 }
668
669
670 gtk_tree_path_free(path);
671 }
672
673 void Tree_V_cursor_changed_cb (GtkWidget *widget, gpointer data)
674 {
675 EventViewerData *Event_Viewer_Data = (EventViewerData*) data;
676 LttTime ltt_time;
677 guint64 time;
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 */
700 }
701
702
703 void v_scroll_cb (GtkAdjustment *adjustment, gpointer data)
704 {
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
734 }
735
736 gint get_cell_height(GtkTreeView *TreeView)
737 {
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;
747 }
748
749 void Tree_V_size_allocate_cb (GtkWidget *widget, GtkAllocation *alloc, gpointer data)
750 {
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 -
759 TREE_VIEW_HEADER_HEIGHT (GTK_TREE_VIEW(Event_Viewer_Data->Tree_V)) )
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
779
780 }
781
782 void Tree_V_size_request_cb (GtkWidget *widget, GtkRequisition *requisition, gpointer data)
783 {
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));
787
788 g_critical("size-request");
789
790 h = Cell_Height + TREE_VIEW_HEADER_HEIGHT
791 (GTK_TREE_VIEW(Event_Viewer_Data->Tree_V));
792 requisition->height = h;
793
794 }
795
796 void get_test_data(guint Event_Number, guint List_Height,
797 EventViewerData *Event_Viewer_Data)
798 {
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;
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;
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;
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;
840
841 //scroll up
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);
856 get_events(Event_Viewer_Data, time_period->start, time_period->end,RESERVE_SIZE);
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);
864 Event_Viewer_Data->raw_trace_data_second = g_ptr_array_sized_new(RESERVE_SIZE);
865
866 Event_Viewer_Data->raw_trace_data = Event_Viewer_Data->raw_trace_data_first;
867 time_period = g_ptr_array_index(Event_Viewer_Data->time_period,
868 Event_Viewer_Data->current_period);
869 get_events(Event_Viewer_Data, time_period->start, time_period->end,RESERVE_SIZE);
870 Event_Viewer_Data->start_event_number = time_period->start_event_number;
871
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);
875 get_events(Event_Viewer_Data, time_period->start, time_period->end,RESERVE_SIZE);
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 }
880 }
881 //scroll down
882 else if(Event_Number+List_Height >= Event_Viewer_Data->end_event_number){
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++;
901 time_period->end.tv_sec = G_MAXULONG;
902 time_period->end.tv_nsec = G_MAXULONG;
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
910 get_events(Event_Viewer_Data,time_period->start, time_period->end, RESERVE_SIZE);
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);
930 Event_Viewer_Data->raw_trace_data_second = g_ptr_array_sized_new(RESERVE_SIZE);
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++;
939 time_period->end.tv_sec = G_MAXULONG;
940 time_period->end.tv_nsec = G_MAXULONG;
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 }
944
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);
948 get_events(Event_Viewer_Data,time_period->start, time_period->end, RESERVE_SIZE);
949 Event_Viewer_Data->start_event_number = time_period->start_event_number;
950 Event_Viewer_Data->end_event_number = time_period->end_event_number;
951
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);
955 get_events(Event_Viewer_Data,time_period->start, time_period->end, RESERVE_SIZE);
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;
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 {
975 guint64 real_data;
976
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 */
987 real_data = raw_data->time.tv_sec;
988 real_data *= 1000000000;
989 real_data += raw_data->time.tv_nsec;
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,
994 TIME_COLUMN, real_data,
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++)
1023 {
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);
1027 }
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);
1042 }
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 //}
1068 #endif //DEBUG
1069 Event_Viewer_Data->First_Event = Event_Number ;
1070 Event_Viewer_Data->Last_Event = Event_Number+List_Height-1 ;
1071
1072
1073
1074 }
1075
1076
1077 void add_test_data(EventViewerData *Event_Viewer_Data)
1078 {
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
1096 }
1097
1098
1099 void
1100 GuiEvents_Destructor(EventViewerData *Event_Viewer_Data)
1101 {
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
1111 /* Clear raw event list */
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);
1117 }
1118
1119 //FIXME : call hGuiEvents_Destructor for corresponding data upon widget destroy
1120
1121 static void
1122 tree_selection_changed_cb (GtkTreeSelection *selection, gpointer data)
1123 {
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 }
1138
1139
1140 int 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);
1151
1152 }
1153
1154
1155 gboolean updateTimeInterval(void * hook_data, void * call_data)
1156 {
1157 EventViewerData *Event_Viewer_Data = (EventViewerData*) hook_data;
1158 Event_Viewer_Data->time_interval = *(TimeInterval*)call_data;
1159
1160 return FALSE;
1161 }
1162
1163 gboolean 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
1193 void 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 }
1198
1199 void get_events(EventViewerData* Event_Viewer_Data, LttTime start,
1200 LttTime end,unsigned maxNumEvents)
1201 {
1202 contextAddHooks(Event_Viewer_Data->mw, NULL, NULL, NULL, NULL, NULL, NULL,
1203 NULL, NULL, NULL,Event_Viewer_Data->before_event_hooks,NULL);
1204 processTraceset(Event_Viewer_Data->mw, start, end, maxNumEvents);
1205 contextRemoveHooks(Event_Viewer_Data->mw, NULL, NULL, NULL, NULL, NULL, NULL,
1206 NULL, NULL, NULL,Event_Viewer_Data->before_event_hooks,NULL);
1207
1208 }
1209
1210 static 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 }
1266
1267 static 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 }
1286
1287 gboolean 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 }
1345
1346 void 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 }
1358
1359
1360
1361 /* Imported code from LTT 0.9.6pre2 tracevisualizer */
1362 #ifdef DEBUG
1363
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 ******************************************************************/
1378 static void WDI_gtk_clist_set_last_row_data_full(GtkCList* pmClist,
1379 gpointer pmData,
1380 GtkDestroyNotify pmDestroy)
1381 {
1382 GtkCListRow *pClistRow;
1383
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);
1387
1388 pClistRow = pmClist->row_list_end->data;
1389 pClistRow->data = pmData;
1390 pClistRow->destroy = pmDestroy;
1391 }
1392
1393
1394 /******************************************************************
1395 * Function :
1396 * SHRTEventSelect()
1397 * Description :
1398 * Parameters :
1399 * Return values :
1400 * History :
1401 * Note :
1402 ******************************************************************/
1403 static void SHRTEventSelect(GtkWidget* pmCList,
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 ******************************************************************/
1429 static void SHRTEventButtonPress(GtkWidget* pmCList,
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 ******************************************************************/
1469 static void SHRTVAdjustValueChanged(GtkAdjustment* pmVAdjust,
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 ******************************************************************/
1547 static void WDConnectSignals(systemView* pmSysView)
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 ******************************************************************/
1594 static void WDFillEventList(GtkWidget* pmList,
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
1714 #endif //DEBUG
1715
1716 static void destroy_cb( GtkWidget *widget,
1717 gpointer data )
1718 {
1719 gtk_main_quit ();
1720 }
1721
1722
1723 /*
1724 int main(int argc, char **argv)
1725 {
1726 GtkWidget *Window;
1727 GtkWidget *ListViewer;
1728 GtkWidget *VBox_V;
1729 EventViewerData *Event_Viewer_Data;
1730 guint ev_sel = 444 ;
1731
1732 // Initialize i18n support
1733 gtk_set_locale ();
1734
1735 // Initialize the widget set
1736 gtk_init (&argc, &argv);
1737
1738 init();
1739
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
1750 //ListViewer = hGuiEvents(Window);
1751 //gtk_box_pack_start(GTK_BOX(VBox_V), ListViewer, TRUE, TRUE, 0);
1752
1753 //ListViewer = hGuiEvents(Window);
1754 //gtk_box_pack_start(GTK_BOX(VBox_V), ListViewer, FALSE, TRUE, 0);
1755
1756 Event_Viewer_Data = GuiEvents(g_new(mainWindow,1));
1757 ListViewer = Event_Viewer_Data->HBox_V;
1758 gtk_box_pack_start(GTK_BOX(VBox_V), ListViewer, TRUE, TRUE, 0);
1759
1760 gtk_widget_show (VBox_V);
1761 gtk_widget_show (Window);
1762
1763 // Event_Selected_Hook(Event_Viewer_Data, &ev_sel);
1764
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 }
1776 */
1777
1778 /*\@}*/
1779
LTTng 2.x Viewer (LTTV)
This page took 0.062759 seconds and 5 git commands to generate.