projects / lttv.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
git-svn-id: http://ltt.polymtl.ca/svn@222 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 "mw_api.h"
39 #include "gtktreeprivate.h"
40
41 #include "icons/hGuiEventsInsert.xpm"
42
43
44 /** Array containing instanced objects. Used when module is unloaded */
45 static GSList *sEvent_Viewer_Data_List = NULL ;
46
47
48 typedef struct _EventViewerData {
49
50 mainWindow * mw;
51 /* Model containing list data */
52 GtkListStore *Store_M;
53
54 GtkWidget *HBox_V;
55 /* Widget to display the data in a columned list */
56 GtkWidget *Tree_V;
57 GtkAdjustment *VTree_Adjust_C ;
58 GdkWindow *TreeWindow ;
59
60 /* Vertical scrollbar and it's adjustment */
61 GtkWidget *VScroll_VC;
62 GtkAdjustment *VAdjust_C ;
63
64 /* Selection handler */
65 GtkTreeSelection *Select_C;
66
67 guint Num_Visible_Events;
68 guint First_Event, Last_Event;
69
70 /* TEST DATA, TO BE READ FROM THE TRACE */
71 gint Number_Of_Events ;
72 guint Currently_Selected_Event ;
73 gboolean Selected_Event ;
74
75 } EventViewerData ;
76
77 //! Event Viewer's constructor hook
78 GtkWidget *hGuiEvents(mainWindow *pmParentWindow);
79 //! Event Viewer's constructor
80 EventViewerData *GuiEvents(mainWindow *pmParentWindow);
81 //! Event Viewer's destructor
82 void GuiEvents_Destructor(EventViewerData *Event_Viewer_Data);
83
84 static int Event_Selected_Hook(void *hook_data, void *call_data);
85
86 void Tree_V_set_cursor(EventViewerData *Event_Viewer_Data);
87 void Tree_V_get_cursor(EventViewerData *Event_Viewer_Data);
88
89 /* Prototype for selection handler callback */
90 static void tree_selection_changed_cb (GtkTreeSelection *selection, gpointer data);
91 static void v_scroll_cb (GtkAdjustment *adjustment, gpointer data);
92 static void Tree_V_size_allocate_cb (GtkWidget *widget, GtkAllocation *alloc, gpointer data);
93 static void Tree_V_size_request_cb (GtkWidget *widget, GtkRequisition *requisition, gpointer data);
94 static void Tree_V_cursor_changed_cb (GtkWidget *widget, gpointer data);
95 static void Tree_V_move_cursor_cb (GtkWidget *widget, GtkMovementStep arg1, gint arg2, gpointer data);
96
97
98
99 static void get_test_data(guint Event_Number, guint List_Height,
100 EventViewerData *Event_Viewer_Data);
101
102 void add_test_data(EventViewerData *Event_Viewer_Data);
103
104 /**
105 * plugin's init function
106 *
107 * This function initializes the Event Viewer functionnality through the
108 * gtkTraceSet API.
109 */
110 G_MODULE_EXPORT void init() {
111 g_critical("GUI Event Viewer init()");
112
113 /* Register the toolbar insert button */
114 ToolbarItemReg(hGuiEventsInsert_xpm, "Insert Event Viewer", hGuiEvents);
115
116 /* Register the menu item insert entry */
117 MenuItemReg("/", "Insert Event Viewer", hGuiEvents);
118 }
119
120 void destroy_walk(gpointer data, gpointer user_data)
121 {
122 GuiEvents_Destructor((EventViewerData*)data);
123 }
124
125 /**
126 * plugin's destroy function
127 *
128 * This function releases the memory reserved by the module and unregisters
129 * everything that has been registered in the gtkTraceSet API.
130 */
131 G_MODULE_EXPORT void destroy() {
132 int i;
133
134 EventViewerData *Event_Viewer_Data;
135
136 g_critical("GUI Event Viewer destroy()");
137
138 g_slist_foreach(sEvent_Viewer_Data_List, destroy_walk, NULL );
139
140 /* Unregister the toolbar insert button */
141 ToolbarItemUnreg(hGuiEvents);
142
143 /* Unregister the menu item insert entry */
144 MenuItemUnreg(hGuiEvents);
145 }
146
147 /* Enumeration of the columns */
148 enum
149 {
150 CPUID_COLUMN,
151 EVENT_COLUMN,
152 TIME_COLUMN,
153 PID_COLUMN,
154 ENTRY_LEN_COLUMN,
155 EVENT_DESCR_COLUMN,
156 N_COLUMNS
157 };
158
159
160 /**
161 * Event Viewer's constructor hook
162 *
163 * This constructor is given as a parameter to the menuitem and toolbar button
164 * registration. It creates the list.
165 * @param pmParentWindow A pointer to the parent window.
166 * @return The widget created.
167 */
168 GtkWidget *
169 hGuiEvents(mainWindow * pmParentWindow)
170 {
171 EventViewerData* Event_Viewer_Data = GuiEvents(pmParentWindow) ;
172
173 return Event_Viewer_Data->HBox_V ;
174
175 }
176
177 /**
178 * Event Viewer's constructor
179 *
180 * This constructor is used to create EventViewerData data structure.
181 * @return The Event viewer data created.
182 */
183 EventViewerData *
184 GuiEvents(mainWindow *pmParentWindow)
185 {
186 GtkTreeViewColumn *column;
187 GtkCellRenderer *renderer;
188 EventViewerData* Event_Viewer_Data = g_new(EventViewerData,1) ;
189
190 Event_Viewer_Data->mw = pmParentWindow;
191
192 /* TEST DATA, TO BE READ FROM THE TRACE */
193 Event_Viewer_Data->Number_Of_Events = 1000 ;
194 Event_Viewer_Data->Currently_Selected_Event = FALSE ;
195 Event_Viewer_Data->Selected_Event = 0;
196
197 /* FIXME register Event_Selected_Hook */
198
199 /* Create a model for storing the data list */
200 Event_Viewer_Data->Store_M = gtk_list_store_new (N_COLUMNS, /* Total number of columns */
201 G_TYPE_INT, /* CPUID */
202 G_TYPE_STRING, /* Event */
203 G_TYPE_INT, /* Time */
204 G_TYPE_INT, /* PID */
205 G_TYPE_INT, /* Entry length */
206 G_TYPE_STRING); /* Event's description */
207
208 /* Create the viewer widget for the columned list */
209 Event_Viewer_Data->Tree_V = gtk_tree_view_new_with_model (GTK_TREE_MODEL (Event_Viewer_Data->Store_M));
210
211 g_signal_connect (G_OBJECT (Event_Viewer_Data->Tree_V), "size-allocate",
212 G_CALLBACK (Tree_V_size_allocate_cb),
213 Event_Viewer_Data);
214 g_signal_connect (G_OBJECT (Event_Viewer_Data->Tree_V), "size-request",
215 G_CALLBACK (Tree_V_size_request_cb),
216 Event_Viewer_Data);
217
218 g_signal_connect (G_OBJECT (Event_Viewer_Data->Tree_V), "cursor-changed",
219 G_CALLBACK (Tree_V_cursor_changed_cb),
220 Event_Viewer_Data);
221
222 g_signal_connect (G_OBJECT (Event_Viewer_Data->Tree_V), "move-cursor",
223 G_CALLBACK (Tree_V_move_cursor_cb),
224 Event_Viewer_Data);
225 // Use on each column!
226 //gtk_tree_view_column_set_sizing(Event_Viewer_Data->Tree_V, GTK_TREE_VIEW_COLUMN_FIXED);
227
228 /* The view now holds a reference. We can get rid of our own
229 * reference */
230 g_object_unref (G_OBJECT (Event_Viewer_Data->Store_M));
231
232
233 /* Create a column, associating the "text" attribute of the
234 * cell_renderer to the first column of the model */
235 /* Columns alignment : 0.0 : Left 0.5 : Center 1.0 : Right */
236 renderer = gtk_cell_renderer_text_new ();
237 column = gtk_tree_view_column_new_with_attributes ("CPUID",
238 renderer,
239 "text", CPUID_COLUMN,
240 NULL);
241 gtk_tree_view_column_set_alignment (column, 0.0);
242 gtk_tree_view_column_set_fixed_width (column, 45);
243 gtk_tree_view_append_column (GTK_TREE_VIEW (Event_Viewer_Data->Tree_V), column);
244
245 renderer = gtk_cell_renderer_text_new ();
246 column = gtk_tree_view_column_new_with_attributes ("Event",
247 renderer,
248 "text", EVENT_COLUMN,
249 NULL);
250 gtk_tree_view_column_set_alignment (column, 0.0);
251 gtk_tree_view_column_set_fixed_width (column, 120);
252 gtk_tree_view_append_column (GTK_TREE_VIEW (Event_Viewer_Data->Tree_V), column);
253
254 renderer = gtk_cell_renderer_text_new ();
255 column = gtk_tree_view_column_new_with_attributes ("Time",
256 renderer,
257 "text", TIME_COLUMN,
258 NULL);
259 gtk_tree_view_column_set_alignment (column, 1.0);
260 gtk_tree_view_column_set_fixed_width (column, 120);
261 gtk_tree_view_append_column (GTK_TREE_VIEW (Event_Viewer_Data->Tree_V), column);
262
263 renderer = gtk_cell_renderer_text_new ();
264 column = gtk_tree_view_column_new_with_attributes ("PID",
265 renderer,
266 "text", PID_COLUMN,
267 NULL);
268 gtk_tree_view_column_set_alignment (column, 1.0);
269 gtk_tree_view_column_set_fixed_width (column, 45);
270 gtk_tree_view_append_column (GTK_TREE_VIEW (Event_Viewer_Data->Tree_V), column);
271
272 renderer = gtk_cell_renderer_text_new ();
273 column = gtk_tree_view_column_new_with_attributes ("Entry Length",
274 renderer,
275 "text", ENTRY_LEN_COLUMN,
276 NULL);
277 gtk_tree_view_column_set_alignment (column, 1.0);
278 gtk_tree_view_column_set_fixed_width (column, 60);
279 gtk_tree_view_append_column (GTK_TREE_VIEW (Event_Viewer_Data->Tree_V), column);
280
281 renderer = gtk_cell_renderer_text_new ();
282 column = gtk_tree_view_column_new_with_attributes ("Event's Description",
283 renderer,
284 "text", EVENT_DESCR_COLUMN,
285 NULL);
286 gtk_tree_view_column_set_alignment (column, 0.0);
287 gtk_tree_view_append_column (GTK_TREE_VIEW (Event_Viewer_Data->Tree_V), column);
288
289
290 /* Setup the selection handler */
291 Event_Viewer_Data->Select_C = gtk_tree_view_get_selection (GTK_TREE_VIEW (Event_Viewer_Data->Tree_V));
292 gtk_tree_selection_set_mode (Event_Viewer_Data->Select_C, GTK_SELECTION_SINGLE);
293 g_signal_connect (G_OBJECT (Event_Viewer_Data->Select_C), "changed",
294 G_CALLBACK (tree_selection_changed_cb),
295 Event_Viewer_Data);
296
297 Event_Viewer_Data->HBox_V = gtk_hbox_new(0, 0);
298 gtk_box_pack_start(GTK_BOX(Event_Viewer_Data->HBox_V), Event_Viewer_Data->Tree_V, TRUE, TRUE, 0);
299
300 /* Create vertical scrollbar and pack it */
301 Event_Viewer_Data->VScroll_VC = gtk_vscrollbar_new(NULL);
302 gtk_box_pack_start(GTK_BOX(Event_Viewer_Data->HBox_V), Event_Viewer_Data->VScroll_VC, FALSE, TRUE, 0);
303
304 /* Get the vertical scrollbar's adjustment */
305 Event_Viewer_Data->VAdjust_C = gtk_range_get_adjustment(GTK_RANGE(Event_Viewer_Data->VScroll_VC));
306 Event_Viewer_Data->VTree_Adjust_C = gtk_tree_view_get_vadjustment(
307 GTK_TREE_VIEW (Event_Viewer_Data->Tree_V));
308
309 g_signal_connect (G_OBJECT (Event_Viewer_Data->VAdjust_C), "value-changed",
310 G_CALLBACK (v_scroll_cb),
311 Event_Viewer_Data);
312 /* Set the upper bound to the last event number */
313 Event_Viewer_Data->VAdjust_C->lower = 0;
314 Event_Viewer_Data->VAdjust_C->upper = Event_Viewer_Data->Number_Of_Events;
315 Event_Viewer_Data->VAdjust_C->value = 0;
316 Event_Viewer_Data->VAdjust_C->step_increment = 1;
317 Event_Viewer_Data->VAdjust_C->page_increment =
318 Event_Viewer_Data->VTree_Adjust_C->upper;
319 Event_Viewer_Data->VAdjust_C->page_size =
320 Event_Viewer_Data->VTree_Adjust_C->upper;
321 g_critical("value : %u",Event_Viewer_Data->VTree_Adjust_C->upper);
322 /* Raw event trace */
323 gtk_widget_show(Event_Viewer_Data->HBox_V);
324 gtk_widget_show(Event_Viewer_Data->Tree_V);
325 gtk_widget_show(Event_Viewer_Data->VScroll_VC);
326
327 /* Add the object's information to the module's array */
328 sEvent_Viewer_Data_List = g_slist_append(sEvent_Viewer_Data_List, Event_Viewer_Data);
329
330 Event_Viewer_Data->First_Event = -1 ;
331 Event_Viewer_Data->Last_Event = 0 ;
332
333 Event_Viewer_Data->Num_Visible_Events = 1;
334
335 /* Test data */
336 get_test_data((int)Event_Viewer_Data->VAdjust_C->value,
337 Event_Viewer_Data->Num_Visible_Events,
338 Event_Viewer_Data);
339
340 /* Set the Selected Event */
341 Tree_V_set_cursor(Event_Viewer_Data);
342
343 return Event_Viewer_Data;
344 }
345
346 void Tree_V_set_cursor(EventViewerData *Event_Viewer_Data)
347 {
348 GtkTreePath *path;
349
350 if(Event_Viewer_Data->Selected_Event && Event_Viewer_Data->First_Event != -1)
351 {
352 gtk_adjustment_set_value(Event_Viewer_Data->VAdjust_C,
353 Event_Viewer_Data->Currently_Selected_Event);
354
355 path = gtk_tree_path_new_from_indices(
356 Event_Viewer_Data->Currently_Selected_Event-
357 Event_Viewer_Data->First_Event,
358 -1);
359
360 gtk_tree_view_set_cursor(GTK_TREE_VIEW(Event_Viewer_Data->Tree_V), path, NULL, FALSE);
361 gtk_tree_path_free(path);
362 }
363 }
364
365 void Tree_V_get_cursor(EventViewerData *Event_Viewer_Data)
366 {
367 GtkTreePath *path;
368 gint *indices;
369
370 gtk_tree_view_get_cursor(GTK_TREE_VIEW(Event_Viewer_Data->Tree_V), &path, NULL);
371 indices = gtk_tree_path_get_indices(path);
372
373 if(indices != NULL)
374 {
375 Event_Viewer_Data->Selected_Event = TRUE;
376 Event_Viewer_Data->Currently_Selected_Event =
377 Event_Viewer_Data->First_Event + indices[0];
378
379 } else {
380 Event_Viewer_Data->Selected_Event = FALSE;
381 Event_Viewer_Data->Currently_Selected_Event = 0;
382 }
383 g_critical("DEBUG : Event Selected : %i , num: %u", Event_Viewer_Data->Selected_Event, Event_Viewer_Data->Currently_Selected_Event) ;
384
385 gtk_tree_path_free(path);
386
387 }
388
389
390
391 void Tree_V_move_cursor_cb (GtkWidget *widget, GtkMovementStep arg1, gint arg2, gpointer data)
392 {
393 GtkTreePath *path; // = gtk_tree_path_new();
394 gint *indices;
395 gdouble value;
396 EventViewerData *Event_Viewer_Data = (EventViewerData*)data;
397
398 gtk_tree_view_get_cursor(GTK_TREE_VIEW(Event_Viewer_Data->Tree_V), &path, NULL);
399 if(path == NULL)
400 {
401 /* No prior cursor, put it at beginning of page and let the execution do */
402 path = gtk_tree_path_new_from_indices(0, -1);
403 gtk_tree_view_set_cursor(GTK_TREE_VIEW(Event_Viewer_Data->Tree_V), path, NULL, FALSE);
404 }
405
406 indices = gtk_tree_path_get_indices(path);
407
408 g_critical("DEBUG : move cursor step : %u , int : %i , indice : %i", (guint)arg1, arg2, indices[0]) ;
409
410 value = gtk_adjustment_get_value(Event_Viewer_Data->VAdjust_C);
411
412 if(arg1 == GTK_MOVEMENT_DISPLAY_LINES)
413 {
414 /* Move one line */
415 if(arg2 == 1)
416 {
417 /* move one line down */
418 if(indices[0] == Event_Viewer_Data->Num_Visible_Events - 1)
419 {
420 if(value + Event_Viewer_Data->Num_Visible_Events <=
421 Event_Viewer_Data->Number_Of_Events -1)
422 {
423 g_critical("need 1 event down") ;
424 Event_Viewer_Data->Currently_Selected_Event += 1;
425 gtk_adjustment_set_value(Event_Viewer_Data->VAdjust_C, value+1);
426 //gtk_tree_path_free(path);
427 //path = gtk_tree_path_new_from_indices(Event_Viewer_Data->Num_Visible_Events-1, -1);
428 //gtk_tree_view_set_cursor(GTK_TREE_VIEW(Event_Viewer_Data->Tree_V), path, NULL, FALSE);
429 g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
430 }
431 }
432 } else {
433 /* Move one line up */
434 if(indices[0] == 0)
435 {
436 if(value - 1 >= 0 )
437 {
438 g_critical("need 1 event up") ;
439 Event_Viewer_Data->Currently_Selected_Event -= 1;
440 gtk_adjustment_set_value(Event_Viewer_Data->VAdjust_C, value-1);
441 //gtk_tree_path_free(path);
442 //path = gtk_tree_path_new_from_indices(0, -1);
443 //gtk_tree_view_set_cursor(GTK_TREE_VIEW(Event_Viewer_Data->Tree_V), path, NULL, FALSE);
444 g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
445 }
446
447 }
448 }
449
450 }
451
452 if(arg1 == GTK_MOVEMENT_PAGES)
453 {
454 /* Move one page */
455 if(arg2 == 1)
456 {
457 if(Event_Viewer_Data->Num_Visible_Events == 1)
458 value += 1 ;
459 /* move one page down */
460 if(value + Event_Viewer_Data->Num_Visible_Events-1 <=
461 Event_Viewer_Data->Number_Of_Events )
462 {
463 g_critical("need 1 page down") ;
464
465 Event_Viewer_Data->Currently_Selected_Event += Event_Viewer_Data->Num_Visible_Events-1;
466 gtk_adjustment_set_value(Event_Viewer_Data->VAdjust_C,
467 value+(Event_Viewer_Data->Num_Visible_Events-1));
468 //gtk_tree_path_free(path);
469 //path = gtk_tree_path_new_from_indices(0, -1);
470 //gtk_tree_view_set_cursor(GTK_TREE_VIEW(Event_Viewer_Data->Tree_V), path, NULL, FALSE);
471 g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
472 }
473 } else {
474 /* Move one page up */
475 if(Event_Viewer_Data->Num_Visible_Events == 1)
476 value -= 1 ;
477
478 if(indices[0] < Event_Viewer_Data->Num_Visible_Events - 2 )
479 {
480 if(value - (Event_Viewer_Data->Num_Visible_Events-1) >= 0)
481 {
482 g_critical("need 1 page up") ;
483
484 Event_Viewer_Data->Currently_Selected_Event -= Event_Viewer_Data->Num_Visible_Events-1;
485
486 gtk_adjustment_set_value(Event_Viewer_Data->VAdjust_C,
487 value-(Event_Viewer_Data->Num_Visible_Events-1));
488 //gtk_tree_path_free(path);
489 //path = gtk_tree_path_new_from_indices(0, -1);
490 //gtk_tree_view_set_cursor(GTK_TREE_VIEW(Event_Viewer_Data->Tree_V), path, NULL, FALSE);
491 g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
492
493 } else {
494 /* Go to first Event */
495 g_critical("need 1 page up") ;
496
497 Event_Viewer_Data->Currently_Selected_Event == 0 ;
498 gtk_adjustment_set_value(Event_Viewer_Data->VAdjust_C,
499 0);
500 //gtk_tree_path_free(path);
501 //path = gtk_tree_path_new_from_indices(0, -1);
502 //gtk_tree_view_set_cursor(GTK_TREE_VIEW(Event_Viewer_Data->Tree_V), path, NULL, FALSE);
503 g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
504
505 }
506 }
507
508 }
509
510 }
511
512 if(arg1 == GTK_MOVEMENT_BUFFER_ENDS)
513 {
514 /* Move to the ends of the buffer */
515 if(arg2 == 1)
516 {
517 /* move end of buffer */
518 g_critical("End of buffer") ;
519 Event_Viewer_Data->Currently_Selected_Event = Event_Viewer_Data->Number_Of_Events-1 ;
520 gtk_adjustment_set_value(Event_Viewer_Data->VAdjust_C,
521 Event_Viewer_Data->Number_Of_Events -
522 Event_Viewer_Data->Num_Visible_Events);
523 //gtk_tree_path_free(path);
524 //path = gtk_tree_path_new_from_indices(Event_Viewer_Data->Num_Visible_Events-1, -1);
525 //gtk_tree_view_set_cursor(GTK_TREE_VIEW(Event_Viewer_Data->Tree_V), path, NULL, FALSE);
526 g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
527 } else {
528 /* Move beginning of buffer */
529 g_critical("Beginning of buffer") ;
530 Event_Viewer_Data->Currently_Selected_Event = 0 ;
531 gtk_adjustment_set_value(Event_Viewer_Data->VAdjust_C, 0);
532 //gtk_tree_path_free(path);
533 //path = gtk_tree_path_new_from_indices(0, -1);
534 //gtk_tree_view_set_cursor(GTK_TREE_VIEW(Event_Viewer_Data->Tree_V), path, NULL, FALSE);
535 g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
536 }
537
538 }
539
540
541 gtk_tree_path_free(path);
542 }
543
544 void Tree_V_cursor_changed_cb (GtkWidget *widget, gpointer data)
545 {
546 EventViewerData *Event_Viewer_Data = (EventViewerData*) data;
547
548 g_critical("DEBUG : cursor change");
549 /* On cursor change, modify the currently selected event by calling
550 * the right API function */
551 Tree_V_get_cursor(Event_Viewer_Data);
552 }
553
554
555 void v_scroll_cb (GtkAdjustment *adjustment, gpointer data)
556 {
557 EventViewerData *Event_Viewer_Data = (EventViewerData*)data;
558 GtkTreePath *Tree_Path;
559
560 g_critical("DEBUG : scroll signal, value : %f", adjustment->value);
561
562 get_test_data((int)adjustment->value, Event_Viewer_Data->Num_Visible_Events,
563 Event_Viewer_Data);
564
565
566 if(Event_Viewer_Data->Currently_Selected_Event
567 >= Event_Viewer_Data->First_Event
568 &&
569 Event_Viewer_Data->Currently_Selected_Event
570 <= Event_Viewer_Data->Last_Event
571 &&
572 Event_Viewer_Data->Selected_Event)
573 {
574
575 Tree_Path = gtk_tree_path_new_from_indices(
576 Event_Viewer_Data->Currently_Selected_Event-
577 Event_Viewer_Data->First_Event,
578 -1);
579
580 gtk_tree_view_set_cursor(GTK_TREE_VIEW(Event_Viewer_Data->Tree_V), Tree_Path,
581 NULL, FALSE);
582 gtk_tree_path_free(Tree_Path);
583 }
584
585
586 }
587
588 gint get_cell_height(GtkTreeView *TreeView)
589 {
590 gint height, width;
591 GtkTreeViewColumn *Column = gtk_tree_view_get_column(TreeView, 0);
592 GList *Render_List = gtk_tree_view_column_get_cell_renderers(Column);
593 GtkCellRenderer *Renderer = g_list_first(Render_List)->data;
594
595 gtk_tree_view_column_cell_get_size(Column, NULL, NULL, NULL, NULL, &height);
596 g_critical("cell 0 height : %u",height);
597
598 return height;
599 }
600
601 void Tree_V_size_allocate_cb (GtkWidget *widget, GtkAllocation *alloc, gpointer data)
602 {
603 EventViewerData *Event_Viewer_Data = (EventViewerData*)data;
604 gint Cell_Height = get_cell_height(GTK_TREE_VIEW(Event_Viewer_Data->Tree_V));
605 gint Last_Num_Visible_Events = Event_Viewer_Data->Num_Visible_Events;
606 gdouble Exact_Num_Visible;
607
608 g_critical("size-allocate");
609
610 Exact_Num_Visible = ( alloc->height -
611 TREE_VIEW_HEADER_HEIGHT (GTK_TREE_VIEW(Event_Viewer_Data->Tree_V)) )
612 / (double)Cell_Height ;
613
614 Event_Viewer_Data->Num_Visible_Events = ceil(Exact_Num_Visible) ;
615
616 g_critical("number of events shown : %u",Event_Viewer_Data->Num_Visible_Events);
617 g_critical("ex number of events shown : %f",Exact_Num_Visible);
618
619 Event_Viewer_Data->VAdjust_C->page_increment =
620 floor(Exact_Num_Visible);
621 Event_Viewer_Data->VAdjust_C->page_size =
622 floor(Exact_Num_Visible);
623
624 if(Event_Viewer_Data->Num_Visible_Events != Last_Num_Visible_Events)
625 {
626 get_test_data((int)Event_Viewer_Data->VAdjust_C->value,
627 Event_Viewer_Data->Num_Visible_Events,
628 Event_Viewer_Data);
629 }
630
631
632 }
633
634 void Tree_V_size_request_cb (GtkWidget *widget, GtkRequisition *requisition, gpointer data)
635 {
636 gint h;
637 EventViewerData *Event_Viewer_Data = (EventViewerData*)data;
638 gint Cell_Height = get_cell_height(GTK_TREE_VIEW(Event_Viewer_Data->Tree_V));
639
640 g_critical("size-request");
641
642 h = Cell_Height + TREE_VIEW_HEADER_HEIGHT
643 (GTK_TREE_VIEW(Event_Viewer_Data->Tree_V));
644 requisition->height = h;
645
646 }
647
648 void get_test_data(guint Event_Number, guint List_Height,
649 EventViewerData *Event_Viewer_Data)
650 {
651 GtkTreeIter iter;
652 int i;
653 GtkTreeModel *model = GTK_TREE_MODEL(Event_Viewer_Data->Store_M);
654 GtkTreePath *Tree_Path;
655 gchar *test_string;
656
657 // if(Event_Number > Event_Viewer_Data->Last_Event ||
658 // Event_Number + List_Height-1 < Event_Viewer_Data->First_Event ||
659 // Event_Viewer_Data->First_Event == -1)
660 {
661 /* no event can be reused, clear and start from nothing */
662 gtk_list_store_clear(Event_Viewer_Data->Store_M);
663 for(i=Event_Number; i<Event_Number+List_Height; i++)
664 {
665 if(i>=Event_Viewer_Data->Number_Of_Events) break;
666 /* Add a new row to the model */
667 gtk_list_store_append (Event_Viewer_Data->Store_M, &iter);
668 gtk_list_store_set (Event_Viewer_Data->Store_M, &iter,
669 CPUID_COLUMN, 0,
670 EVENT_COLUMN, "event irq",
671 TIME_COLUMN, i,
672 PID_COLUMN, 100,
673 ENTRY_LEN_COLUMN, 17,
674 EVENT_DESCR_COLUMN, "Detailed information",
675 -1);
676 }
677 }
678 #ifdef DEBUG //do not use this, it's slower and broken
679 // } else {
680 /* Some events will be reused */
681 if(Event_Number < Event_Viewer_Data->First_Event)
682 {
683 /* scrolling up, prepend events */
684 Tree_Path = gtk_tree_path_new_from_indices
685 (Event_Number+List_Height-1 -
686 Event_Viewer_Data->First_Event + 1,
687 -1);
688 for(i=0; i<Event_Viewer_Data->Last_Event-(Event_Number+List_Height-1);
689 i++)
690 {
691 /* Remove the last events from the list */
692 if(gtk_tree_model_get_iter(model, &iter, Tree_Path))
693 gtk_list_store_remove(Event_Viewer_Data->Store_M, &iter);
694 }
695
696 for(i=Event_Viewer_Data->First_Event-1; i>=Event_Number; i--)
697 {
698 if(i>=Event_Viewer_Data->Number_Of_Events) break;
699 /* Prepend new events */
700 gtk_list_store_prepend (Event_Viewer_Data->Store_M, &iter);
701 gtk_list_store_set (Event_Viewer_Data->Store_M, &iter,
702 CPUID_COLUMN, 0,
703 EVENT_COLUMN, "event irq",
704 TIME_COLUMN, i,
705 PID_COLUMN, 100,
706 ENTRY_LEN_COLUMN, 17,
707 EVENT_DESCR_COLUMN, "Detailed information",
708 -1);
709 }
710 } else {
711 /* Scrolling down, append events */
712 for(i=Event_Viewer_Data->First_Event; i<Event_Number; i++)
713 {
714 /* Remove these events from the list */
715 gtk_tree_model_get_iter_first(model, &iter);
716 gtk_list_store_remove(Event_Viewer_Data->Store_M, &iter);
717 }
718 for(i=Event_Viewer_Data->Last_Event+1; i<Event_Number+List_Height; i++)
719 {
720 if(i>=Event_Viewer_Data->Number_Of_Events) break;
721 /* Append new events */
722 gtk_list_store_append (Event_Viewer_Data->Store_M, &iter);
723 gtk_list_store_set (Event_Viewer_Data->Store_M, &iter,
724 CPUID_COLUMN, 0,
725 EVENT_COLUMN, "event irq",
726 TIME_COLUMN, i,
727 PID_COLUMN, 100,
728 ENTRY_LEN_COLUMN, 17,
729 EVENT_DESCR_COLUMN, "Detailed information",
730 -1);
731 }
732
733 }
734 }
735 #endif //DEBUG
736 Event_Viewer_Data->First_Event = Event_Number ;
737 Event_Viewer_Data->Last_Event = Event_Number+List_Height-1 ;
738
739
740
741 }
742
743
744 void add_test_data(EventViewerData *Event_Viewer_Data)
745 {
746 GtkTreeIter iter;
747 int i;
748
749 for(i=0; i<10; i++)
750 {
751 /* Add a new row to the model */
752 gtk_list_store_append (Event_Viewer_Data->Store_M, &iter);
753 gtk_list_store_set (Event_Viewer_Data->Store_M, &iter,
754 CPUID_COLUMN, 0,
755 EVENT_COLUMN, "event irq",
756 TIME_COLUMN, i,
757 PID_COLUMN, 100,
758 ENTRY_LEN_COLUMN, 17,
759 EVENT_DESCR_COLUMN, "Detailed information",
760 -1);
761 }
762
763 }
764
765
766 void
767 GuiEvents_Destructor(EventViewerData *Event_Viewer_Data)
768 {
769 guint index;
770
771 /* May already been done by GTK window closing */
772 if(GTK_IS_WIDGET(Event_Viewer_Data->HBox_V))
773 gtk_widget_destroy(Event_Viewer_Data->HBox_V);
774
775 /* Destroy the Tree View */
776 //gtk_widget_destroy(Event_Viewer_Data->Tree_V);
777
778 /* Clear raw event list */
779 //gtk_list_store_clear(Event_Viewer_Data->Store_M);
780 //gtk_widget_destroy(GTK_WIDGET(Event_Viewer_Data->Store_M));
781
782 g_slist_remove(sEvent_Viewer_Data_List,Event_Viewer_Data);
783 g_free(Event_Viewer_Data);
784 }
785
786 //FIXME : call hGuiEvents_Destructor for corresponding data upon widget destroy
787
788 static void
789 tree_selection_changed_cb (GtkTreeSelection *selection, gpointer data)
790 {
791 EventViewerData *Event_Viewer_Data = (EventViewerData*)data;
792 GtkTreeIter iter;
793 GtkTreeModel *model = GTK_TREE_MODEL(Event_Viewer_Data->Store_M);
794 gchar *Event;
795
796 if (gtk_tree_selection_get_selected (selection, &model, &iter))
797 {
798 gtk_tree_model_get (model, &iter, EVENT_COLUMN, &Event, -1);
799
800 g_print ("Event selected : %s\n", Event);
801
802 g_free (Event);
803 }
804 }
805
806
807 /* it will be registered and called by the main window */
808 int Event_Selected_Hook(void *hook_data, void *call_data)
809 {
810 EventViewerData *Event_Viewer_Data = (EventViewerData*) hook_data;
811 guint *Event_Number = (guint*) call_data;
812
813 g_critical("DEBUG : event selected by main window : %u", *Event_Number);
814
815 Event_Viewer_Data->Currently_Selected_Event = *Event_Number;
816 Event_Viewer_Data->Selected_Event = TRUE ;
817
818 Tree_V_set_cursor(Event_Viewer_Data);
819
820 }
821
822
823
824
825
826
827
828 /* Imported code from LTT 0.9.6pre2 tracevisualizer */
829 #ifdef DEBUG
830
831 /******************************************************************
832 * Function :
833 * WDI_gtk_clist_set_last_row_data_full()
834 * Description :
835 * Appends data to the last row of a GtkClist.
836 * Parameters :
837 * Return values :
838 * NONE.
839 * History :
840 * J.H.D., 27/08/99, Initial typing.
841 * Note :
842 * Based on gtk_clist_set_row_data_full() version 1.2.3.
843 * Much faster than using gtk_clist_set_row_data_full().
844 ******************************************************************/
845 static void WDI_gtk_clist_set_last_row_data_full(GtkCList* pmClist,
846 gpointer pmData,
847 GtkDestroyNotify pmDestroy)
848 {
849 GtkCListRow *pClistRow;
850
851 g_return_if_fail (pmClist != NULL);
852 g_return_if_fail (GTK_IS_CLIST (pmClist));
853 g_return_if_fail (pmClist->row_list_end != NULL);
854
855 pClistRow = pmClist->row_list_end->data;
856 pClistRow->data = pmData;
857 pClistRow->destroy = pmDestroy;
858 }
859
860
861 /******************************************************************
862 * Function :
863 * SHRTEventSelect()
864 * Description :
865 * Parameters :
866 * Return values :
867 * History :
868 * Note :
869 ******************************************************************/
870 static void SHRTEventSelect(GtkWidget* pmCList,
871 gint pmRow,
872 gint pmColumn,
873 GdkEventButton* pmEvent,
874 gpointer pmData)
875 {
876 systemView* pSysView; /* The system being displayed */
877
878 /* Do we have anything meaningfull */
879 if((pSysView = (systemView*) pmData) == NULL)
880 return;
881
882 /* Store the selected event */
883 pSysView->Window->LastSelectedEvent = *(event*) gtk_clist_get_row_data(GTK_CLIST(pmCList), pmRow);
884 pSysView->Window->EventSelected = TRUE;
885 }
886
887 /******************************************************************
888 * Function :
889 * SHRTEventButtonPress()
890 * Description :
891 * Parameters :
892 * Return values :
893 * History :
894 * Note :
895 ******************************************************************/
896 static void SHRTEventButtonPress(GtkWidget* pmCList,
897 GdkEventButton* pmEvent,
898 gpointer pmData)
899 {
900 systemView* pSysView; /* The system being displayed */
901 gint row, column; /* The clicked row and column */
902
903 /* Do we have anything meaningfull */
904 if((pSysView = (systemView*) pmData) == NULL)
905 return;
906
907 /* if we have a right-click event */
908 if(pmEvent->button == 3)
909 /* If we clicked on an item, get its row and column values */
910 if(gtk_clist_get_selection_info(GTK_CLIST(pmCList), pmEvent->x, pmEvent->y, &row, &column))
911 {
912 /* Highlight the selected row */
913 gtk_clist_select_row(GTK_CLIST(pmCList), row, column);
914
915 /* Store the selected event */
916 pSysView->Window->LastSelectedEvent = *(event*) gtk_clist_get_row_data(GTK_CLIST(pmCList), row);
917 pSysView->Window->EventSelected = TRUE;
918
919 /* Display the popup menu */
920 gtk_menu_popup(GTK_MENU(pSysView->Window->RawEventPopup),
921 NULL, NULL, NULL, NULL,
922 pmEvent->button, GDK_CURRENT_TIME);
923 }
924 }
925
926
927 /******************************************************************
928 * Function :
929 * SHRTVAdjustValueChanged()
930 * Description :
931 * Parameters :
932 * Return values :
933 * History :
934 * Note :
935 ******************************************************************/
936 static void SHRTVAdjustValueChanged(GtkAdjustment* pmVAdjust,
937 gpointer pmData)
938 {
939 event lEvent; /* Event used for searching */
940 guint32 lPosition; /* The position to scroll to */
941 systemView* pSysView; /* The system being displayed */
942
943 /* Do we have anything meaningfull */
944 if((pSysView = (systemView*) pmData) == NULL)
945 return;
946
947 /* Is there an event database? */
948 if(pSysView->EventDB == NULL)
949 return;
950
951 /* Set the pointer to the first event */
952 if(pSysView->EventDB->TraceStart == NULL)
953 return;
954
955 /* Are we closer to the beginning? */
956 if((pmVAdjust->value - (pmVAdjust->upper / 2)) < 0)
957 {
958 /* Set the navigation pointer to the beginning of the list */
959 lEvent = pSysView->EventDB->FirstEvent;
960
961 /* Calculate distance from beginning */
962 lPosition = (guint32) pmVAdjust->value;
963
964 /* Find the event in the event database */
965 while(lPosition > 0)
966 {
967 lPosition--;
968 if(DBEventNext(pSysView->EventDB, &lEvent) != TRUE)
969 break;
970 }
971 }
972 else
973 {
974 /* Set the navigation pointer to the end of the list */
975 lEvent = pSysView->EventDB->LastEvent;
976
977 /* Calculate distance from end */
978 lPosition = (guint32) (pmVAdjust->upper - pmVAdjust->value);
979
980 /* Find the event in the event database */
981 while(lPosition > 0)
982 {
983 lPosition--;
984 if(DBEventPrev(pSysView->EventDB, &lEvent) != TRUE)
985 break;
986 }
987 }
988
989 /* Fill the event list according to what was found */
990 WDFillEventList(pSysView->Window->RTCList,
991 pSysView->EventDB,
992 pSysView->System,
993 &lEvent,
994 &(pSysView->Window->LastSelectedEvent));
995 }
996
997
998
999 /******************************************************************
1000 * Function :
1001 * WDConnectSignals()
1002 * Description :
1003 * Attaches signal handlers to the window items.
1004 * Parameters :
1005 * pmSysView, System view for which signals have to be connected
1006 * Return values :
1007 * NONE
1008 * History :
1009 * Note :
1010 * This function attaches a pointer to the main window during
1011 * the connect. This means that the handlers will get a pointer
1012 * to the window in the data argument.
1013 ******************************************************************/
1014 static void WDConnectSignals(systemView* pmSysView)
1015 {
1016 /* Raw event Popup menu */
1017 gtk_signal_connect(GTK_OBJECT(pmSysView->Window->RawGotoProcess),
1018 "activate",
1019 GTK_SIGNAL_FUNC(SHGotoProcAnalysis),
1020 pmSysView);
1021 gtk_signal_connect(GTK_OBJECT(pmSysView->Window->RawViewEvent),
1022 "activate",
1023 GTK_SIGNAL_FUNC(SHViewEventInEG),
1024 pmSysView);
1025
1026 /* Set event list callbacks */
1027 gtk_signal_connect(GTK_OBJECT(pmSysView->Window->RTCList),
1028 "select_row",
1029 GTK_SIGNAL_FUNC(SHRTEventSelect),
1030 pmSysView);
1031 gtk_signal_connect(GTK_OBJECT(pmSysView->Window->RTCList),
1032 "button-press-event",
1033 GTK_SIGNAL_FUNC(SHRTEventButtonPress),
1034 pmSysView);
1035 gtk_signal_connect(GTK_OBJECT(pmSysView->Window->RTVAdjust),
1036 "value-changed",
1037 GTK_SIGNAL_FUNC(SHRTVAdjustValueChanged),
1038 pmSysView);
1039
1040
1041 }
1042
1043
1044 /******************************************************************
1045 * Function :
1046 * WDFillEventList()
1047 * Description :
1048 * Fills the window's event list using the trace database.
1049 * Parameters :
1050 * pmList, The list to be filled.
1051 * pmTraceDB, The database of events.
1052 * pmSystem, The system to which this list belongs.
1053 * pmEvent, Event from which we start drawing.
1054 * pmSelectedEvent, Event selected if any.
1055 * Return values :
1056 * NONE.
1057 * History :
1058 * K.Y., 18/06/99, Initial typing.
1059 * Note :
1060 ******************************************************************/
1061 static void WDFillEventList(GtkWidget* pmList,
1062 db* pmTraceDB,
1063 systemInfo* pmSystem,
1064 event* pmEvent,
1065 event* pmSelectedEvent)
1066 {
1067 gint i = 0; /* Generic index */
1068 event lEvent; /* Generic event */
1069 gchar lTimeStr[TIME_STR_LEN]; /* Time of event */
1070 static gchar* lString[RTCLIST_NB_COLUMNS]={'\0'}; /* Strings describing event */
1071 process* pProcess; /* Generic process pointer */
1072 #if SUPP_RTAI
1073 RTAItask* pTask = NULL; /* Generic task pointer */
1074 #endif /* SUPP_RTAI */
1075 eventDescription lEventDesc; /* Description of event */
1076
1077 /* Did we allocate space for strings */
1078 if(lString[0] == NULL)
1079 /* Allocate space for strings */
1080 for (i = 0; i < RTCLIST_NB_COLUMNS - 1; i++)
1081 lString[i] = (char*) g_malloc(MW_DEFAULT_STRLEN);
1082
1083 /* Allocate space for description string */
1084 lString[RTCLIST_NB_COLUMNS - 1] = (char*) g_malloc(MW_LONG_STRLEN);
1085
1086 /* If no event was supplied, start at the beginning */
1087 if(pmEvent == NULL)
1088 lEvent = pmTraceDB->FirstEvent;
1089 else
1090 lEvent = *pmEvent;
1091
1092 /* Freeze and clear clist */
1093 gtk_clist_freeze(GTK_CLIST(pmList));
1094 gtk_clist_clear(GTK_CLIST(pmList));
1095
1096 /* Reset index */
1097 i = 0;
1098
1099 /* Go through the event list */
1100 do
1101 {
1102 /* Get the event description */
1103 DBEventDescription(pmTraceDB, &lEvent, TRUE, &lEventDesc);
1104
1105 /* Get the event's process */
1106 pProcess = DBEventProcess(pmTraceDB, &lEvent, pmSystem, FALSE);
1107
1108 #if SUPP_RTAI
1109 /* Does this trace contain RTAI information */
1110 if(pmTraceDB->SystemType == TRACE_SYS_TYPE_RTAI_LINUX)
1111 /* Get the RTAI task to which this event belongs */
1112 pTask = RTAIDBEventTask(pmTraceDB, &lEvent, pmSystem, FALSE);
1113 #endif /* SUPP_RTAI */
1114
1115 /* Set the event's entry in the list of raw events displayed */
1116 sRawEventsDisplayed[i] = lEvent;
1117
1118 /* Add text describing the event */
1119 /* The CPU ID */
1120 if(pmTraceDB->LogCPUID == TRUE)
1121 snprintf(lString[0], MW_DEFAULT_STRLEN, "%d", lEventDesc.CPUID);
1122 else
1123 snprintf(lString[0], MW_DEFAULT_STRLEN, "0");
1124
1125 /* The event ID */
1126 snprintf(lString[1], MW_DEFAULT_STRLEN, "%s", pmTraceDB->EventString(pmTraceDB, lEventDesc.ID, &lEvent));
1127
1128 /* The event's time of occurence */
1129 DBFormatTimeInReadableString(lTimeStr,
1130 lEventDesc.Time.tv_sec,
1131 lEventDesc.Time.tv_usec);
1132 snprintf(lString[2], MW_DEFAULT_STRLEN, "%s", lTimeStr);
1133
1134 /* Is this an RT event */
1135 if(lEventDesc.ID <= TRACE_MAX)
1136 {
1137 /* The PID of the process to which the event belongs */
1138 if(pProcess != NULL)
1139 snprintf(lString[3], MW_DEFAULT_STRLEN, "%d", pProcess->PID);
1140 else
1141 snprintf(lString[3], MW_DEFAULT_STRLEN, "N/A");
1142 }
1143 #if SUPP_RTAI
1144 else
1145 {
1146 /* The TID of the task to which the event belongs */
1147 if(pTask != NULL)
1148 snprintf(lString[3], MW_DEFAULT_STRLEN, "RT:%d", pTask->TID);
1149 else
1150 snprintf(lString[3], MW_DEFAULT_STRLEN, "RT:N/A");
1151 }
1152 #endif /* SUPP_RTAI */
1153
1154 /* The size of the entry */
1155 snprintf(lString[4], MW_DEFAULT_STRLEN, "%d", lEventDesc.Size);
1156
1157 /* The string describing the event */
1158 snprintf(lString[5], MW_LONG_STRLEN, "%s", lEventDesc.String);
1159
1160 /* Insert the entry into the list */
1161 gtk_clist_append(GTK_CLIST(pmList), lString);
1162
1163 /* Set the row's data to point to the current event */
1164 WDI_gtk_clist_set_last_row_data_full(GTK_CLIST(pmList), (gpointer) &(sRawEventsDisplayed[i]), NULL);
1165
1166 /* Was this the last selected event */
1167 if(DBEventsEqual(lEvent, (*pmSelectedEvent)))
1168 gtk_clist_select_row(GTK_CLIST(pmList), i, 0);
1169
1170 /* Go to next row */
1171 i++;
1172 } while((DBEventNext(pmTraceDB, &lEvent) == TRUE) && (i < RTCLIST_NB_ROWS));
1173
1174 /* Resize the list's length */
1175 gtk_widget_queue_resize(pmList);
1176
1177 /* Thaw the clist */
1178 gtk_clist_thaw(GTK_CLIST(pmList));
1179 }
1180
1181 #endif //DEBUG
1182
1183 static void destroy_cb( GtkWidget *widget,
1184 gpointer data )
1185 {
1186 gtk_main_quit ();
1187 }
1188
1189
1190 /*
1191 int main(int argc, char **argv)
1192 {
1193 GtkWidget *Window;
1194 GtkWidget *ListViewer;
1195 GtkWidget *VBox_V;
1196 EventViewerData *Event_Viewer_Data;
1197 guint ev_sel = 444 ;
1198
1199 // Initialize i18n support
1200 gtk_set_locale ();
1201
1202 // Initialize the widget set
1203 gtk_init (&argc, &argv);
1204
1205 init();
1206
1207 Window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1208 gtk_window_set_title (GTK_WINDOW (Window), ("Test Window"));
1209
1210 g_signal_connect (G_OBJECT (Window), "destroy",
1211 G_CALLBACK (destroy_cb), NULL);
1212
1213
1214 VBox_V = gtk_vbox_new(0, 0);
1215 gtk_container_add (GTK_CONTAINER (Window), VBox_V);
1216
1217 //ListViewer = hGuiEvents(Window);
1218 //gtk_box_pack_start(GTK_BOX(VBox_V), ListViewer, TRUE, TRUE, 0);
1219
1220 //ListViewer = hGuiEvents(Window);
1221 //gtk_box_pack_start(GTK_BOX(VBox_V), ListViewer, FALSE, TRUE, 0);
1222
1223 Event_Viewer_Data = GuiEvents(g_new(mainWindow,1));
1224 ListViewer = Event_Viewer_Data->HBox_V;
1225 gtk_box_pack_start(GTK_BOX(VBox_V), ListViewer, TRUE, TRUE, 0);
1226
1227 gtk_widget_show (VBox_V);
1228 gtk_widget_show (Window);
1229
1230 // Event_Selected_Hook(Event_Viewer_Data, &ev_sel);
1231
1232 gtk_main ();
1233
1234 g_critical("main loop finished");
1235
1236 //hGuiEvents_Destructor(ListViewer);
1237
1238 //g_critical("GuiEvents Destructor finished");
1239 destroy();
1240
1241 return 0;
1242 }
1243 */
1244
1245 /*\@}*/
1246
LTTng 2.x Viewer (LTTV)
This page took 0.063106 seconds and 5 git commands to generate.