projects / lttv.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
git-svn-id: http://ltt.polymtl.ca/svn@226 04897980-b3bd-0310-b5e0-8ef037075253
[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 #define SECOND_INTERVAL 1
80 #define NANOSECOND_INTERVAL 1000
81
82 typedef enum _ScrollDirection{
83 SCROLL_IN_SAME_PERIOD,
84 SCROLL_UP_ONE_PERIOD,
85 SCROLL_UP_MORE_PERIOD,
86 SCROLL_DOWN_ONE_PERIOD,
87 SCROLL_DOWN_MORE_PERIOD
88 } ScrollDirection;
89
90 typedef struct _EventViewerData {
91
92 mainWindow * mw;
93 TimeInterval time_interval;
94 LttTime current_time;
95 GPtrArray * raw_trace_data;
96 GPtrArray * raw_trace_data_first;
97 GPtrArray * raw_trace_data_second;
98 GPtrArray * time_period;
99 unsigned current_period;
100 unsigned start_event_number;
101 unsigned end_event_number;
102 LttvHooks * before_event_hooks;
103
104 //scroll window containing Tree View
105 GtkWidget * Scroll_Win;
106
107 /* Model containing list data */
108 GtkListStore *Store_M;
109
110 GtkWidget *HBox_V;
111 /* Widget to display the data in a columned list */
112 GtkWidget *Tree_V;
113 GtkAdjustment *VTree_Adjust_C ;
114 GdkWindow *TreeWindow ;
115
116 /* Vertical scrollbar and it's adjustment */
117 GtkWidget *VScroll_VC;
118 GtkAdjustment *VAdjust_C ;
119
120 /* Selection handler */
121 GtkTreeSelection *Select_C;
122
123 guint Num_Visible_Events;
124 guint First_Event, Last_Event;
125
126 /* TEST DATA, TO BE READ FROM THE TRACE */
127 gint Number_Of_Events ;
128 guint Currently_Selected_Event ;
129 gboolean Selected_Event ;
130
131 } EventViewerData ;
132
133 //! Event Viewer's constructor hook
134 GtkWidget *hGuiEvents(mainWindow *pmParentWindow);
135 //! Event Viewer's constructor
136 EventViewerData *GuiEvents(mainWindow *pmParentWindow);
137 //! Event Viewer's destructor
138 void GuiEvents_Destructor(EventViewerData *Event_Viewer_Data);
139
140 static int Event_Selected_Hook(void *hook_data, void *call_data);
141
142 void Tree_V_set_cursor(EventViewerData *Event_Viewer_Data);
143 void Tree_V_get_cursor(EventViewerData *Event_Viewer_Data);
144
145 /* Prototype for selection handler callback */
146 static void tree_selection_changed_cb (GtkTreeSelection *selection, gpointer data);
147 static void v_scroll_cb (GtkAdjustment *adjustment, gpointer data);
148 static void Tree_V_size_allocate_cb (GtkWidget *widget, GtkAllocation *alloc, gpointer data);
149 static void Tree_V_size_request_cb (GtkWidget *widget, GtkRequisition *requisition, gpointer data);
150 static void Tree_V_cursor_changed_cb (GtkWidget *widget, gpointer data);
151 static void Tree_V_move_cursor_cb (GtkWidget *widget, GtkMovementStep arg1, gint arg2, gpointer data);
152 static void Tree_V_grab_focus(GtkWidget *widget, gpointer data);
153
154
155 static void get_test_data(guint Event_Number, guint List_Height,
156 EventViewerData *Event_Viewer_Data);
157
158 void add_test_data(EventViewerData *Event_Viewer_Data);
159
160 static void get_events(EventViewerData* Event_Viewer_Data, LttTime start, LttTime end);
161 static gboolean parse_event(void *hook_data, void *call_data);
162
163 /**
164 * plugin's init function
165 *
166 * This function initializes the Event Viewer functionnality through the
167 * gtkTraceSet API.
168 */
169 G_MODULE_EXPORT void init() {
170
171 g_critical("GUI Event Viewer init()");
172
173 /* Register the toolbar insert button */
174 ToolbarItemReg(hGuiEventsInsert_xpm, "Insert Event Viewer", hGuiEvents);
175
176 /* Register the menu item insert entry */
177 MenuItemReg("/", "Insert Event Viewer", hGuiEvents);
178
179 }
180
181 void destroy_walk(gpointer data, gpointer user_data)
182 {
183 GuiEvents_Destructor((EventViewerData*)data);
184 }
185
186 /**
187 * plugin's destroy function
188 *
189 * This function releases the memory reserved by the module and unregisters
190 * everything that has been registered in the gtkTraceSet API.
191 */
192 G_MODULE_EXPORT void destroy() {
193 int i;
194
195 EventViewerData *Event_Viewer_Data;
196
197 g_critical("GUI Event Viewer destroy()");
198
199 g_slist_foreach(sEvent_Viewer_Data_List, destroy_walk, NULL );
200
201 /* Unregister the toolbar insert button */
202 ToolbarItemUnreg(hGuiEvents);
203
204 /* Unregister the menu item insert entry */
205 MenuItemUnreg(hGuiEvents);
206 }
207
208 /* Enumeration of the columns */
209 enum
210 {
211 CPUID_COLUMN,
212 EVENT_COLUMN,
213 TIME_COLUMN,
214 PID_COLUMN,
215 ENTRY_LEN_COLUMN,
216 EVENT_DESCR_COLUMN,
217 N_COLUMNS
218 };
219
220
221 /**
222 * Event Viewer's constructor hook
223 *
224 * This constructor is given as a parameter to the menuitem and toolbar button
225 * registration. It creates the list.
226 * @param pmParentWindow A pointer to the parent window.
227 * @return The widget created.
228 */
229 GtkWidget *
230 hGuiEvents(mainWindow * pmParentWindow)
231 {
232 EventViewerData* Event_Viewer_Data = GuiEvents(pmParentWindow) ;
233
234 return Event_Viewer_Data->HBox_V ;
235
236 }
237
238 /**
239 * Event Viewer's constructor
240 *
241 * This constructor is used to create EventViewerData data structure.
242 * @return The Event viewer data created.
243 */
244 EventViewerData *
245 GuiEvents(mainWindow *pmParentWindow)
246 {
247 LttTime start, end;
248 GtkTreeViewColumn *column;
249 GtkCellRenderer *renderer;
250 EventViewerData* Event_Viewer_Data = g_new(EventViewerData,1) ;
251 TimePeriod * time_period;
252 RawTraceData * data;
253
254 Event_Viewer_Data->mw = pmParentWindow;
255 GetTimeInterval(Event_Viewer_Data->mw, &Event_Viewer_Data->time_interval);
256 GetCurrentTime(Event_Viewer_Data->mw, &Event_Viewer_Data->current_time);
257 Event_Viewer_Data->raw_trace_data_first = g_ptr_array_sized_new(RESERVE_SIZE);
258 Event_Viewer_Data->raw_trace_data_second = g_ptr_array_sized_new(RESERVE_SIZE);
259 Event_Viewer_Data->time_period = g_ptr_array_sized_new(RESERVE_SIZE);
260
261 Event_Viewer_Data->before_event_hooks = lttv_hooks_new();
262 lttv_hooks_add(Event_Viewer_Data->before_event_hooks, parse_event, Event_Viewer_Data);
263
264 RegUpdateTimeInterval(updateTimeInterval,Event_Viewer_Data, Event_Viewer_Data->mw);
265 RegUpdateCurrentTime(updateCurrentTime,Event_Viewer_Data, Event_Viewer_Data->mw);
266
267 Event_Viewer_Data->Scroll_Win = gtk_scrolled_window_new (NULL, NULL);
268 gtk_widget_show ( Event_Viewer_Data->Scroll_Win);
269 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(Event_Viewer_Data->Scroll_Win),
270 GTK_POLICY_AUTOMATIC, GTK_POLICY_NEVER);
271
272 /* TEST DATA, TO BE READ FROM THE TRACE */
273 Event_Viewer_Data->Number_Of_Events = RESERVE_SIZE ;
274 Event_Viewer_Data->Currently_Selected_Event = FALSE ;
275 Event_Viewer_Data->Selected_Event = 0;
276
277 /* Create a model for storing the data list */
278 Event_Viewer_Data->Store_M = gtk_list_store_new (N_COLUMNS, /* Total number of columns */
279 G_TYPE_INT, /* CPUID */
280 G_TYPE_STRING, /* Event */
281 G_TYPE_UINT64, /* Time */
282 G_TYPE_INT, /* PID */
283 G_TYPE_INT, /* Entry length */
284 G_TYPE_STRING); /* Event's description */
285
286 /* Create the viewer widget for the columned list */
287 Event_Viewer_Data->Tree_V = gtk_tree_view_new_with_model (GTK_TREE_MODEL (Event_Viewer_Data->Store_M));
288
289 g_signal_connect (G_OBJECT (Event_Viewer_Data->Tree_V), "size-allocate",
290 G_CALLBACK (Tree_V_size_allocate_cb),
291 Event_Viewer_Data);
292 g_signal_connect (G_OBJECT (Event_Viewer_Data->Tree_V), "size-request",
293 G_CALLBACK (Tree_V_size_request_cb),
294 Event_Viewer_Data);
295
296 g_signal_connect (G_OBJECT (Event_Viewer_Data->Tree_V), "cursor-changed",
297 G_CALLBACK (Tree_V_cursor_changed_cb),
298 Event_Viewer_Data);
299
300 g_signal_connect (G_OBJECT (Event_Viewer_Data->Tree_V), "move-cursor",
301 G_CALLBACK (Tree_V_move_cursor_cb),
302 Event_Viewer_Data);
303
304 g_signal_connect (G_OBJECT (Event_Viewer_Data->Tree_V), "grab-focus",
305 G_CALLBACK (Tree_V_grab_focus),
306 Event_Viewer_Data);
307
308 // Use on each column!
309 //gtk_tree_view_column_set_sizing(Event_Viewer_Data->Tree_V, GTK_TREE_VIEW_COLUMN_FIXED);
310
311 /* The view now holds a reference. We can get rid of our own
312 * reference */
313 g_object_unref (G_OBJECT (Event_Viewer_Data->Store_M));
314
315
316 /* Create a column, associating the "text" attribute of the
317 * cell_renderer to the first column of the model */
318 /* Columns alignment : 0.0 : Left 0.5 : Center 1.0 : Right */
319 renderer = gtk_cell_renderer_text_new ();
320 column = gtk_tree_view_column_new_with_attributes ("CPUID",
321 renderer,
322 "text", CPUID_COLUMN,
323 NULL);
324 gtk_tree_view_column_set_alignment (column, 0.0);
325 gtk_tree_view_column_set_fixed_width (column, 45);
326 gtk_tree_view_append_column (GTK_TREE_VIEW (Event_Viewer_Data->Tree_V), column);
327
328 renderer = gtk_cell_renderer_text_new ();
329 column = gtk_tree_view_column_new_with_attributes ("Event",
330 renderer,
331 "text", EVENT_COLUMN,
332 NULL);
333 gtk_tree_view_column_set_alignment (column, 0.0);
334 gtk_tree_view_column_set_fixed_width (column, 120);
335 gtk_tree_view_append_column (GTK_TREE_VIEW (Event_Viewer_Data->Tree_V), column);
336
337 renderer = gtk_cell_renderer_text_new ();
338 column = gtk_tree_view_column_new_with_attributes ("Time",
339 renderer,
340 "text", TIME_COLUMN,
341 NULL);
342 gtk_tree_view_column_set_alignment (column, 1.0);
343 gtk_tree_view_column_set_fixed_width (column, 120);
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 ("PID",
348 renderer,
349 "text", PID_COLUMN,
350 NULL);
351 gtk_tree_view_column_set_alignment (column, 1.0);
352 gtk_tree_view_column_set_fixed_width (column, 45);
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 ("Entry Length",
357 renderer,
358 "text", ENTRY_LEN_COLUMN,
359 NULL);
360 gtk_tree_view_column_set_alignment (column, 1.0);
361 gtk_tree_view_column_set_fixed_width (column, 60);
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 ("Event's Description",
366 renderer,
367 "text", EVENT_DESCR_COLUMN,
368 NULL);
369 gtk_tree_view_column_set_alignment (column, 0.0);
370 gtk_tree_view_append_column (GTK_TREE_VIEW (Event_Viewer_Data->Tree_V), column);
371
372
373 /* Setup the selection handler */
374 Event_Viewer_Data->Select_C = gtk_tree_view_get_selection (GTK_TREE_VIEW (Event_Viewer_Data->Tree_V));
375 gtk_tree_selection_set_mode (Event_Viewer_Data->Select_C, GTK_SELECTION_SINGLE);
376 g_signal_connect (G_OBJECT (Event_Viewer_Data->Select_C), "changed",
377 G_CALLBACK (tree_selection_changed_cb),
378 Event_Viewer_Data);
379
380 gtk_container_add (GTK_CONTAINER (Event_Viewer_Data->Scroll_Win), Event_Viewer_Data->Tree_V);
381
382 Event_Viewer_Data->HBox_V = gtk_hbox_new(0, 0);
383 gtk_box_pack_start(GTK_BOX(Event_Viewer_Data->HBox_V), Event_Viewer_Data->Scroll_Win, TRUE, TRUE, 0);
384
385 /* Create vertical scrollbar and pack it */
386 Event_Viewer_Data->VScroll_VC = gtk_vscrollbar_new(NULL);
387 gtk_box_pack_start(GTK_BOX(Event_Viewer_Data->HBox_V), Event_Viewer_Data->VScroll_VC, FALSE, TRUE, 0);
388
389 /* Get the vertical scrollbar's adjustment */
390 Event_Viewer_Data->VAdjust_C = gtk_range_get_adjustment(GTK_RANGE(Event_Viewer_Data->VScroll_VC));
391 Event_Viewer_Data->VTree_Adjust_C = gtk_tree_view_get_vadjustment(
392 GTK_TREE_VIEW (Event_Viewer_Data->Tree_V));
393
394 g_signal_connect (G_OBJECT (Event_Viewer_Data->VAdjust_C), "value-changed",
395 G_CALLBACK (v_scroll_cb),
396 Event_Viewer_Data);
397 /* Set the upper bound to the last event number */
398 Event_Viewer_Data->VAdjust_C->lower = 0;
399 Event_Viewer_Data->VAdjust_C->upper = Event_Viewer_Data->Number_Of_Events;
400 Event_Viewer_Data->VAdjust_C->value = 0;
401 Event_Viewer_Data->VAdjust_C->step_increment = 1;
402 Event_Viewer_Data->VAdjust_C->page_increment =
403 Event_Viewer_Data->VTree_Adjust_C->upper;
404 Event_Viewer_Data->VAdjust_C->page_size =
405 Event_Viewer_Data->VTree_Adjust_C->upper;
406 g_critical("value : %u",Event_Viewer_Data->VTree_Adjust_C->upper);
407 /* Raw event trace */
408 gtk_widget_show(Event_Viewer_Data->HBox_V);
409 gtk_widget_show(Event_Viewer_Data->Tree_V);
410 gtk_widget_show(Event_Viewer_Data->VScroll_VC);
411
412 /* Add the object's information to the module's array */
413 sEvent_Viewer_Data_List = g_slist_append(sEvent_Viewer_Data_List, Event_Viewer_Data);
414
415 Event_Viewer_Data->First_Event = -1 ;
416 Event_Viewer_Data->Last_Event = 0 ;
417
418 Event_Viewer_Data->Num_Visible_Events = 1;
419
420 start.tv_sec = 0;
421 start.tv_nsec = 0;
422 end.tv_sec = SECOND_INTERVAL;
423 end.tv_nsec = NANOSECOND_INTERVAL;
424
425 Event_Viewer_Data->raw_trace_data = Event_Viewer_Data->raw_trace_data_first;
426 get_events(Event_Viewer_Data, start,end);
427 Event_Viewer_Data->Number_Of_Events = Event_Viewer_Data->raw_trace_data->len;
428
429 time_period = g_new(TimePeriod, 1);
430 data = g_ptr_array_index(Event_Viewer_Data->raw_trace_data,0);
431 time_period->start = data->time;
432 data = g_ptr_array_index(Event_Viewer_Data->raw_trace_data,
433 Event_Viewer_Data->raw_trace_data->len-1);
434 time_period->end = data->time;
435 time_period->start_event_number = 0;
436 time_period->end_event_number = Event_Viewer_Data->raw_trace_data->len - 1;
437 g_ptr_array_add(Event_Viewer_Data->time_period, time_period);
438
439 start = data->time;
440 start.tv_nsec++;
441
442 Event_Viewer_Data->current_period = 0;
443 Event_Viewer_Data->raw_trace_data = Event_Viewer_Data->raw_trace_data_second;
444 get_events(Event_Viewer_Data, start,end);
445 Event_Viewer_Data->Number_Of_Events += Event_Viewer_Data->raw_trace_data->len;
446
447 time_period = g_new(TimePeriod, 1);
448 data = g_ptr_array_index(Event_Viewer_Data->raw_trace_data,0);
449 time_period->start = data->time;
450 data = g_ptr_array_index(Event_Viewer_Data->raw_trace_data,
451 Event_Viewer_Data->raw_trace_data->len-1);
452 time_period->end = data->time;
453 time_period->start_event_number = Event_Viewer_Data->Number_Of_Events
454 - Event_Viewer_Data->raw_trace_data->len;
455 time_period->end_event_number = Event_Viewer_Data->Number_Of_Events - 1;
456 g_ptr_array_add(Event_Viewer_Data->time_period, time_period);
457
458 Event_Viewer_Data->raw_trace_data = Event_Viewer_Data->raw_trace_data_first;
459
460 Event_Viewer_Data->start_event_number = 0;
461 Event_Viewer_Data->end_event_number = Event_Viewer_Data->Number_Of_Events - 1;
462
463 Event_Viewer_Data->VAdjust_C->upper = Event_Viewer_Data->Number_Of_Events;
464
465 // Test data
466 get_test_data((int)Event_Viewer_Data->VAdjust_C->value,
467 Event_Viewer_Data->Num_Visible_Events,
468 Event_Viewer_Data);
469
470 /* Set the Selected Event */
471 Tree_V_set_cursor(Event_Viewer_Data);
472
473 return Event_Viewer_Data;
474 }
475
476 void Tree_V_set_cursor(EventViewerData *Event_Viewer_Data)
477 {
478 GtkTreePath *path;
479
480 if(Event_Viewer_Data->Selected_Event && Event_Viewer_Data->First_Event != -1)
481 {
482 gtk_adjustment_set_value(Event_Viewer_Data->VAdjust_C,
483 Event_Viewer_Data->Currently_Selected_Event);
484
485 path = gtk_tree_path_new_from_indices(
486 Event_Viewer_Data->Currently_Selected_Event-
487 Event_Viewer_Data->First_Event,
488 -1);
489
490 gtk_tree_view_set_cursor(GTK_TREE_VIEW(Event_Viewer_Data->Tree_V), path, NULL, FALSE);
491 gtk_tree_path_free(path);
492 }
493 }
494
495 void Tree_V_get_cursor(EventViewerData *Event_Viewer_Data)
496 {
497 GtkTreePath *path;
498 gint *indices;
499
500 gtk_tree_view_get_cursor(GTK_TREE_VIEW(Event_Viewer_Data->Tree_V), &path, NULL);
501 indices = gtk_tree_path_get_indices(path);
502
503 if(indices != NULL)
504 {
505 Event_Viewer_Data->Selected_Event = TRUE;
506 Event_Viewer_Data->Currently_Selected_Event =
507 Event_Viewer_Data->First_Event + indices[0];
508
509 } else {
510 Event_Viewer_Data->Selected_Event = FALSE;
511 Event_Viewer_Data->Currently_Selected_Event = 0;
512 }
513 g_critical("DEBUG : Event Selected : %i , num: %u", Event_Viewer_Data->Selected_Event, Event_Viewer_Data->Currently_Selected_Event) ;
514
515 gtk_tree_path_free(path);
516
517 }
518
519
520
521 void Tree_V_move_cursor_cb (GtkWidget *widget, GtkMovementStep arg1, gint arg2, gpointer data)
522 {
523 GtkTreePath *path; // = gtk_tree_path_new();
524 gint *indices;
525 gdouble value;
526 EventViewerData *Event_Viewer_Data = (EventViewerData*)data;
527
528 gtk_tree_view_get_cursor(GTK_TREE_VIEW(Event_Viewer_Data->Tree_V), &path, NULL);
529 if(path == NULL)
530 {
531 /* No prior cursor, put it at beginning of page and let the execution do */
532 path = gtk_tree_path_new_from_indices(0, -1);
533 gtk_tree_view_set_cursor(GTK_TREE_VIEW(Event_Viewer_Data->Tree_V), path, NULL, FALSE);
534 }
535
536 indices = gtk_tree_path_get_indices(path);
537
538 g_critical("DEBUG : move cursor step : %u , int : %i , indice : %i", (guint)arg1, arg2, indices[0]) ;
539
540 value = gtk_adjustment_get_value(Event_Viewer_Data->VAdjust_C);
541
542 if(arg1 == GTK_MOVEMENT_DISPLAY_LINES)
543 {
544 /* Move one line */
545 if(arg2 == 1)
546 {
547 /* move one line down */
548 if(indices[0] == Event_Viewer_Data->Num_Visible_Events - 1)
549 {
550 if(value + Event_Viewer_Data->Num_Visible_Events <=
551 Event_Viewer_Data->Number_Of_Events -1)
552 {
553 g_critical("need 1 event down") ;
554 Event_Viewer_Data->Currently_Selected_Event += 1;
555 gtk_adjustment_set_value(Event_Viewer_Data->VAdjust_C, value+1);
556 //gtk_tree_path_free(path);
557 //path = gtk_tree_path_new_from_indices(Event_Viewer_Data->Num_Visible_Events-1, -1);
558 //gtk_tree_view_set_cursor(GTK_TREE_VIEW(Event_Viewer_Data->Tree_V), path, NULL, FALSE);
559 g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
560 }
561 }
562 } else {
563 /* Move one line up */
564 if(indices[0] == 0)
565 {
566 if(value - 1 >= 0 )
567 {
568 g_critical("need 1 event up") ;
569 Event_Viewer_Data->Currently_Selected_Event -= 1;
570 gtk_adjustment_set_value(Event_Viewer_Data->VAdjust_C, value-1);
571 //gtk_tree_path_free(path);
572 //path = gtk_tree_path_new_from_indices(0, -1);
573 //gtk_tree_view_set_cursor(GTK_TREE_VIEW(Event_Viewer_Data->Tree_V), path, NULL, FALSE);
574 g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
575 }
576
577 }
578 }
579
580 }
581
582 if(arg1 == GTK_MOVEMENT_PAGES)
583 {
584 /* Move one page */
585 if(arg2 == 1)
586 {
587 if(Event_Viewer_Data->Num_Visible_Events == 1)
588 value += 1 ;
589 /* move one page down */
590 if(value + Event_Viewer_Data->Num_Visible_Events-1 <=
591 Event_Viewer_Data->Number_Of_Events )
592 {
593 g_critical("need 1 page down") ;
594
595 Event_Viewer_Data->Currently_Selected_Event += Event_Viewer_Data->Num_Visible_Events-1;
596 gtk_adjustment_set_value(Event_Viewer_Data->VAdjust_C,
597 value+(Event_Viewer_Data->Num_Visible_Events-1));
598 //gtk_tree_path_free(path);
599 //path = gtk_tree_path_new_from_indices(0, -1);
600 //gtk_tree_view_set_cursor(GTK_TREE_VIEW(Event_Viewer_Data->Tree_V), path, NULL, FALSE);
601 g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
602 }
603 } else {
604 /* Move one page up */
605 if(Event_Viewer_Data->Num_Visible_Events == 1)
606 value -= 1 ;
607
608 if(indices[0] < Event_Viewer_Data->Num_Visible_Events - 2 )
609 {
610 if(value - (Event_Viewer_Data->Num_Visible_Events-1) >= 0)
611 {
612 g_critical("need 1 page up") ;
613
614 Event_Viewer_Data->Currently_Selected_Event -= Event_Viewer_Data->Num_Visible_Events-1;
615
616 gtk_adjustment_set_value(Event_Viewer_Data->VAdjust_C,
617 value-(Event_Viewer_Data->Num_Visible_Events-1));
618 //gtk_tree_path_free(path);
619 //path = gtk_tree_path_new_from_indices(0, -1);
620 //gtk_tree_view_set_cursor(GTK_TREE_VIEW(Event_Viewer_Data->Tree_V), path, NULL, FALSE);
621 g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
622
623 } else {
624 /* Go to first Event */
625 g_critical("need 1 page up") ;
626
627 Event_Viewer_Data->Currently_Selected_Event == 0 ;
628 gtk_adjustment_set_value(Event_Viewer_Data->VAdjust_C,
629 0);
630 //gtk_tree_path_free(path);
631 //path = gtk_tree_path_new_from_indices(0, -1);
632 //gtk_tree_view_set_cursor(GTK_TREE_VIEW(Event_Viewer_Data->Tree_V), path, NULL, FALSE);
633 g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
634
635 }
636 }
637
638 }
639
640 }
641
642 if(arg1 == GTK_MOVEMENT_BUFFER_ENDS)
643 {
644 /* Move to the ends of the buffer */
645 if(arg2 == 1)
646 {
647 /* move end of buffer */
648 g_critical("End of buffer") ;
649 Event_Viewer_Data->Currently_Selected_Event = Event_Viewer_Data->Number_Of_Events-1 ;
650 gtk_adjustment_set_value(Event_Viewer_Data->VAdjust_C,
651 Event_Viewer_Data->Number_Of_Events -
652 Event_Viewer_Data->Num_Visible_Events);
653 //gtk_tree_path_free(path);
654 //path = gtk_tree_path_new_from_indices(Event_Viewer_Data->Num_Visible_Events-1, -1);
655 //gtk_tree_view_set_cursor(GTK_TREE_VIEW(Event_Viewer_Data->Tree_V), path, NULL, FALSE);
656 g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
657 } else {
658 /* Move beginning of buffer */
659 g_critical("Beginning of buffer") ;
660 Event_Viewer_Data->Currently_Selected_Event = 0 ;
661 gtk_adjustment_set_value(Event_Viewer_Data->VAdjust_C, 0);
662 //gtk_tree_path_free(path);
663 //path = gtk_tree_path_new_from_indices(0, -1);
664 //gtk_tree_view_set_cursor(GTK_TREE_VIEW(Event_Viewer_Data->Tree_V), path, NULL, FALSE);
665 g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
666 }
667
668 }
669
670
671 gtk_tree_path_free(path);
672 }
673
674 void Tree_V_cursor_changed_cb (GtkWidget *widget, gpointer data)
675 {
676 EventViewerData *Event_Viewer_Data = (EventViewerData*) data;
677 LttTime ltt_time;
678 guint64 time;
679 GtkTreeIter iter;
680 GtkTreeModel* model = GTK_TREE_MODEL(Event_Viewer_Data->Store_M);
681 GtkTreePath *path;
682
683 g_critical("DEBUG : cursor change");
684 /* On cursor change, modify the currently selected event by calling
685 * the right API function */
686 Tree_V_get_cursor(Event_Viewer_Data);
687 /*
688 gtk_tree_view_get_cursor(GTK_TREE_VIEW(Event_Viewer_Data->Tree_V), &path, NULL);
689 if(gtk_tree_model_get_iter(model,&iter,path)){
690 gtk_tree_model_get(model, &iter, TIME_COLUMN, &time, -1);
691 ltt_time.tv_sec = time / 1000000000;
692 ltt_time.tv_nsec = time % 1000000000;
693
694 if(ltt_time.tv_sec != Event_Viewer_Data->current_time.tv_sec ||
695 ltt_time.tv_nsec != Event_Viewer_Data->current_time.tv_nsec)
696 SetCurrentTime(Event_Viewer_Data->mw,&ltt_time);
697 }else{
698 g_warning("Can not get iter\n");
699 }
700 */
701 }
702
703
704 void v_scroll_cb (GtkAdjustment *adjustment, gpointer data)
705 {
706 EventViewerData *Event_Viewer_Data = (EventViewerData*)data;
707 GtkTreePath *Tree_Path;
708
709 g_critical("DEBUG : scroll signal, value : %f", adjustment->value);
710
711 get_test_data((int)adjustment->value, Event_Viewer_Data->Num_Visible_Events,
712 Event_Viewer_Data);
713
714
715 if(Event_Viewer_Data->Currently_Selected_Event
716 >= Event_Viewer_Data->First_Event
717 &&
718 Event_Viewer_Data->Currently_Selected_Event
719 <= Event_Viewer_Data->Last_Event
720 &&
721 Event_Viewer_Data->Selected_Event)
722 {
723
724 Tree_Path = gtk_tree_path_new_from_indices(
725 Event_Viewer_Data->Currently_Selected_Event-
726 Event_Viewer_Data->First_Event,
727 -1);
728
729 gtk_tree_view_set_cursor(GTK_TREE_VIEW(Event_Viewer_Data->Tree_V), Tree_Path,
730 NULL, FALSE);
731 gtk_tree_path_free(Tree_Path);
732 }
733
734
735 }
736
737 gint get_cell_height(GtkTreeView *TreeView)
738 {
739 gint height, width;
740 GtkTreeViewColumn *Column = gtk_tree_view_get_column(TreeView, 0);
741 GList *Render_List = gtk_tree_view_column_get_cell_renderers(Column);
742 GtkCellRenderer *Renderer = g_list_first(Render_List)->data;
743
744 gtk_tree_view_column_cell_get_size(Column, NULL, NULL, NULL, NULL, &height);
745 g_critical("cell 0 height : %u",height);
746
747 return height;
748 }
749
750 void Tree_V_size_allocate_cb (GtkWidget *widget, GtkAllocation *alloc, gpointer data)
751 {
752 EventViewerData *Event_Viewer_Data = (EventViewerData*)data;
753 gint Cell_Height = get_cell_height(GTK_TREE_VIEW(Event_Viewer_Data->Tree_V));
754 gint Last_Num_Visible_Events = Event_Viewer_Data->Num_Visible_Events;
755 gdouble Exact_Num_Visible;
756
757 g_critical("size-allocate");
758
759 Exact_Num_Visible = ( alloc->height -
760 TREE_VIEW_HEADER_HEIGHT (GTK_TREE_VIEW(Event_Viewer_Data->Tree_V)) )
761 / (double)Cell_Height ;
762
763 Event_Viewer_Data->Num_Visible_Events = ceil(Exact_Num_Visible) ;
764
765 g_critical("number of events shown : %u",Event_Viewer_Data->Num_Visible_Events);
766 g_critical("ex number of events shown : %f",Exact_Num_Visible);
767
768 Event_Viewer_Data->VAdjust_C->page_increment =
769 floor(Exact_Num_Visible);
770 Event_Viewer_Data->VAdjust_C->page_size =
771 floor(Exact_Num_Visible);
772
773 if(Event_Viewer_Data->Num_Visible_Events != Last_Num_Visible_Events)
774 {
775 get_test_data((int)Event_Viewer_Data->VAdjust_C->value,
776 Event_Viewer_Data->Num_Visible_Events,
777 Event_Viewer_Data);
778 }
779
780
781 }
782
783 void Tree_V_size_request_cb (GtkWidget *widget, GtkRequisition *requisition, gpointer data)
784 {
785 gint h;
786 EventViewerData *Event_Viewer_Data = (EventViewerData*)data;
787 gint Cell_Height = get_cell_height(GTK_TREE_VIEW(Event_Viewer_Data->Tree_V));
788
789 g_critical("size-request");
790
791 h = Cell_Height + TREE_VIEW_HEADER_HEIGHT
792 (GTK_TREE_VIEW(Event_Viewer_Data->Tree_V));
793 requisition->height = h;
794
795 }
796
797 void get_test_data(guint Event_Number, guint List_Height,
798 EventViewerData *Event_Viewer_Data)
799 {
800 GtkTreeIter iter;
801 int i, j;
802 GtkTreeModel *model = GTK_TREE_MODEL(Event_Viewer_Data->Store_M);
803 GtkTreePath *Tree_Path;
804 gchar *test_string;
805 RawTraceData * raw_data;
806 GPtrArray * second_data;
807 TimePeriod * time_period, *time_period1;
808 unsigned scroll_period;
809 ScrollDirection direction = SCROLL_IN_SAME_PERIOD;
810 int period_diff;
811 gboolean new_time_period = FALSE;
812
813 // if(Event_Number > Event_Viewer_Data->Last_Event ||
814 // Event_Number + List_Height-1 < Event_Viewer_Data->First_Event ||
815 // Event_Viewer_Data->First_Event == -1)
816 {
817 /* no event can be reused, clear and start from nothing */
818 second_data = Event_Viewer_Data->raw_trace_data == Event_Viewer_Data->raw_trace_data_first
819 ? Event_Viewer_Data->raw_trace_data_second : Event_Viewer_Data->raw_trace_data_first;
820
821 // get the right time period
822 for(i=0;i<Event_Viewer_Data->time_period->len;i++){
823 time_period = g_ptr_array_index(Event_Viewer_Data->time_period, i);
824 scroll_period = i;
825 if(Event_Number > time_period->end_event_number)continue;
826 if(Event_Number + List_Height <= time_period->end_event_number){
827 if(Event_Viewer_Data->current_period == scroll_period -1){
828 scroll_period--;
829 }
830 }
831 break;
832 }
833
834 period_diff = scroll_period - Event_Viewer_Data->current_period;
835 if(period_diff == 0) direction = SCROLL_IN_SAME_PERIOD;
836 else if(period_diff == -1) direction = SCROLL_UP_ONE_PERIOD;
837 else if(period_diff < -1) direction = SCROLL_UP_MORE_PERIOD;
838 else if(period_diff == 1) direction = SCROLL_DOWN_ONE_PERIOD;
839 else if(period_diff > 1) direction = SCROLL_DOWN_MORE_PERIOD;
840 Event_Viewer_Data->current_period += period_diff;
841
842 //scroll up
843 if(Event_Number < Event_Viewer_Data->start_event_number){
844 if(direction == SCROLL_UP_ONE_PERIOD){
845 // Event_Viewer_Data->current_period--;
846 Event_Viewer_Data->end_event_number -= second_data->len;
847 free_ptr_array(second_data);
848 if(Event_Viewer_Data->raw_trace_data == Event_Viewer_Data->raw_trace_data_first){
849 Event_Viewer_Data->raw_trace_data_second = g_ptr_array_sized_new(RESERVE_SIZE);
850 Event_Viewer_Data->raw_trace_data = Event_Viewer_Data->raw_trace_data_second;
851 }else{
852 Event_Viewer_Data->raw_trace_data_first = g_ptr_array_sized_new(RESERVE_SIZE);
853 Event_Viewer_Data->raw_trace_data = Event_Viewer_Data->raw_trace_data_first;
854 }
855 time_period = g_ptr_array_index(Event_Viewer_Data->time_period,
856 Event_Viewer_Data->current_period);
857 get_events(Event_Viewer_Data, time_period->start, time_period->end);
858 raw_data = g_ptr_array_index(Event_Viewer_Data->raw_trace_data,
859 Event_Viewer_Data->raw_trace_data->len-1);
860 Event_Viewer_Data->start_event_number -= Event_Viewer_Data->raw_trace_data->len;
861 }else{//direction = SCROLL_UP_MORE_PERIOD
862 free_ptr_array(second_data);
863 free_ptr_array(Event_Viewer_Data->raw_trace_data);
864 Event_Viewer_Data->raw_trace_data_first = g_ptr_array_sized_new(RESERVE_SIZE);
865 Event_Viewer_Data->raw_trace_data_second = g_ptr_array_sized_new(RESERVE_SIZE);
866
867 Event_Viewer_Data->raw_trace_data = Event_Viewer_Data->raw_trace_data_first;
868 time_period = g_ptr_array_index(Event_Viewer_Data->time_period,
869 Event_Viewer_Data->current_period);
870 get_events(Event_Viewer_Data, time_period->start, time_period->end);
871 Event_Viewer_Data->start_event_number = time_period->start_event_number;
872
873 Event_Viewer_Data->raw_trace_data = Event_Viewer_Data->raw_trace_data_second;
874 time_period = g_ptr_array_index(Event_Viewer_Data->time_period,
875 Event_Viewer_Data->current_period + 1);
876 get_events(Event_Viewer_Data, time_period->start, time_period->end);
877 Event_Viewer_Data->end_event_number = time_period->end_event_number;
878
879 Event_Viewer_Data->raw_trace_data = Event_Viewer_Data->raw_trace_data_first;
880 }
881 }
882 //scroll down
883 else if(Event_Number+List_Height >= Event_Viewer_Data->end_event_number){
884 if(direction == SCROLL_DOWN_ONE_PERIOD){
885 //Event_Viewer_Data->current_period++;
886 Event_Viewer_Data->start_event_number += Event_Viewer_Data->raw_trace_data->len;
887 free_ptr_array(Event_Viewer_Data->raw_trace_data);
888 if(second_data == Event_Viewer_Data->raw_trace_data_first){
889 Event_Viewer_Data->raw_trace_data_second = g_ptr_array_sized_new(RESERVE_SIZE);
890 Event_Viewer_Data->raw_trace_data = Event_Viewer_Data->raw_trace_data_second;
891 }else{
892 Event_Viewer_Data->raw_trace_data_first = g_ptr_array_sized_new(RESERVE_SIZE);
893 Event_Viewer_Data->raw_trace_data = Event_Viewer_Data->raw_trace_data_first;
894 }
895
896 if(Event_Viewer_Data->current_period+1 == Event_Viewer_Data->time_period->len){
897 new_time_period = TRUE;
898 time_period = g_new(TimePeriod, 1);
899 raw_data = g_ptr_array_index(second_data,second_data->len-1);
900 time_period->start = raw_data->time;
901 time_period->start.tv_nsec++;
902 time_period->end.tv_sec = time_period->start.tv_sec + SECOND_INTERVAL;
903 time_period->end.tv_nsec = time_period->start.tv_nsec + NANOSECOND_INTERVAL;
904 time_period->start_event_number = Event_Viewer_Data->end_event_number + 1;
905 g_ptr_array_add(Event_Viewer_Data->time_period,time_period);
906 }
907
908 time_period = g_ptr_array_index(Event_Viewer_Data->time_period,
909 Event_Viewer_Data->current_period+1);
910
911 get_events(Event_Viewer_Data,time_period->start, time_period->end);
912 Event_Viewer_Data->end_event_number += Event_Viewer_Data->raw_trace_data->len;
913 if(new_time_period){
914 raw_data = g_ptr_array_index(Event_Viewer_Data->raw_trace_data,0);
915 time_period->start = raw_data->time;
916 raw_data = g_ptr_array_index(Event_Viewer_Data->raw_trace_data,
917 Event_Viewer_Data->raw_trace_data->len-1);
918 time_period->end = raw_data->time;
919 time_period->end_event_number = Event_Viewer_Data->end_event_number;
920 }
921 Event_Viewer_Data->raw_trace_data = second_data;
922
923 if(Event_Viewer_Data->end_event_number > Event_Viewer_Data->Number_Of_Events){
924 Event_Viewer_Data->Number_Of_Events = Event_Viewer_Data->end_event_number;
925 Event_Viewer_Data->VAdjust_C->upper = Event_Viewer_Data->Number_Of_Events;
926 }
927 }else{//direction = SCROLL_DOWN_MORE_PERIOD
928 free_ptr_array(second_data);
929 free_ptr_array(Event_Viewer_Data->raw_trace_data);
930 Event_Viewer_Data->raw_trace_data_first = g_ptr_array_sized_new(RESERVE_SIZE);
931 Event_Viewer_Data->raw_trace_data_second = g_ptr_array_sized_new(RESERVE_SIZE);
932
933 if(Event_Viewer_Data->current_period+1 == Event_Viewer_Data->time_period->len){
934 new_time_period = TRUE;
935 time_period = g_new(TimePeriod, 1);
936 time_period1 = g_ptr_array_index(Event_Viewer_Data->time_period,
937 Event_Viewer_Data->time_period->len-1);
938 time_period->start = time_period1->end;
939 time_period->start.tv_nsec++;
940 time_period->end.tv_sec = time_period->start.tv_sec + SECOND_INTERVAL;
941 time_period->end.tv_nsec = time_period->start.tv_nsec + NANOSECOND_INTERVAL;
942 time_period->start_event_number = time_period1->end_event_number + 1;
943 g_ptr_array_add(Event_Viewer_Data->time_period,time_period);
944 }
945
946 Event_Viewer_Data->raw_trace_data = Event_Viewer_Data->raw_trace_data_first;
947 time_period = g_ptr_array_index(Event_Viewer_Data->time_period,
948 Event_Viewer_Data->current_period);
949 get_events(Event_Viewer_Data,time_period->start, time_period->end);
950 Event_Viewer_Data->start_event_number = time_period->start_event_number;
951 Event_Viewer_Data->end_event_number = time_period->end_event_number;
952
953 Event_Viewer_Data->raw_trace_data = Event_Viewer_Data->raw_trace_data_second;
954 time_period = g_ptr_array_index(Event_Viewer_Data->time_period,
955 Event_Viewer_Data->current_period+1);
956 get_events(Event_Viewer_Data,time_period->start, time_period->end);
957 Event_Viewer_Data->end_event_number += Event_Viewer_Data->raw_trace_data->len;
958 if(new_time_period){
959 raw_data = g_ptr_array_index(Event_Viewer_Data->raw_trace_data,0);
960 time_period->start = raw_data->time;
961 raw_data = g_ptr_array_index(Event_Viewer_Data->raw_trace_data,
962 Event_Viewer_Data->raw_trace_data->len-1);
963 time_period->end = raw_data->time;
964 time_period->end_event_number = Event_Viewer_Data->end_event_number;
965 }
966 Event_Viewer_Data->raw_trace_data = Event_Viewer_Data->raw_trace_data_first;
967 }
968 }
969
970 second_data = Event_Viewer_Data->raw_trace_data == Event_Viewer_Data->raw_trace_data_first
971 ? Event_Viewer_Data->raw_trace_data_second : Event_Viewer_Data->raw_trace_data_first;
972
973 gtk_list_store_clear(Event_Viewer_Data->Store_M);
974 for(i=Event_Number; i<Event_Number+List_Height; i++)
975 {
976 guint64 real_data;
977
978 if(i>=Event_Viewer_Data->Number_Of_Events) break;
979
980 j = i - Event_Viewer_Data->start_event_number;
981
982 if(j < Event_Viewer_Data->raw_trace_data->len)
983 raw_data = g_ptr_array_index(Event_Viewer_Data->raw_trace_data, j);
984 else
985 raw_data = g_ptr_array_index(second_data, j - Event_Viewer_Data->raw_trace_data->len);
986
987 /* Add a new row to the model */
988 real_data = raw_data->time.tv_sec;
989 real_data *= 1000000000;
990 real_data += raw_data->time.tv_nsec;
991 gtk_list_store_append (Event_Viewer_Data->Store_M, &iter);
992 gtk_list_store_set (Event_Viewer_Data->Store_M, &iter,
993 CPUID_COLUMN, raw_data->cpu_id,
994 EVENT_COLUMN, raw_data->event_name,
995 TIME_COLUMN, real_data,
996 PID_COLUMN, raw_data->pid,
997 ENTRY_LEN_COLUMN, raw_data->entry_length,
998 EVENT_DESCR_COLUMN, raw_data->event_description,
999 -1);
1000 /*
1001 gtk_list_store_set (Event_Viewer_Data->Store_M, &iter,
1002 CPUID_COLUMN, 0,
1003 EVENT_COLUMN, "event irq",
1004 TIME_COLUMN, i,
1005 PID_COLUMN, 100,
1006 ENTRY_LEN_COLUMN, 17,
1007 EVENT_DESCR_COLUMN, "Detailed information",
1008 -1);
1009 */
1010 }
1011 }
1012 #ifdef DEBUG //do not use this, it's slower and broken
1013 // } else {
1014 /* Some events will be reused */
1015 if(Event_Number < Event_Viewer_Data->First_Event)
1016 {
1017 /* scrolling up, prepend events */
1018 Tree_Path = gtk_tree_path_new_from_indices
1019 (Event_Number+List_Height-1 -
1020 Event_Viewer_Data->First_Event + 1,
1021 -1);
1022 for(i=0; i<Event_Viewer_Data->Last_Event-(Event_Number+List_Height-1);
1023 i++)
1024 {
1025 /* Remove the last events from the list */
1026 if(gtk_tree_model_get_iter(model, &iter, Tree_Path))
1027 gtk_list_store_remove(Event_Viewer_Data->Store_M, &iter);
1028 }
1029
1030 for(i=Event_Viewer_Data->First_Event-1; i>=Event_Number; i--)
1031 {
1032 if(i>=Event_Viewer_Data->Number_Of_Events) break;
1033 /* Prepend new events */
1034 gtk_list_store_prepend (Event_Viewer_Data->Store_M, &iter);
1035 gtk_list_store_set (Event_Viewer_Data->Store_M, &iter,
1036 CPUID_COLUMN, 0,
1037 EVENT_COLUMN, "event irq",
1038 TIME_COLUMN, i,
1039 PID_COLUMN, 100,
1040 ENTRY_LEN_COLUMN, 17,
1041 EVENT_DESCR_COLUMN, "Detailed information",
1042 -1);
1043 }
1044 } else {
1045 /* Scrolling down, append events */
1046 for(i=Event_Viewer_Data->First_Event; i<Event_Number; i++)
1047 {
1048 /* Remove these events from the list */
1049 gtk_tree_model_get_iter_first(model, &iter);
1050 gtk_list_store_remove(Event_Viewer_Data->Store_M, &iter);
1051 }
1052 for(i=Event_Viewer_Data->Last_Event+1; i<Event_Number+List_Height; i++)
1053 {
1054 if(i>=Event_Viewer_Data->Number_Of_Events) break;
1055 /* Append new events */
1056 gtk_list_store_append (Event_Viewer_Data->Store_M, &iter);
1057 gtk_list_store_set (Event_Viewer_Data->Store_M, &iter,
1058 CPUID_COLUMN, 0,
1059 EVENT_COLUMN, "event irq",
1060 TIME_COLUMN, i,
1061 PID_COLUMN, 100,
1062 ENTRY_LEN_COLUMN, 17,
1063 EVENT_DESCR_COLUMN, "Detailed information",
1064 -1);
1065 }
1066
1067 }
1068 //}
1069 #endif //DEBUG
1070 Event_Viewer_Data->First_Event = Event_Number ;
1071 Event_Viewer_Data->Last_Event = Event_Number+List_Height-1 ;
1072
1073
1074
1075 }
1076
1077
1078 void add_test_data(EventViewerData *Event_Viewer_Data)
1079 {
1080 GtkTreeIter iter;
1081 int i;
1082
1083 for(i=0; i<10; i++)
1084 {
1085 /* Add a new row to the model */
1086 gtk_list_store_append (Event_Viewer_Data->Store_M, &iter);
1087 gtk_list_store_set (Event_Viewer_Data->Store_M, &iter,
1088 CPUID_COLUMN, 0,
1089 EVENT_COLUMN, "event irq",
1090 TIME_COLUMN, i,
1091 PID_COLUMN, 100,
1092 ENTRY_LEN_COLUMN, 17,
1093 EVENT_DESCR_COLUMN, "Detailed information",
1094 -1);
1095 }
1096
1097 }
1098
1099
1100 void
1101 GuiEvents_Destructor(EventViewerData *Event_Viewer_Data)
1102 {
1103 guint index;
1104
1105 /* May already been done by GTK window closing */
1106 if(GTK_IS_WIDGET(Event_Viewer_Data->HBox_V))
1107 gtk_widget_destroy(Event_Viewer_Data->HBox_V);
1108
1109 /* Destroy the Tree View */
1110 //gtk_widget_destroy(Event_Viewer_Data->Tree_V);
1111
1112 /* Clear raw event list */
1113 //gtk_list_store_clear(Event_Viewer_Data->Store_M);
1114 //gtk_widget_destroy(GTK_WIDGET(Event_Viewer_Data->Store_M));
1115
1116 g_slist_remove(sEvent_Viewer_Data_List,Event_Viewer_Data);
1117 g_free(Event_Viewer_Data);
1118 }
1119
1120 //FIXME : call hGuiEvents_Destructor for corresponding data upon widget destroy
1121
1122 static void
1123 tree_selection_changed_cb (GtkTreeSelection *selection, gpointer data)
1124 {
1125 EventViewerData *Event_Viewer_Data = (EventViewerData*)data;
1126 GtkTreeIter iter;
1127 GtkTreeModel *model = GTK_TREE_MODEL(Event_Viewer_Data->Store_M);
1128 gchar *Event;
1129
1130 if (gtk_tree_selection_get_selected (selection, &model, &iter))
1131 {
1132 gtk_tree_model_get (model, &iter, EVENT_COLUMN, &Event, -1);
1133
1134 g_print ("Event selected : %s\n", Event);
1135
1136 g_free (Event);
1137 }
1138 }
1139
1140
1141 int Event_Selected_Hook(void *hook_data, void *call_data)
1142 {
1143 EventViewerData *Event_Viewer_Data = (EventViewerData*) hook_data;
1144 guint *Event_Number = (guint*) call_data;
1145
1146 g_critical("DEBUG : event selected by main window : %u", *Event_Number);
1147
1148 Event_Viewer_Data->Currently_Selected_Event = *Event_Number;
1149 Event_Viewer_Data->Selected_Event = TRUE ;
1150
1151 Tree_V_set_cursor(Event_Viewer_Data);
1152
1153 }
1154
1155
1156 gboolean updateTimeInterval(void * hook_data, void * call_data)
1157 {
1158 EventViewerData *Event_Viewer_Data = (EventViewerData*) hook_data;
1159 Event_Viewer_Data->time_interval = *(TimeInterval*)call_data;
1160
1161 return FALSE;
1162 }
1163
1164 gboolean updateCurrentTime(void * hook_data, void * call_data)
1165 {
1166 EventViewerData *Event_Viewer_Data = (EventViewerData*) hook_data;
1167 Event_Viewer_Data->current_time = *(LttTime*)call_data;
1168 unsigned long nsec = Event_Viewer_Data->current_time.tv_sec * 1000000000
1169 + Event_Viewer_Data->current_time.tv_nsec;
1170 GtkTreeIter iter;
1171 unsigned long time;
1172 int count = 0;
1173 GtkTreeModel* model = (GtkTreeModel*)Event_Viewer_Data->Store_M;
1174
1175
1176 if(gtk_tree_model_get_iter_first(model, &iter)){
1177 while(1){
1178 gtk_tree_model_get(model, &iter, TIME_COLUMN, &time, -1);
1179 if(time < nsec){
1180 if(!gtk_tree_model_iter_next(model, &iter)){
1181 return TRUE;
1182 }
1183 count++;
1184 }else{
1185 break;
1186 }
1187 }
1188 // Event_Selected_Hook(Event_Viewer_Data, &count);
1189 }
1190
1191 return FALSE;
1192 }
1193
1194 void Tree_V_grab_focus(GtkWidget *widget, gpointer data){
1195 EventViewerData *Event_Viewer_Data = (EventViewerData *)data;
1196 mainWindow * mw = Event_Viewer_Data->mw;
1197 SetFocusedPane(mw, gtk_widget_get_parent(Event_Viewer_Data->HBox_V));
1198 }
1199
1200 void get_events(EventViewerData* Event_Viewer_Data, LttTime start, LttTime end)
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);
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.123262 seconds and 4 git commands to generate.