projects / lttv.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
git-svn-id: http://ltt.polymtl.ca/svn@222 04897980-b3bd-0310-b5e0-8ef037075253
[lttv.git] / ltt / branches / poly / lttv / modules / guiEvents.c
CommitLineData
fbbb2697 1//*! \defgroup GuiEvents libGuiEvents: The GUI Events display plugin */
5c7463ed 2/*\@{*/
3
fbbb2697 4/*! \file GuiEvents.c
5c7463ed 5 * \brief Graphical plugin for showing events.
6 *
17abcce3 7 * This plugin lists all the events contained in the current time interval
8 * in a list.
9 *
5c7463ed 10 * This plugin adds a Events Viewer functionnality to Linux TraceToolkit
11 * GUI when this plugin is loaded. The init and destroy functions add the
12 * viewer's insertion menu item and toolbar icon by calling gtkTraceSet's
13 * API functions. Then, when a viewer's object is created, the constructor
14 * creates ans register through API functions what is needed to interact
15 * with the TraceSet window.
16 *
fbbb2697 17 * Coding standard :
18 * pm : parameter
19 * l : local
20 * g : global
21 * s : static
22 * h : hook
23 *
fcdf0ec2 24 * Author : Karim Yaghmour
25 * Integrated to LTTng by Mathieu Desnoyers, June 2003
5c7463ed 26 */
27
b26121f4 28#include <math.h>
29
5c7463ed 30#include <glib.h>
31#include <gmodule.h>
fbbb2697 32#include <gtk/gtk.h>
33#include <gdk/gdk.h>
5c7463ed 34
35#include <lttv/module.h>
682c6edb 36#include <lttv/hook.h>
d1ebdadd 37#include <lttv/gtkTraceSet.h>
38//#include "mw_api.h"
6601bf27 39#include "gtktreeprivate.h"
5c7463ed 40
fbbb2697 41#include "icons/hGuiEventsInsert.xpm"
5c7463ed 42
e921c965 43
fcdf0ec2 44/** Array containing instanced objects. Used when module is unloaded */
fbbb2697 45static GSList *sEvent_Viewer_Data_List = NULL ;
46
e921c965 47
fbbb2697 48typedef struct _EventViewerData {
49
e921c965 50 mainWindow * mw;
fbbb2697 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 ;
b26121f4 59
fbbb2697 60 /* Vertical scrollbar and it's adjustment */
61 GtkWidget *VScroll_VC;
62 GtkAdjustment *VAdjust_C ;
63
64 /* Selection handler */
65 GtkTreeSelection *Select_C;
66
b26121f4 67 guint Num_Visible_Events;
68 guint First_Event, Last_Event;
fcdf0ec2 69
682c6edb 70 /* TEST DATA, TO BE READ FROM THE TRACE */
71 gint Number_Of_Events ;
72 guint Currently_Selected_Event ;
73 gboolean Selected_Event ;
74
fbbb2697 75} EventViewerData ;
76
77//! Event Viewer's constructor hook
e921c965 78GtkWidget *hGuiEvents(mainWindow *pmParentWindow);
5c7463ed 79//! Event Viewer's constructor
e921c965 80EventViewerData *GuiEvents(mainWindow *pmParentWindow);
fbbb2697 81//! Event Viewer's destructor
82void GuiEvents_Destructor(EventViewerData *Event_Viewer_Data);
83
682c6edb 84static int Event_Selected_Hook(void *hook_data, void *call_data);
85
86void Tree_V_set_cursor(EventViewerData *Event_Viewer_Data);
87void Tree_V_get_cursor(EventViewerData *Event_Viewer_Data);
88
fbbb2697 89/* Prototype for selection handler callback */
90static void tree_selection_changed_cb (GtkTreeSelection *selection, gpointer data);
91static void v_scroll_cb (GtkAdjustment *adjustment, gpointer data);
92static void Tree_V_size_allocate_cb (GtkWidget *widget, GtkAllocation *alloc, gpointer data);
93static void Tree_V_size_request_cb (GtkWidget *widget, GtkRequisition *requisition, gpointer data);
b26121f4 94static void Tree_V_cursor_changed_cb (GtkWidget *widget, gpointer data);
95static void Tree_V_move_cursor_cb (GtkWidget *widget, GtkMovementStep arg1, gint arg2, gpointer data);
fbbb2697 96
682c6edb 97
98
b26121f4 99static void get_test_data(guint Event_Number, guint List_Height,
100 EventViewerData *Event_Viewer_Data);
fbbb2697 101
102void add_test_data(EventViewerData *Event_Viewer_Data);
103
5c7463ed 104/**
105 * plugin's init function
106 *
107 * This function initializes the Event Viewer functionnality through the
108 * gtkTraceSet API.
109 */
110G_MODULE_EXPORT void init() {
111 g_critical("GUI Event Viewer init()");
112
113 /* Register the toolbar insert button */
e921c965 114 ToolbarItemReg(hGuiEventsInsert_xpm, "Insert Event Viewer", hGuiEvents);
5c7463ed 115
116 /* Register the menu item insert entry */
e921c965 117 MenuItemReg("/", "Insert Event Viewer", hGuiEvents);
fbbb2697 118}
5c7463ed 119
fbbb2697 120void destroy_walk(gpointer data, gpointer user_data)
121{
122 GuiEvents_Destructor((EventViewerData*)data);
5c7463ed 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 */
131G_MODULE_EXPORT void destroy() {
fcdf0ec2 132 int i;
fbbb2697 133
134 EventViewerData *Event_Viewer_Data;
fcdf0ec2 135
5c7463ed 136 g_critical("GUI Event Viewer destroy()");
137
fbbb2697 138 g_slist_foreach(sEvent_Viewer_Data_List, destroy_walk, NULL );
fcdf0ec2 139
5c7463ed 140 /* Unregister the toolbar insert button */
e921c965 141 ToolbarItemUnreg(hGuiEvents);
5c7463ed 142
143 /* Unregister the menu item insert entry */
e921c965 144 MenuItemUnreg(hGuiEvents);
5c7463ed 145}
146
fbbb2697 147/* Enumeration of the columns */
148enum
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
5c7463ed 160/**
fbbb2697 161 * Event Viewer's constructor hook
5c7463ed 162 *
163 * This constructor is given as a parameter to the menuitem and toolbar button
fbbb2697 164 * registration. It creates the list.
165 * @param pmParentWindow A pointer to the parent window.
5c7463ed 166 * @return The widget created.
167 */
fbbb2697 168GtkWidget *
e921c965 169hGuiEvents(mainWindow * pmParentWindow)
fbbb2697 170{
e921c965 171 EventViewerData* Event_Viewer_Data = GuiEvents(pmParentWindow) ;
fbbb2697 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 */
183EventViewerData *
e921c965 184GuiEvents(mainWindow *pmParentWindow)
5c7463ed 185{
fbbb2697 186 GtkTreeViewColumn *column;
187 GtkCellRenderer *renderer;
188 EventViewerData* Event_Viewer_Data = g_new(EventViewerData,1) ;
e921c965 189
190 Event_Viewer_Data->mw = pmParentWindow;
b26121f4 191
682c6edb 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
f60d7a47 197 /* FIXME register Event_Selected_Hook */
b26121f4 198
fbbb2697 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));
b26121f4 210
fbbb2697 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
b26121f4 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);
fbbb2697 221
b26121f4 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);
fbbb2697 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));
fcdf0ec2 231
232
fbbb2697 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
fbbb2697 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),
b26121f4 295 Event_Viewer_Data);
fbbb2697 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);
fcdf0ec2 299
300 /* Create vertical scrollbar and pack it */
fbbb2697 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
fcdf0ec2 304 /* Get the vertical scrollbar's adjustment */
fbbb2697 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;
682c6edb 314 Event_Viewer_Data->VAdjust_C->upper = Event_Viewer_Data->Number_Of_Events;
fbbb2697 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;
fbbb2697 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 */
e921c965 328 sEvent_Viewer_Data_List = g_slist_append(sEvent_Viewer_Data_List, Event_Viewer_Data);
fbbb2697 329
b26121f4 330 Event_Viewer_Data->First_Event = -1 ;
331 Event_Viewer_Data->Last_Event = 0 ;
332
333 Event_Viewer_Data->Num_Visible_Events = 1;
334
fbbb2697 335 /* Test data */
b26121f4 336 get_test_data((int)Event_Viewer_Data->VAdjust_C->value,
337 Event_Viewer_Data->Num_Visible_Events,
338 Event_Viewer_Data);
fbbb2697 339
682c6edb 340 /* Set the Selected Event */
341 Tree_V_set_cursor(Event_Viewer_Data);
342
fbbb2697 343 return Event_Viewer_Data;
344}
fcdf0ec2 345
682c6edb 346void 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
365void 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
b26121f4 391void Tree_V_move_cursor_cb (GtkWidget *widget, GtkMovementStep arg1, gint arg2, gpointer data)
fbbb2697 392{
b26121f4 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 {
682c6edb 420 if(value + Event_Viewer_Data->Num_Visible_Events <=
421 Event_Viewer_Data->Number_Of_Events -1)
b26121f4 422 {
423 g_critical("need 1 event down") ;
682c6edb 424 Event_Viewer_Data->Currently_Selected_Event += 1;
b26121f4 425 gtk_adjustment_set_value(Event_Viewer_Data->VAdjust_C, value+1);
682c6edb 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);
b26121f4 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") ;
682c6edb 439 Event_Viewer_Data->Currently_Selected_Event -= 1;
b26121f4 440 gtk_adjustment_set_value(Event_Viewer_Data->VAdjust_C, value-1);
682c6edb 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);
b26121f4 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 */
682c6edb 460 if(value + Event_Viewer_Data->Num_Visible_Events-1 <=
461 Event_Viewer_Data->Number_Of_Events )
b26121f4 462 {
463 g_critical("need 1 page down") ;
464
682c6edb 465 Event_Viewer_Data->Currently_Selected_Event += Event_Viewer_Data->Num_Visible_Events-1;
b26121f4 466 gtk_adjustment_set_value(Event_Viewer_Data->VAdjust_C,
467 value+(Event_Viewer_Data->Num_Visible_Events-1));
682c6edb 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);
b26121f4 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
682c6edb 484 Event_Viewer_Data->Currently_Selected_Event -= Event_Viewer_Data->Num_Visible_Events-1;
b26121f4 485
486 gtk_adjustment_set_value(Event_Viewer_Data->VAdjust_C,
487 value-(Event_Viewer_Data->Num_Visible_Events-1));
682c6edb 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);
b26121f4 503 g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
504
505 }
506 }
682c6edb 507
b26121f4 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") ;
682c6edb 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);
b26121f4 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") ;
682c6edb 530 Event_Viewer_Data->Currently_Selected_Event = 0 ;
b26121f4 531 gtk_adjustment_set_value(Event_Viewer_Data->VAdjust_C, 0);
682c6edb 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);
b26121f4 535 g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
536 }
537
538 }
539
fbbb2697 540
b26121f4 541 gtk_tree_path_free(path);
b26121f4 542}
543
544void Tree_V_cursor_changed_cb (GtkWidget *widget, gpointer data)
545{
682c6edb 546 EventViewerData *Event_Viewer_Data = (EventViewerData*) data;
b26121f4 547
682c6edb 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);
b26121f4 552}
553
554
555void v_scroll_cb (GtkAdjustment *adjustment, gpointer data)
556{
557 EventViewerData *Event_Viewer_Data = (EventViewerData*)data;
682c6edb 558 GtkTreePath *Tree_Path;
559
b26121f4 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
682c6edb 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
fbbb2697 586}
fcdf0ec2 587
6601bf27 588gint 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
b26121f4 595 gtk_tree_view_column_cell_get_size(Column, NULL, NULL, NULL, NULL, &height);
596 g_critical("cell 0 height : %u",height);
6601bf27 597
598 return height;
599}
600
fbbb2697 601void Tree_V_size_allocate_cb (GtkWidget *widget, GtkAllocation *alloc, gpointer data)
602{
603 EventViewerData *Event_Viewer_Data = (EventViewerData*)data;
6601bf27 604 gint Cell_Height = get_cell_height(GTK_TREE_VIEW(Event_Viewer_Data->Tree_V));
b26121f4 605 gint Last_Num_Visible_Events = Event_Viewer_Data->Num_Visible_Events;
606 gdouble Exact_Num_Visible;
607
fbbb2697 608 g_critical("size-allocate");
fcdf0ec2 609
b26121f4 610 Exact_Num_Visible = ( alloc->height -
6601bf27 611 TREE_VIEW_HEADER_HEIGHT (GTK_TREE_VIEW(Event_Viewer_Data->Tree_V)) )
b26121f4 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);
6601bf27 618
619 Event_Viewer_Data->VAdjust_C->page_increment =
b26121f4 620 floor(Exact_Num_Visible);
6601bf27 621 Event_Viewer_Data->VAdjust_C->page_size =
b26121f4 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
6601bf27 631
fbbb2697 632}
633
634void Tree_V_size_request_cb (GtkWidget *widget, GtkRequisition *requisition, gpointer data)
635{
6601bf27 636 gint h;
fbbb2697 637 EventViewerData *Event_Viewer_Data = (EventViewerData*)data;
6601bf27 638 gint Cell_Height = get_cell_height(GTK_TREE_VIEW(Event_Viewer_Data->Tree_V));
fbbb2697 639
640 g_critical("size-request");
641
6601bf27 642 h = Cell_Height + TREE_VIEW_HEADER_HEIGHT
643 (GTK_TREE_VIEW(Event_Viewer_Data->Tree_V));
644 requisition->height = h;
fbbb2697 645
fcdf0ec2 646}
647
b26121f4 648void 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 {
682c6edb 665 if(i>=Event_Viewer_Data->Number_Of_Events) break;
b26121f4 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 {
682c6edb 698 if(i>=Event_Viewer_Data->Number_Of_Events) break;
b26121f4 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 {
682c6edb 720 if(i>=Event_Viewer_Data->Number_Of_Events) break;
b26121f4 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
682c6edb 739
740
b26121f4 741}
742
fbbb2697 743
744void add_test_data(EventViewerData *Event_Viewer_Data)
fcdf0ec2 745{
fbbb2697 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
fcdf0ec2 765
fbbb2697 766void
767GuiEvents_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);
e921c965 783 g_free(Event_Viewer_Data);
fcdf0ec2 784}
785
fbbb2697 786//FIXME : call hGuiEvents_Destructor for corresponding data upon widget destroy
787
788static void
789tree_selection_changed_cb (GtkTreeSelection *selection, gpointer data)
790{
b26121f4 791 EventViewerData *Event_Viewer_Data = (EventViewerData*)data;
fbbb2697 792 GtkTreeIter iter;
b26121f4 793 GtkTreeModel *model = GTK_TREE_MODEL(Event_Viewer_Data->Store_M);
fbbb2697 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}
fcdf0ec2 805
fcdf0ec2 806
e921c965 807/* it will be registered and called by the main window */
682c6edb 808int 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
fbbb2697 827
828/* Imported code from LTT 0.9.6pre2 tracevisualizer */
829#ifdef DEBUG
830
fcdf0ec2 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 ******************************************************************/
fbbb2697 845static void WDI_gtk_clist_set_last_row_data_full(GtkCList* pmClist,
fcdf0ec2 846 gpointer pmData,
847 GtkDestroyNotify pmDestroy)
848{
849 GtkCListRow *pClistRow;
5c7463ed 850
fcdf0ec2 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);
5c7463ed 854
fcdf0ec2 855 pClistRow = pmClist->row_list_end->data;
856 pClistRow->data = pmData;
857 pClistRow->destroy = pmDestroy;
5c7463ed 858}
859
860
fcdf0ec2 861/******************************************************************
862 * Function :
863 * SHRTEventSelect()
864 * Description :
865 * Parameters :
866 * Return values :
867 * History :
868 * Note :
869 ******************************************************************/
fbbb2697 870static void SHRTEventSelect(GtkWidget* pmCList,
fcdf0ec2 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 ******************************************************************/
fbbb2697 896static void SHRTEventButtonPress(GtkWidget* pmCList,
fcdf0ec2 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 ******************************************************************/
fbbb2697 936static void SHRTVAdjustValueChanged(GtkAdjustment* pmVAdjust,
fcdf0ec2 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 ******************************************************************/
fbbb2697 1014static void WDConnectSignals(systemView* pmSysView)
fcdf0ec2 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 ******************************************************************/
fbbb2697 1061static void WDFillEventList(GtkWidget* pmList,
fcdf0ec2 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
fbbb2697 1181#endif //DEBUG
1182
1183static void destroy_cb( GtkWidget *widget,
1184 gpointer data )
1185{
1186 gtk_main_quit ();
1187}
1188
1189
e921c965 1190/*
fbbb2697 1191int main(int argc, char **argv)
1192{
1193 GtkWidget *Window;
1194 GtkWidget *ListViewer;
1195 GtkWidget *VBox_V;
1196 EventViewerData *Event_Viewer_Data;
682c6edb 1197 guint ev_sel = 444 ;
1198
e921c965 1199 // Initialize i18n support
fbbb2697 1200 gtk_set_locale ();
1201
e921c965 1202 // Initialize the widget set
fbbb2697 1203 gtk_init (&argc, &argv);
1204
1205 init();
fcdf0ec2 1206
fbbb2697 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
e921c965 1217 //ListViewer = hGuiEvents(Window);
682c6edb 1218 //gtk_box_pack_start(GTK_BOX(VBox_V), ListViewer, TRUE, TRUE, 0);
fbbb2697 1219
6601bf27 1220 //ListViewer = hGuiEvents(Window);
1221 //gtk_box_pack_start(GTK_BOX(VBox_V), ListViewer, FALSE, TRUE, 0);
682c6edb 1222
e921c965 1223 Event_Viewer_Data = GuiEvents(g_new(mainWindow,1));
682c6edb 1224 ListViewer = Event_Viewer_Data->HBox_V;
e921c965 1225 gtk_box_pack_start(GTK_BOX(VBox_V), ListViewer, TRUE, TRUE, 0);
1226
fbbb2697 1227 gtk_widget_show (VBox_V);
1228 gtk_widget_show (Window);
1229
e921c965 1230 // Event_Selected_Hook(Event_Viewer_Data, &ev_sel);
682c6edb 1231
fbbb2697 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}
e921c965 1243*/
17abcce3 1244
5c7463ed 1245/*\@}*/
fbbb2697 1246
LTTng 2.x Viewer (LTTV)
This page took 0.076713 seconds and 4 git commands to generate.