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 *g_event_viewer_data_list = NULL ;
  56
  57 /** hook functions for update time interval, current time ... */
  58 gboolean update_time_window(void * hook_data, void * call_data);
  59 gboolean update_current_time(void * hook_data, void * call_data);
  60 void remove_item_from_queue(GQueue * q, gboolean fromHead);
  61 void remove_all_items_from_queue(GQueue * q);
  62
  63 typedef struct _RawTraceData{
  64   unsigned  cpu_id;
  65   char * event_name;
  66   LttTime time;
  67   int pid;
  68   unsigned entry_length;
  69   char * event_description;
  70   LttEventPosition ep;
  71 } RawTraceData;
  72
  73 #define RESERVE_BIG_SIZE      1000
  74 #define RESERVE_SMALL_SIZE    100
  75
  76 typedef enum _ScrollDirection{
  77   SCROLL_STEP_UP,
  78   SCROLL_STEP_DOWN,
  79   SCROLL_PAGE_UP,
  80   SCROLL_PAGE_DOWN,
  81   SCROLL_JUMP,
  82   SCROLL_NONE
  83 } ScrollDirection;
  84
  85 typedef struct _EventViewerData {
  86
  87   MainWindow * mw;
  88   TimeWindow   time_window;
  89   LttTime      current_time;
  90   LttvHooks  * before_event_hooks;
  91
  92   gboolean     append;                    //prepend or append item
  93   GQueue     * raw_trace_data_queue;      //buf to contain raw trace data
  94   GQueue     * raw_trace_data_queue_tmp;  //tmp buf to contain raw data
  95   unsigned     current_event_index;
  96   double       previous_value;            //value of the slide
  97   TimeInterval time_span;
  98  // LttTime      trace_start;
  99  // LttTime      trace_end;
 100   unsigned     start_event_index;        //the first event shown in the window
 101   unsigned     end_event_index;          //the last event shown in the window
 102
 103   //scroll window containing Tree View
 104   GtkWidget * scroll_win;
 105
 106   /* Model containing list data */
 107   GtkListStore *store_m;
 108
 109   GtkWidget *hbox_v;
 110   /* Widget to display the data in a columned list */
 111   GtkWidget *tree_v;
 112   GtkAdjustment *vtree_adjust_c ;
 113
 114   /* Vertical scrollbar and it's adjustment */
 115   GtkWidget *vscroll_vc;
 116   GtkAdjustment *vadjust_c ;
 117
 118   /* Selection handler */
 119   GtkTreeSelection *select_c;
 120
 121   guint num_visible_events;
 122   guint first_event, last_event;
 123
 124   /* TEST DATA, TO BE READ FROM THE TRACE */
 125   gint number_of_events ;
 126   guint currently_selected_event  ;
 127   gboolean selected_event ;
 128
 129 } EventViewerData ;
 130
 131 //! Event Viewer's constructor hook
 132 GtkWidget *h_gui_events(MainWindow *parent_window);
 133 //! Event Viewer's constructor
 134 EventViewerData *gui_events(MainWindow *parent_window);
 135 //! Event Viewer's destructor
 136 void gui_events_destructor(EventViewerData *event_viewer_data);
 137 void gui_events_free(EventViewerData *event_viewer_data);
 138
 139 static int event_selected_hook(void *hook_data, void *call_data);
 140
 141 void tree_v_set_cursor(EventViewerData *event_viewer_data);
 142 void tree_v_get_cursor(EventViewerData *event_viewer_data);
 143
 144 /* Prototype for selection handler callback */
 145 static void tree_selection_changed_cb (GtkTreeSelection *selection, gpointer data);
 146 static void v_scroll_cb (GtkAdjustment *adjustment, gpointer data);
 147 static void tree_v_size_allocate_cb (GtkWidget *widget, GtkAllocation *alloc, gpointer data);
 148 static void tree_v_size_request_cb (GtkWidget *widget, GtkRequisition *requisition, gpointer data);
 149 static void tree_v_cursor_changed_cb (GtkWidget *widget, gpointer data);
 150 static void tree_v_move_cursor_cb (GtkWidget *widget, GtkMovementStep arg1, gint arg2, gpointer data);
 151 static void tree_v_grab_focus(GtkWidget *widget, gpointer data);
 152
 153
 154 static void get_test_data(double time, guint list_height,
 155                           EventViewerData *event_viewer_data);
 156
 157 void add_test_data(EventViewerData *event_viewer_data);
 158
 159 static void get_events(EventViewerData* event_viewer_data, LttTime start,
 160                        LttTime end, unsigned max_num_events, unsigned * real_num_events);
 161 static gboolean parse_event(void *hook_data, void *call_data);
 162
 163 static LttvModule *main_win_module;
 164
 165 /**
 166  * plugin's init function
 167  *
 168  * This function initializes the Event Viewer functionnality through the
 169  * gtkTraceSet API.
 170  */
 171 G_MODULE_EXPORT void init(LttvModule *self, int argc, char *argv[]) {
 172
 173   main_win_module = lttv_module_require(self, "mainwin", argc, argv);
 174
 175   if(main_win_module == NULL){
 176     g_critical("Can't load Control Flow Viewer : missing mainwin\n");
 177     return;
 178   }
 179
 180   /* Register the toolbar insert button */
 181   toolbar_item_reg(hGuiEventsInsert_xpm, "Insert Event Viewer", h_gui_events);
 182
 183   /* Register the menu item insert entry */
 184   menu_item_reg("/", "Insert Event Viewer", h_gui_events);
 185
 186 }
 187
 188 void event_destroy_walk(gpointer data, gpointer user_data)
 189 {
 190   gui_events_destructor((EventViewerData*)data);
 191 }
 192
 193 /**
 194  * plugin's destroy function
 195  *
 196  * This function releases the memory reserved by the module and unregisters
 197  * everything that has been registered in the gtkTraceSet API.
 198  */
 199 G_MODULE_EXPORT void destroy() {
 200   int i;
 201
 202   EventViewerData *event_viewer_data;
 203
 204   if(g_event_viewer_data_list){
 205     g_slist_foreach(g_event_viewer_data_list, event_destroy_walk, NULL );
 206     g_slist_free(g_event_viewer_data_list);
 207   }
 208
 209   /* Unregister the toolbar insert button */
 210   toolbar_item_unreg(h_gui_events);
 211
 212   /* Unregister the menu item insert entry */
 213   menu_item_unreg(h_gui_events);
 214 }
 215
 216 /* Enumeration of the columns */
 217 enum
 218 {
 219   CPUID_COLUMN,
 220   EVENT_COLUMN,
 221   TIME_COLUMN,
 222   PID_COLUMN,
 223   ENTRY_LEN_COLUMN,
 224   EVENT_DESCR_COLUMN,
 225   N_COLUMNS
 226 };
 227
 228
 229 /**
 230  * Event Viewer's constructor hook
 231  *
 232  * This constructor is given as a parameter to the menuitem and toolbar button
 233  * registration. It creates the list.
 234  * @param parent_window A pointer to the parent window.
 235  * @return The widget created.
 236  */
 237 GtkWidget *
 238 h_gui_events(MainWindow * parent_window)
 239 {
 240   EventViewerData* event_viewer_data = gui_events(parent_window) ;
 241
 242   if(event_viewer_data)
 243     return event_viewer_data->hbox_v;
 244   else return NULL;
 245
 246 }
 247
 248 /**
 249  * Event Viewer's constructor
 250  *
 251  * This constructor is used to create EventViewerData data structure.
 252  * @return The Event viewer data created.
 253  */
 254 EventViewerData *
 255 gui_events(MainWindow *parent_window)
 256 {
 257   LttTime start, end;
 258   GtkTreeViewColumn *column;
 259   GtkCellRenderer *renderer;
 260   EventViewerData* event_viewer_data = g_new(EventViewerData,1) ;
 261   RawTraceData * data;
 262   unsigned size;
 263
 264   event_viewer_data->mw = parent_window;
 265   get_time_window(event_viewer_data->mw, &event_viewer_data->time_window);
 266   get_current_time(event_viewer_data->mw, &event_viewer_data->current_time);
 267
 268   event_viewer_data->before_event_hooks = lttv_hooks_new();
 269   lttv_hooks_add(event_viewer_data->before_event_hooks, parse_event, event_viewer_data);
 270
 271   event_viewer_data->raw_trace_data_queue     = g_queue_new();
 272   event_viewer_data->raw_trace_data_queue_tmp = g_queue_new();
 273
 274   reg_update_time_window(update_time_window,event_viewer_data, event_viewer_data->mw);
 275   reg_update_current_time(update_current_time,event_viewer_data, event_viewer_data->mw);
 276
 277   event_viewer_data->scroll_win = gtk_scrolled_window_new (NULL, NULL);
 278   gtk_widget_show ( event_viewer_data->scroll_win);
 279   gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(event_viewer_data->scroll_win),
 280                                  GTK_POLICY_AUTOMATIC, GTK_POLICY_NEVER);
 281
 282   /* TEST DATA, TO BE READ FROM THE TRACE */
 283   event_viewer_data->currently_selected_event = FALSE  ;
 284   event_viewer_data->selected_event = 0;
 285
 286   /* Create a model for storing the data list */
 287   event_viewer_data->store_m = gtk_list_store_new (
 288                 N_COLUMNS,      /* Total number of columns */
 289                 G_TYPE_INT,     /* CPUID                  */
 290                 G_TYPE_STRING,  /* Event                   */
 291                 G_TYPE_UINT64,  /* Time                    */
 292                 G_TYPE_INT,     /* PID                     */
 293                 G_TYPE_INT,     /* Entry length            */
 294                 G_TYPE_STRING); /* Event's description     */
 295
 296   /* Create the viewer widget for the columned list */
 297   event_viewer_data->tree_v = gtk_tree_view_new_with_model (GTK_TREE_MODEL (event_viewer_data->store_m));
 298
 299   g_signal_connect (G_OBJECT (event_viewer_data->tree_v), "size-allocate",
 300                     G_CALLBACK (tree_v_size_allocate_cb),
 301                     event_viewer_data);
 302   g_signal_connect (G_OBJECT (event_viewer_data->tree_v), "size-request",
 303                     G_CALLBACK (tree_v_size_request_cb),
 304                     event_viewer_data);
 305
 306   g_signal_connect (G_OBJECT (event_viewer_data->tree_v), "cursor-changed",
 307                     G_CALLBACK (tree_v_cursor_changed_cb),
 308                     event_viewer_data);
 309
 310   g_signal_connect (G_OBJECT (event_viewer_data->tree_v), "move-cursor",
 311                     G_CALLBACK (tree_v_move_cursor_cb),
 312                     event_viewer_data);
 313
 314   g_signal_connect (G_OBJECT (event_viewer_data->tree_v), "grab-focus",
 315                     G_CALLBACK (tree_v_grab_focus),
 316                     event_viewer_data);
 317
 318   // Use on each column!
 319   //gtk_tree_view_column_set_sizing(event_viewer_data->tree_v, GTK_TREE_VIEW_COLUMN_FIXED);
 320
 321   /* The view now holds a reference.  We can get rid of our own
 322    * reference */
 323   g_object_unref (G_OBJECT (event_viewer_data->store_m));
 324
 325
 326   /* Create a column, associating the "text" attribute of the
 327    * cell_renderer to the first column of the model */
 328   /* Columns alignment : 0.0 : Left    0.5 : Center   1.0 : Right */
 329   renderer = gtk_cell_renderer_text_new ();
 330   column = gtk_tree_view_column_new_with_attributes ("CPUID",
 331                                                      renderer,
 332                                                      "text", CPUID_COLUMN,
 333                                                      NULL);
 334   gtk_tree_view_column_set_alignment (column, 0.0);
 335   gtk_tree_view_column_set_fixed_width (column, 45);
 336   gtk_tree_view_append_column (GTK_TREE_VIEW (event_viewer_data->tree_v), column);
 337
 338   renderer = gtk_cell_renderer_text_new ();
 339   column = gtk_tree_view_column_new_with_attributes ("Event",
 340                                                      renderer,
 341                                                      "text", EVENT_COLUMN,
 342                                                      NULL);
 343   gtk_tree_view_column_set_alignment (column, 0.0);
 344   gtk_tree_view_column_set_fixed_width (column, 120);
 345   gtk_tree_view_append_column (GTK_TREE_VIEW (event_viewer_data->tree_v), column);
 346
 347   renderer = gtk_cell_renderer_text_new ();
 348   column = gtk_tree_view_column_new_with_attributes ("Time",
 349                                                      renderer,
 350                                                      "text", TIME_COLUMN,
 351                                                      NULL);
 352   gtk_tree_view_column_set_alignment (column, 1.0);
 353   gtk_tree_view_column_set_fixed_width (column, 120);
 354   gtk_tree_view_append_column (GTK_TREE_VIEW (event_viewer_data->tree_v), column);
 355
 356   renderer = gtk_cell_renderer_text_new ();
 357   column = gtk_tree_view_column_new_with_attributes ("PID",
 358                                                      renderer,
 359                                                      "text", PID_COLUMN,
 360                                                      NULL);
 361   gtk_tree_view_column_set_alignment (column, 1.0);
 362   gtk_tree_view_column_set_fixed_width (column, 45);
 363   gtk_tree_view_append_column (GTK_TREE_VIEW (event_viewer_data->tree_v), column);
 364
 365   renderer = gtk_cell_renderer_text_new ();
 366   column = gtk_tree_view_column_new_with_attributes ("Entry Length",
 367                                                      renderer,
 368                                                      "text", ENTRY_LEN_COLUMN,
 369                                                      NULL);
 370   gtk_tree_view_column_set_alignment (column, 1.0);
 371   gtk_tree_view_column_set_fixed_width (column, 60);
 372   gtk_tree_view_append_column (GTK_TREE_VIEW (event_viewer_data->tree_v), column);
 373
 374   renderer = gtk_cell_renderer_text_new ();
 375   column = gtk_tree_view_column_new_with_attributes ("Event's Description",
 376                                                      renderer,
 377                                                      "text", EVENT_DESCR_COLUMN,
 378                                                      NULL);
 379   gtk_tree_view_column_set_alignment (column, 0.0);
 380   gtk_tree_view_append_column (GTK_TREE_VIEW (event_viewer_data->tree_v), column);
 381
 382
 383   /* Setup the selection handler */
 384   event_viewer_data->select_c = gtk_tree_view_get_selection (GTK_TREE_VIEW (event_viewer_data->tree_v));
 385   gtk_tree_selection_set_mode (event_viewer_data->select_c, GTK_SELECTION_SINGLE);
 386   g_signal_connect (G_OBJECT (event_viewer_data->select_c), "changed",
 387                     G_CALLBACK (tree_selection_changed_cb),
 388                     event_viewer_data);
 389
 390   gtk_container_add (GTK_CONTAINER (event_viewer_data->scroll_win), event_viewer_data->tree_v);
 391
 392   event_viewer_data->hbox_v = gtk_hbox_new(0, 0);
 393   gtk_box_pack_start(GTK_BOX(event_viewer_data->hbox_v), event_viewer_data->scroll_win, TRUE, TRUE, 0);
 394
 395   /* Create vertical scrollbar and pack it */
 396   event_viewer_data->vscroll_vc = gtk_vscrollbar_new(NULL);
 397   gtk_range_set_update_policy (GTK_RANGE(event_viewer_data->vscroll_vc),
 398                                GTK_UPDATE_DISCONTINUOUS);
 399   gtk_box_pack_start(GTK_BOX(event_viewer_data->hbox_v), event_viewer_data->vscroll_vc, FALSE, TRUE, 0);
 400
 401   /* Get the vertical scrollbar's adjustment */
 402   event_viewer_data->vadjust_c = gtk_range_get_adjustment(GTK_RANGE(event_viewer_data->vscroll_vc));
 403   event_viewer_data->vtree_adjust_c = gtk_tree_view_get_vadjustment(
 404                                                                     GTK_TREE_VIEW (event_viewer_data->tree_v));
 405
 406   g_signal_connect (G_OBJECT (event_viewer_data->vadjust_c), "value-changed",
 407                     G_CALLBACK (v_scroll_cb),
 408                     event_viewer_data);
 409   /* Set the upper bound to the last event number */
 410   event_viewer_data->previous_value = 0;
 411   event_viewer_data->vadjust_c->lower = 0.0;
 412     //event_viewer_data->vadjust_c->upper = event_viewer_data->number_of_events;
 413   event_viewer_data->vadjust_c->value = 0.0;
 414   event_viewer_data->vadjust_c->step_increment = 1.0;
 415   event_viewer_data->vadjust_c->page_increment = 2.0;
 416     //  event_viewer_data->vtree_adjust_c->upper;
 417   event_viewer_data->vadjust_c->page_size = 2.0;
 418   //    event_viewer_data->vtree_adjust_c->upper;
 419   /*  Raw event trace */
 420   gtk_widget_show(event_viewer_data->hbox_v);
 421   gtk_widget_show(event_viewer_data->tree_v);
 422   gtk_widget_show(event_viewer_data->vscroll_vc);
 423
 424   /* Add the object's information to the module's array */
 425   g_event_viewer_data_list = g_slist_append(g_event_viewer_data_list, event_viewer_data);
 426
 427   event_viewer_data->first_event = -1 ;
 428   event_viewer_data->last_event = 0 ;
 429
 430   event_viewer_data->num_visible_events = 1;
 431
 432   //get the life span of the traceset and set the upper of the scroll bar
 433   get_traceset_time_span(event_viewer_data->mw, &event_viewer_data->time_span);
 434
 435   start = ltt_time_sub(event_viewer_data->time_span.endTime, event_viewer_data->time_span.startTime);
 436   event_viewer_data->vadjust_c->upper = ltt_time_to_double(start) * NANOSECONDS_PER_SECOND;
 437
 438   event_viewer_data->append = TRUE;
 439
 440   start.tv_sec = 0;
 441   start.tv_nsec = 0;
 442   end.tv_sec = G_MAXULONG;
 443   end.tv_nsec = G_MAXULONG;
 444
 445   get_events(event_viewer_data, start,end, RESERVE_SMALL_SIZE, &size);
 446
 447   event_viewer_data->start_event_index = 0;
 448   event_viewer_data->end_event_index   = event_viewer_data->num_visible_events - 1;
 449
 450   // Test data
 451   get_test_data(event_viewer_data->vadjust_c->value,
 452                 event_viewer_data->num_visible_events,
 453                 event_viewer_data);
 454
 455   /* Set the Selected Event */
 456   //  tree_v_set_cursor(event_viewer_data);
 457
 458
 459   g_object_set_data_full(
 460                         G_OBJECT(event_viewer_data->hbox_v),
 461                         "event_viewer_data",
 462                         event_viewer_data,
 463                         (GDestroyNotify)gui_events_free);
 464
 465   return event_viewer_data;
 466 }
 467
 468 void tree_v_set_cursor(EventViewerData *event_viewer_data)
 469 {
 470   GtkTreePath *path;
 471
 472   if(event_viewer_data->selected_event && event_viewer_data->first_event != -1)
 473     {
 474       //      gtk_adjustment_set_value(event_viewer_data->vadjust_c,
 475      //                        event_viewer_data->currently_selected_event);
 476
 477       path = gtk_tree_path_new_from_indices(
 478                                             event_viewer_data->currently_selected_event-
 479                                             event_viewer_data->first_event,
 480                                             -1);
 481
 482       gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), path, NULL, FALSE);
 483       gtk_tree_path_free(path);
 484     }
 485 }
 486
 487 void tree_v_get_cursor(EventViewerData *event_viewer_data)
 488 {
 489   GtkTreePath *path;
 490   gint *indices;
 491
 492   gtk_tree_view_get_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), &path, NULL);
 493   indices = gtk_tree_path_get_indices(path);
 494
 495   if(indices != NULL)
 496     {
 497       event_viewer_data->selected_event = TRUE;
 498       event_viewer_data->currently_selected_event =
 499         event_viewer_data->first_event + indices[0];
 500
 501     } else {
 502       event_viewer_data->selected_event = FALSE;
 503       event_viewer_data->currently_selected_event = 0;
 504     }
 505
 506   gtk_tree_path_free(path);
 507
 508 }
 509
 510
 511
 512 void tree_v_move_cursor_cb (GtkWidget *widget, GtkMovementStep arg1, gint arg2, gpointer data)
 513 {
 514   GtkTreePath *path; // = gtk_tree_path_new();
 515   gint *indices;
 516   gdouble value;
 517   EventViewerData *event_viewer_data = (EventViewerData*)data;
 518
 519   gtk_tree_view_get_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), &path, NULL);
 520   if(path == NULL)
 521     {
 522       /* No prior cursor, put it at beginning of page and let the execution do */
 523       path = gtk_tree_path_new_from_indices(0, -1);
 524       gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), path, NULL, FALSE);
 525     }
 526
 527   indices = gtk_tree_path_get_indices(path);
 528
 529   value = gtk_adjustment_get_value(event_viewer_data->vadjust_c);
 530
 531   if(arg1 == GTK_MOVEMENT_DISPLAY_LINES)
 532     {
 533       /* Move one line */
 534       if(arg2 == 1)
 535         {
 536           /* move one line down */
 537           if(indices[0] == event_viewer_data->num_visible_events - 1)
 538             {
 539               if(value + event_viewer_data->num_visible_events <=
 540                  event_viewer_data->number_of_events -1)
 541                 {
 542                   event_viewer_data->currently_selected_event += 1;
 543                   //              gtk_adjustment_set_value(event_viewer_data->vadjust_c, value+1);
 544                   //gtk_tree_path_free(path);
 545                   //path = gtk_tree_path_new_from_indices(event_viewer_data->num_visible_events-1, -1);
 546                   //gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), path, NULL, FALSE);
 547                   g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
 548                 }
 549             }
 550         } else {
 551           /* Move one line up */
 552           if(indices[0] == 0)
 553             {
 554               if(value - 1 >= 0 )
 555                 {
 556                   event_viewer_data->currently_selected_event -= 1;
 557                   //              gtk_adjustment_set_value(event_viewer_data->vadjust_c, value-1);
 558                   //gtk_tree_path_free(path);
 559                   //path = gtk_tree_path_new_from_indices(0, -1);
 560                   //gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), path, NULL, FALSE);
 561                   g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
 562                 }
 563
 564             }
 565         }
 566
 567     }
 568
 569   if(arg1 == GTK_MOVEMENT_PAGES)
 570     {
 571       /* Move one page */
 572       if(arg2 == 1)
 573         {
 574           if(event_viewer_data->num_visible_events == 1)
 575             value += 1 ;
 576           /* move one page down */
 577           if(value + event_viewer_data->num_visible_events-1 <=
 578              event_viewer_data->number_of_events )
 579             {
 580               event_viewer_data->currently_selected_event += event_viewer_data->num_visible_events-1;
 581               //              gtk_adjustment_set_value(event_viewer_data->vadjust_c,
 582               //                                       value+(event_viewer_data->num_visible_events-1));
 583               //gtk_tree_path_free(path);
 584               //path = gtk_tree_path_new_from_indices(0, -1);
 585               //gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), path, NULL, FALSE);
 586               g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
 587             }
 588         } else {
 589           /* Move one page up */
 590           if(event_viewer_data->num_visible_events == 1)
 591             value -= 1 ;
 592
 593           if(indices[0] < event_viewer_data->num_visible_events - 2 )
 594             {
 595               if(value - (event_viewer_data->num_visible_events-1) >= 0)
 596                 {
 597                   event_viewer_data->currently_selected_event -= event_viewer_data->num_visible_events-1;
 598
 599                   //              gtk_adjustment_set_value(event_viewer_data->vadjust_c,
 600                   //                                       value-(event_viewer_data->num_visible_events-1));
 601                   //gtk_tree_path_free(path);
 602                   //path = gtk_tree_path_new_from_indices(0, -1);
 603                   //gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), path, NULL, FALSE);
 604                   g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
 605
 606                 } else {
 607                   /* Go to first Event */
 608                   event_viewer_data->currently_selected_event == 0 ;
 609                   //              gtk_adjustment_set_value(event_viewer_data->vadjust_c,
 610                   //                                       0);
 611                   //gtk_tree_path_free(path);
 612                   //path = gtk_tree_path_new_from_indices(0, -1);
 613                   //gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), path, NULL, FALSE);
 614                   g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
 615
 616                 }
 617             }
 618
 619         }
 620
 621     }
 622
 623   if(arg1 == GTK_MOVEMENT_BUFFER_ENDS)
 624     {
 625       /* Move to the ends of the buffer */
 626       if(arg2 == 1)
 627         {
 628           /* move end of buffer */
 629           event_viewer_data->currently_selected_event = event_viewer_data->number_of_events-1 ;
 630           //      gtk_adjustment_set_value(event_viewer_data->vadjust_c,
 631           //                               event_viewer_data->number_of_events -
 632           //                               event_viewer_data->num_visible_events);
 633           //gtk_tree_path_free(path);
 634           //path = gtk_tree_path_new_from_indices(event_viewer_data->num_visible_events-1, -1);
 635           //gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), path, NULL, FALSE);
 636           g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
 637         } else {
 638           /* Move beginning of buffer */
 639           event_viewer_data->currently_selected_event = 0 ;
 640           //      gtk_adjustment_set_value(event_viewer_data->vadjust_c, 0);
 641                         //gtk_tree_path_free(path);
 642                         //path = gtk_tree_path_new_from_indices(0, -1);
 643                         //gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), path, NULL, FALSE);
 644           g_signal_stop_emission_by_name(G_OBJECT(widget), "move-cursor");
 645         }
 646
 647     }
 648
 649
 650   gtk_tree_path_free(path);
 651 }
 652
 653 void tree_v_cursor_changed_cb (GtkWidget *widget, gpointer data)
 654 {
 655   EventViewerData *event_viewer_data = (EventViewerData*) data;
 656   LttTime ltt_time;
 657   guint64 time;
 658   GtkTreeIter iter;
 659   GtkTreeModel* model = GTK_TREE_MODEL(event_viewer_data->store_m);
 660   GtkTreePath *path;
 661
 662   /* On cursor change, modify the currently selected event by calling
 663    * the right API function */
 664   tree_v_get_cursor(event_viewer_data);
 665 /*
 666   gtk_tree_view_get_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), &path, NULL);
 667   if(gtk_tree_model_get_iter(model,&iter,path)){
 668     gtk_tree_model_get(model, &iter, TIME_COLUMN, &time, -1);
 669     ltt_time.tv_sec = time / NANOSECONDS_PER_SECOND;
 670     ltt_time.tv_nsec = time % NANOSECONDS_PER_SECOND;
 671
 672     if(ltt_time.tv_sec != event_viewer_data->current_time.tv_sec ||
 673        ltt_time.tv_nsec != event_viewer_data->current_time.tv_nsec)
 674       set_current_time(event_viewer_data->mw,&ltt_time);
 675   }else{
 676     g_warning("Can not get iter\n");
 677   }
 678 */
 679 }
 680
 681
 682 void v_scroll_cb (GtkAdjustment *adjustment, gpointer data)
 683 {
 684   EventViewerData *event_viewer_data = (EventViewerData*)data;
 685   GtkTreePath *tree_path;
 686
 687   get_test_data(adjustment->value, event_viewer_data->num_visible_events,
 688                 event_viewer_data);
 689
 690
 691   if(event_viewer_data->currently_selected_event
 692      >= event_viewer_data->first_event
 693      &&
 694      event_viewer_data->currently_selected_event
 695      <= event_viewer_data->last_event
 696      &&
 697      event_viewer_data->selected_event)
 698     {
 699
 700       tree_path = gtk_tree_path_new_from_indices(
 701                                                  event_viewer_data->currently_selected_event-
 702                                                  event_viewer_data->first_event,
 703                                                  -1);
 704
 705       //      gtk_tree_view_set_cursor(GTK_TREE_VIEW(event_viewer_data->tree_v), tree_path,
 706       //                               NULL, FALSE);
 707       gtk_tree_path_free(tree_path);
 708     }
 709
 710
 711 }
 712
 713 gint get_cell_height(GtkTreeView *TreeView)
 714 {
 715   gint height, width;
 716   GtkTreeViewColumn *column = gtk_tree_view_get_column(TreeView, 0);
 717   GList *Render_List = gtk_tree_view_column_get_cell_renderers(column);
 718   GtkCellRenderer *renderer = g_list_first(Render_List)->data;
 719
 720   gtk_tree_view_column_cell_get_size(column, NULL, NULL, NULL, NULL, &height);
 721
 722   return height;
 723 }
 724
 725 void tree_v_size_allocate_cb (GtkWidget *widget, GtkAllocation *alloc, gpointer data)
 726 {
 727   EventViewerData *event_viewer_data = (EventViewerData*)data;
 728   gint cell_height = get_cell_height(GTK_TREE_VIEW(event_viewer_data->tree_v));
 729   gint last_num_visible_events = event_viewer_data->num_visible_events;
 730   gdouble exact_num_visible;
 731
 732   exact_num_visible = ( alloc->height -
 733                         TREE_VIEW_HEADER_HEIGHT (GTK_TREE_VIEW(event_viewer_data->tree_v)) )
 734     / (double)cell_height ;
 735
 736   event_viewer_data->num_visible_events = ceil(exact_num_visible) ;
 737
 738 /*
 739   event_viewer_data->vadjust_c->page_increment =
 740     floor(exact_num_visible);
 741   event_viewer_data->vadjust_c->page_size =
 742     floor(exact_num_visible);
 743 */
 744
 745   if(event_viewer_data->num_visible_events != last_num_visible_events)
 746     {
 747       get_test_data(event_viewer_data->vadjust_c->value,
 748                     event_viewer_data->num_visible_events,
 749                     event_viewer_data);
 750     }
 751
 752
 753 }
 754
 755 void tree_v_size_request_cb (GtkWidget *widget, GtkRequisition *requisition, gpointer data)
 756 {
 757   gint h;
 758   EventViewerData *event_viewer_data = (EventViewerData*)data;
 759   gint cell_height = get_cell_height(GTK_TREE_VIEW(event_viewer_data->tree_v));
 760
 761   h = cell_height + TREE_VIEW_HEADER_HEIGHT
 762     (GTK_TREE_VIEW(event_viewer_data->tree_v));
 763   requisition->height = h;
 764
 765 }
 766
 767 void get_test_data(double time_value, guint list_height,
 768                    EventViewerData *event_viewer_data)
 769 {
 770   GtkTreeIter iter;
 771   int i;
 772   GtkTreeModel *model = GTK_TREE_MODEL(event_viewer_data->store_m);
 773   GtkTreePath *tree_path;
 774   RawTraceData * raw_data;
 775   ScrollDirection  direction = SCROLL_NONE;
 776   GList * first;
 777   int event_number;
 778   double value = event_viewer_data->previous_value - time_value;
 779   LttTime start, end, time;
 780   LttEvent * ev;
 781   unsigned backward_num, minNum, maxNum;
 782   LttTracefile * tf;
 783   unsigned  block_num, event_num;
 784   unsigned size = 1, count = 0;
 785   gboolean need_backward_again, backward;
 786   GdkWindow * win;
 787   GdkCursor * new;
 788   GtkWidget* widget = gtk_widget_get_parent(event_viewer_data->hbox_v);
 789
 790   if(widget){
 791     new = gdk_cursor_new(GDK_X_CURSOR);
 792     win = gtk_widget_get_parent_window(widget);
 793     gdk_window_set_cursor(win, new);
 794     gdk_cursor_unref(new);
 795     gdk_window_stick(win);
 796     gdk_window_unstick(win);
 797   }
 798
 799
 800   //    if(event_number > event_viewer_data->last_event ||
 801   //             event_number + list_height-1 < event_viewer_data->first_event ||
 802   //             event_viewer_data->first_event == -1)
 803   {
 804     /* no event can be reused, clear and start from nothing */
 805     if(value == -1.0)      direction = SCROLL_STEP_DOWN;
 806     else if(value == 1.0 ) direction = SCROLL_STEP_UP;
 807     else if(value == -2.0) direction = SCROLL_PAGE_DOWN;
 808     else if(value == 2.0 ) direction = SCROLL_PAGE_UP;
 809     else if(value == 0.0 ) direction = SCROLL_NONE;
 810     else direction = SCROLL_JUMP;
 811
 812     switch(direction){
 813       case SCROLL_STEP_UP:
 814       case SCROLL_PAGE_UP:
 815         if(direction == SCROLL_PAGE_UP){
 816           backward = list_height>event_viewer_data->start_event_index ? TRUE : FALSE;
 817         }else{
 818           backward = event_viewer_data->start_event_index == 0 ? TRUE : FALSE;
 819         }
 820         if(backward){
 821           event_viewer_data->append = FALSE;
 822           do{
 823             if(direction == SCROLL_PAGE_UP){
 824               minNum = list_height - event_viewer_data->start_event_index ;
 825             }else{
 826               minNum = 1;
 827             }
 828
 829             first = event_viewer_data->raw_trace_data_queue->head;
 830             raw_data = (RawTraceData*)g_list_nth_data(first,0);
 831             end = raw_data->time;
 832             end.tv_nsec--;
 833             ltt_event_position_get(&raw_data->ep, &block_num, &event_num, &tf);
 834             if(size !=0){
 835               if(event_num > minNum){
 836                 backward_num = event_num > RESERVE_SMALL_SIZE
 837                               ? event_num - RESERVE_SMALL_SIZE : 1;
 838                 ltt_event_position_set(&raw_data->ep, block_num, backward_num);
 839                 ltt_tracefile_seek_position(tf, &raw_data->ep);
 840                 ev = ltt_tracefile_read(tf);
 841                 start = ltt_event_time(ev);
 842                 maxNum = G_MAXULONG;
 843               }else{
 844                 if(block_num > 1){
 845                   ltt_event_position_set(&raw_data->ep, block_num-1, 1);
 846                   ltt_tracefile_seek_position(tf, &raw_data->ep);
 847                   ev = ltt_tracefile_read(tf);
 848                   start = ltt_event_time(ev);
 849                 }else{
 850                   start.tv_sec  = 0;
 851                   start.tv_nsec = 0;
 852                 }
 853                 maxNum = G_MAXULONG;
 854               }
 855             }else{
 856               if(block_num > count){
 857                 ltt_event_position_set(&raw_data->ep, block_num-count, 1);
 858                 ltt_tracefile_seek_position(tf, &raw_data->ep);
 859                 ev = ltt_tracefile_read(tf);
 860                 start = ltt_event_time(ev);
 861               }else{
 862                 start.tv_sec  = 0;
 863                 start.tv_nsec = 0;
 864               }
 865               maxNum = G_MAXULONG;
 866             }
 867
 868             event_viewer_data->current_event_index = event_viewer_data->start_event_index;
 869             get_events(event_viewer_data, start, end, maxNum, &size);
 870             event_viewer_data->start_event_index = event_viewer_data->current_event_index;
 871
 872             if(size < minNum && (start.tv_sec !=0 || start.tv_nsec !=0))
 873               need_backward_again = TRUE;
 874             else need_backward_again = FALSE;
 875             if(size == 0){
 876               count++;
 877             }else{
 878               count = 0;
 879             }
 880           }while(need_backward_again);
 881         }
 882         if(direction == SCROLL_STEP_UP)
 883           event_number = event_viewer_data->start_event_index - 1;
 884         else
 885           event_number = event_viewer_data->start_event_index - list_height;
 886         break;
 887       case SCROLL_STEP_DOWN:
 888         if(event_viewer_data->end_event_index == event_viewer_data->number_of_events - 1){
 889           event_viewer_data->append = TRUE;
 890           first = event_viewer_data->raw_trace_data_queue->head;
 891           raw_data = (RawTraceData*)g_list_nth_data(first,event_viewer_data->number_of_events - 1);
 892           start = raw_data->time;
 893           start.tv_nsec++;
 894           end.tv_sec = G_MAXULONG;
 895           end.tv_nsec = G_MAXULONG;
 896           get_events(event_viewer_data, start, end, RESERVE_SMALL_SIZE, &size);
 897         }else size = 1;
 898         if(size > 0) event_number = event_viewer_data->start_event_index + 1;
 899         else         event_number = event_viewer_data->start_event_index;
 900         break;
 901       case SCROLL_PAGE_DOWN:
 902         if(event_viewer_data->end_event_index >= event_viewer_data->number_of_events - 1 - list_height){
 903           event_viewer_data->append = TRUE;
 904           first = event_viewer_data->raw_trace_data_queue->head;
 905           raw_data = (RawTraceData*)g_list_nth_data(first,event_viewer_data->number_of_events - 1);
 906           start = raw_data->time;
 907           start.tv_nsec++;
 908           end.tv_sec = G_MAXULONG;
 909           end.tv_nsec = G_MAXULONG;
 910           get_events(event_viewer_data, start, end, RESERVE_SMALL_SIZE,&size);
 911         }
 912         if(list_height <= event_viewer_data->number_of_events - 1 - event_viewer_data->end_event_index)
 913           event_number = event_viewer_data->start_event_index + list_height - 1;
 914         else
 915           event_number = event_viewer_data->number_of_events - 1 - list_height;
 916         break;
 917       case SCROLL_JUMP:
 918         event_viewer_data->append = TRUE;
 919         remove_all_items_from_queue(event_viewer_data->raw_trace_data_queue);
 920         end.tv_sec = G_MAXULONG;
 921         end.tv_nsec = G_MAXULONG;
 922         time = ltt_time_from_double(time_value / NANOSECONDS_PER_SECOND);
 923         start = ltt_time_add(event_viewer_data->time_span.startTime, time);
 924         event_viewer_data->previous_value = time_value;
 925         get_events(event_viewer_data, start, end, RESERVE_SMALL_SIZE,&size);
 926         if(size < list_height){
 927           event_viewer_data->append = FALSE;
 928           first = event_viewer_data->raw_trace_data_queue->head;
 929           raw_data = (RawTraceData*)g_list_nth_data(first,0);
 930           end = raw_data->time;
 931           end.tv_nsec--;
 932           ltt_event_position_get(&raw_data->ep, &block_num, &event_num, &tf);
 933
 934           if(event_num > list_height - size){
 935             backward_num = event_num > RESERVE_SMALL_SIZE
 936               ? event_num - RESERVE_SMALL_SIZE : 1;
 937             ltt_event_position_set(&raw_data->ep, block_num, backward_num);
 938             ltt_tracefile_seek_position(tf, &raw_data->ep);
 939             ev = ltt_tracefile_read(tf);
 940             start = ltt_event_time(ev);
 941             maxNum = G_MAXULONG;
 942             event_viewer_data->current_event_index = 0;
 943             get_events(event_viewer_data, start, end, maxNum, &size);
 944             event_viewer_data->start_event_index = event_viewer_data->current_event_index;
 945           }
 946           event_number = event_viewer_data->raw_trace_data_queue->length - list_height;
 947         }else{
 948           event_number = 0;
 949         }
 950         break;
 951       case SCROLL_NONE:
 952         event_number = event_viewer_data->current_event_index;
 953         break;
 954       default:
 955           break;
 956     }
 957
 958     //update the value of the scroll bar
 959     if(direction != SCROLL_NONE && direction != SCROLL_JUMP){
 960       first = event_viewer_data->raw_trace_data_queue->head;
 961       raw_data = (RawTraceData*)g_list_nth_data(first,event_number);
 962       time = ltt_time_sub(raw_data->time, event_viewer_data->time_span.startTime);
 963       event_viewer_data->vadjust_c->value = ltt_time_to_double(time) * NANOSECONDS_PER_SECOND;
 964       g_signal_stop_emission_by_name(G_OBJECT(event_viewer_data->vadjust_c), "value-changed");
 965       event_viewer_data->previous_value = event_viewer_data->vadjust_c->value;
 966     }
 967
 968
 969     event_viewer_data->start_event_index = event_number;
 970     event_viewer_data->end_event_index = event_number + list_height - 1;
 971
 972     first = event_viewer_data->raw_trace_data_queue->head;
 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         raw_data = (RawTraceData*)g_list_nth_data(first, i);
 981
 982         // Add a new row to the model
 983         real_data = raw_data->time.tv_sec;
 984         real_data *= NANOSECONDS_PER_SECOND;
 985         real_data += raw_data->time.tv_nsec;
 986         gtk_list_store_append (event_viewer_data->store_m, &iter);
 987         gtk_list_store_set (event_viewer_data->store_m, &iter,
 988                             CPUID_COLUMN, raw_data->cpu_id,
 989                             EVENT_COLUMN, raw_data->event_name,
 990                             TIME_COLUMN, real_data,
 991                             PID_COLUMN, raw_data->pid,
 992                             ENTRY_LEN_COLUMN, raw_data->entry_length,
 993                             EVENT_DESCR_COLUMN, raw_data->event_description,
 994                             -1);
 995 /*
 996         gtk_list_store_append (event_viewer_data->store_m, &iter);
 997         gtk_list_store_set (event_viewer_data->store_m, &iter,
 998                             CPUID_COLUMN, 0,
 999                             EVENT_COLUMN, "event irq",
1000                             TIME_COLUMN, i,
1001                             PID_COLUMN, 100,
1002                             ENTRY_LEN_COLUMN, 17,
1003                             EVENT_DESCR_COLUMN, "Detailed information",
1004                             -1);
1005 */
1006       }
1007   }
1008 #ifdef DEBUG //do not use this, it's slower and broken
1009   //    } else {
1010   /* Some events will be reused */
1011   if(event_number < event_viewer_data->first_event)
1012     {
1013       /* scrolling up, prepend events */
1014       tree_path = gtk_tree_path_new_from_indices
1015         (event_number+list_height-1 -
1016          event_viewer_data->first_event + 1,
1017          -1);
1018       for(i=0; i<event_viewer_data->last_event-(event_number+list_height-1);
1019           i++)
1020         {
1021           /* Remove the last events from the list */
1022           if(gtk_tree_model_get_iter(model, &iter, tree_path))
1023             gtk_list_store_remove(event_viewer_data->store_m, &iter);
1024         }
1025
1026       for(i=event_viewer_data->first_event-1; i>=event_number; i--)
1027         {
1028           if(i>=event_viewer_data->number_of_events) break;
1029           /* Prepend new events */
1030           gtk_list_store_prepend (event_viewer_data->store_m, &iter);
1031           gtk_list_store_set (event_viewer_data->store_m, &iter,
1032                               CPUID_COLUMN, 0,
1033                               EVENT_COLUMN, "event irq",
1034                               TIME_COLUMN, i,
1035                               PID_COLUMN, 100,
1036                               ENTRY_LEN_COLUMN, 17,
1037                               EVENT_DESCR_COLUMN, "Detailed information",
1038                               -1);
1039         }
1040     } else {
1041       /* Scrolling down, append events */
1042       for(i=event_viewer_data->first_event; i<event_number; i++)
1043         {
1044           /* Remove these events from the list */
1045           gtk_tree_model_get_iter_first(model, &iter);
1046           gtk_list_store_remove(event_viewer_data->store_m, &iter);
1047         }
1048       for(i=event_viewer_data->last_event+1; i<event_number+list_height; i++)
1049         {
1050           if(i>=event_viewer_data->number_of_events) break;
1051           /* Append new events */
1052           gtk_list_store_append (event_viewer_data->store_m, &iter);
1053           gtk_list_store_set (event_viewer_data->store_m, &iter,
1054                               CPUID_COLUMN, 0,
1055                               EVENT_COLUMN, "event irq",
1056                               TIME_COLUMN, i,
1057                               PID_COLUMN, 100,
1058                               ENTRY_LEN_COLUMN, 17,
1059                               EVENT_DESCR_COLUMN, "Detailed information",
1060                               -1);
1061         }
1062
1063     }
1064   //}
1065 #endif //DEBUG
1066   event_viewer_data->first_event = event_viewer_data->start_event_index ;
1067   event_viewer_data->last_event = event_viewer_data->end_event_index ;
1068
1069   if(widget)
1070      gdk_window_set_cursor(win, NULL);
1071
1072 }
1073
1074
1075 void add_test_data(EventViewerData *event_viewer_data)
1076 {
1077   GtkTreeIter iter;
1078   int i;
1079
1080   for(i=0; i<10; i++)
1081     {
1082       /* Add a new row to the model */
1083       gtk_list_store_append (event_viewer_data->store_m, &iter);
1084       gtk_list_store_set (event_viewer_data->store_m, &iter,
1085                           CPUID_COLUMN, 0,
1086                           EVENT_COLUMN, "event irq",
1087                           TIME_COLUMN, i,
1088                           PID_COLUMN, 100,
1089                           ENTRY_LEN_COLUMN, 17,
1090                           EVENT_DESCR_COLUMN, "Detailed information",
1091                           -1);
1092     }
1093
1094 }
1095
1096 void
1097 gui_events_free(EventViewerData *event_viewer_data)
1098 {
1099   if(event_viewer_data){
1100     lttv_hooks_remove(event_viewer_data->before_event_hooks,parse_event);
1101     lttv_hooks_destroy(event_viewer_data->before_event_hooks);
1102
1103     remove_all_items_from_queue (event_viewer_data->raw_trace_data_queue);
1104     g_queue_free(event_viewer_data->raw_trace_data_queue);
1105     g_queue_free(event_viewer_data->raw_trace_data_queue_tmp);
1106
1107     unreg_update_time_window(update_time_window,event_viewer_data, event_viewer_data->mw);
1108     unreg_update_current_time(update_current_time,event_viewer_data, event_viewer_data->mw);
1109
1110     g_event_viewer_data_list = g_slist_remove(g_event_viewer_data_list, event_viewer_data);
1111     g_free(event_viewer_data);
1112   }
1113 }
1114
1115 void
1116 gui_events_destructor(EventViewerData *event_viewer_data)
1117 {
1118   guint index;
1119
1120   /* May already been done by GTK window closing */
1121   if(GTK_IS_WIDGET(event_viewer_data->hbox_v)){
1122     gtk_widget_destroy(event_viewer_data->hbox_v);
1123     event_viewer_data = NULL;
1124   }
1125
1126   /* Destroy the Tree View */
1127   //gtk_widget_destroy(event_viewer_data->tree_v);
1128
1129   /*  Clear raw event list */
1130   //gtk_list_store_clear(event_viewer_data->store_m);
1131   //gtk_widget_destroy(GTK_WIDGET(event_viewer_data->store_m));
1132
1133   //gui_events_free(event_viewer_data);
1134 }
1135
1136 //FIXME : call hGuiEvents_Destructor for corresponding data upon widget destroy
1137
1138 static void
1139 tree_selection_changed_cb (GtkTreeSelection *selection, gpointer data)
1140 {
1141   EventViewerData *event_viewer_data = (EventViewerData*)data;
1142   GtkTreeIter iter;
1143   GtkTreeModel *model = GTK_TREE_MODEL(event_viewer_data->store_m);
1144   gchar *event;
1145
1146   if (gtk_tree_selection_get_selected (selection, &model, &iter))
1147     {
1148       gtk_tree_model_get (model, &iter, EVENT_COLUMN, &event, -1);
1149
1150       g_free (event);
1151     }
1152 }
1153
1154
1155 int event_selected_hook(void *hook_data, void *call_data)
1156 {
1157   EventViewerData *event_viewer_data = (EventViewerData*) hook_data;
1158   guint *event_number = (guint*) call_data;
1159
1160   event_viewer_data->currently_selected_event = *event_number;
1161   event_viewer_data->selected_event = TRUE ;
1162
1163   tree_v_set_cursor(event_viewer_data);
1164
1165 }
1166
1167
1168 gboolean update_time_window(void * hook_data, void * call_data)
1169 {
1170   EventViewerData *event_viewer_data = (EventViewerData*) hook_data;
1171   event_viewer_data->time_window = *(TimeWindow*)call_data;
1172
1173   return FALSE;
1174 }
1175
1176 gboolean update_current_time(void * hook_data, void * call_data)
1177 {
1178   EventViewerData *event_viewer_data = (EventViewerData*) hook_data;
1179   event_viewer_data->current_time = *(LttTime*)call_data;
1180   guint64 nsec = event_viewer_data->current_time.tv_sec * NANOSECONDS_PER_SECOND
1181                   + event_viewer_data->current_time.tv_nsec;
1182   GtkTreeIter iter;
1183   guint64 time;
1184   int count = 0;
1185   GtkTreeModel* model = (GtkTreeModel*)event_viewer_data->store_m;
1186
1187
1188   if(gtk_tree_model_get_iter_first(model, &iter)){
1189     while(1){
1190       gtk_tree_model_get(model, &iter, TIME_COLUMN, &time, -1);
1191       if(time < nsec){
1192         if(!gtk_tree_model_iter_next(model, &iter)){
1193           return TRUE;
1194         }
1195         count++;
1196       }else{
1197         break;
1198       }
1199     }
1200     //    event_selected_hook(event_viewer_data, &count);
1201   }
1202
1203   return FALSE;
1204 }
1205
1206 void tree_v_grab_focus(GtkWidget *widget, gpointer data){
1207   EventViewerData *event_viewer_data = (EventViewerData *)data;
1208   MainWindow * mw = event_viewer_data->mw;
1209   set_focused_pane(mw, gtk_widget_get_parent(event_viewer_data->hbox_v));
1210 }
1211
1212 void get_events(EventViewerData* event_viewer_data, LttTime start,
1213                 LttTime end,unsigned max_num_events, unsigned * real_num_events)
1214 {
1215   int size;
1216   RawTraceData * data;
1217   context_add_hooks_api(event_viewer_data->mw, NULL, NULL, NULL, NULL, NULL, NULL,
1218                         NULL, NULL, NULL,event_viewer_data->before_event_hooks,NULL);
1219   process_traceset_api(event_viewer_data->mw, start, end, max_num_events);
1220   context_remove_hooks_api(event_viewer_data->mw, NULL, NULL, NULL, NULL, NULL, NULL,
1221                            NULL, NULL, NULL,event_viewer_data->before_event_hooks,NULL);
1222
1223   size = event_viewer_data->raw_trace_data_queue_tmp->length;
1224   *real_num_events = size;
1225   if(size > 0){
1226     int pid, tmpPid, i;
1227     GList * list, *tmpList;
1228
1229     //if the queue is full, remove some data, keep the size of the queue constant
1230     while(event_viewer_data->raw_trace_data_queue->length + size > RESERVE_BIG_SIZE){
1231       remove_item_from_queue(event_viewer_data->raw_trace_data_queue,
1232                              event_viewer_data->append);
1233     }
1234
1235     //update pid if it is not known
1236     if(event_viewer_data->raw_trace_data_queue->length > 0){
1237       list    = event_viewer_data->raw_trace_data_queue->head;
1238       tmpList = event_viewer_data->raw_trace_data_queue_tmp->head;
1239       if(event_viewer_data->append){
1240         data = (RawTraceData*)g_list_nth_data(list, event_viewer_data->raw_trace_data_queue->length-1);
1241         pid  = data->pid;
1242         data = (RawTraceData*)g_list_nth_data(tmpList, 0);
1243         tmpPid = data->pid;
1244       }else{
1245         data = (RawTraceData*)g_list_nth_data(list, 0);
1246         pid  = data->pid;
1247         data = (RawTraceData*)g_list_nth_data(tmpList, event_viewer_data->raw_trace_data_queue_tmp->length-1);
1248         tmpPid = data->pid;
1249       }
1250
1251       if(pid == -1 && tmpPid != -1){
1252         for(i=0;i<event_viewer_data->raw_trace_data_queue->length;i++){
1253           data = (RawTraceData*)g_list_nth_data(list,i);
1254           if(data->pid == -1) data->pid = tmpPid;
1255         }
1256       }else if(pid != -1 && tmpPid == -1){
1257         for(i=0;i<event_viewer_data->raw_trace_data_queue_tmp->length;i++){
1258           data = (RawTraceData*)g_list_nth_data(tmpList,i);
1259           if(data->pid == -1) data->pid = pid;
1260         }
1261       }
1262     }
1263
1264     //add data from tmp queue into the queue
1265     event_viewer_data->number_of_events = event_viewer_data->raw_trace_data_queue->length
1266                                         + event_viewer_data->raw_trace_data_queue_tmp->length;
1267     if(event_viewer_data->append){
1268       if(event_viewer_data->raw_trace_data_queue->length > 0)
1269         event_viewer_data->current_event_index = event_viewer_data->raw_trace_data_queue->length - 1;
1270       else event_viewer_data->current_event_index = 0;
1271       while((data = g_queue_pop_head(event_viewer_data->raw_trace_data_queue_tmp)) != NULL){
1272         g_queue_push_tail(event_viewer_data->raw_trace_data_queue, data);
1273       }
1274     }else{
1275       event_viewer_data->current_event_index += event_viewer_data->raw_trace_data_queue_tmp->length;
1276       while((data = g_queue_pop_tail(event_viewer_data->raw_trace_data_queue_tmp)) != NULL){
1277         g_queue_push_head(event_viewer_data->raw_trace_data_queue, data);
1278       }
1279     }
1280   }
1281 }
1282
1283 static void get_event_detail(LttEvent *e, LttField *f, GString * s)
1284 {
1285   LttType *type;
1286   LttField *element;
1287   char *name;
1288   int nb, i;
1289
1290   type = ltt_field_type(f);
1291   switch(ltt_type_class(type)) {
1292     case LTT_INT:
1293       g_string_append_printf(s, " %ld", ltt_event_get_long_int(e,f));
1294       break;
1295
1296     case LTT_UINT:
1297       g_string_append_printf(s, " %lu", ltt_event_get_long_unsigned(e,f));
1298       break;
1299
1300     case LTT_FLOAT:
1301       g_string_append_printf(s, " %g", ltt_event_get_double(e,f));
1302       break;
1303
1304     case LTT_STRING:
1305       g_string_append_printf(s, " \"%s\"", ltt_event_get_string(e,f));
1306       break;
1307
1308     case LTT_ENUM:
1309       g_string_append_printf(s, " %s", ltt_enum_string_get(type,
1310           ltt_event_get_unsigned(e,f)-1));
1311       break;
1312
1313     case LTT_ARRAY:
1314     case LTT_SEQUENCE:
1315       g_string_append_printf(s, " {");
1316       nb = ltt_event_field_element_number(e,f);
1317       element = ltt_field_element(f);
1318       for(i = 0 ; i < nb ; i++) {
1319         ltt_event_field_element_select(e,f,i);
1320         get_event_detail(e, element, s);
1321       }
1322       g_string_append_printf(s, " }");
1323       break;
1324
1325     case LTT_STRUCT:
1326       g_string_append_printf(s, " {");
1327       nb = ltt_type_member_number(type);
1328       for(i = 0 ; i < nb ; i++) {
1329         element = ltt_field_member(f,i);
1330         ltt_type_member_type(type, i, &name);
1331         g_string_append_printf(s, " %s = ", name);
1332         get_event_detail(e, element, s);
1333       }
1334       g_string_append_printf(s, " }");
1335       break;
1336   }
1337
1338 }
1339
1340 static void get_pid(unsigned * in, unsigned * out, char * s)
1341 {
1342   char * str;
1343   str = strstr(s, "out =");
1344   if (str){
1345     str = str + 5;
1346     sscanf(str,"%d", out);
1347   }else{
1348     g_warning("Can not find out pid\n");
1349   }
1350
1351   str = strstr(s,"in =");
1352   if (str){
1353     str = str + 4;
1354     sscanf(str,"%d", in);
1355   }else{
1356     g_warning("Can not find in pid\n");
1357   }
1358 }
1359
1360 gboolean parse_event(void *hook_data, void *call_data)
1361 {
1362   EventViewerData *event_viewer_data = (EventViewerData *)hook_data;
1363   LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
1364   LttvTracefileState *tfs = (LttvTracefileState *)call_data;
1365
1366   RawTraceData * tmp_raw_trace_data,*prev_raw_trace_data = NULL, *data=NULL;
1367   LttEvent *e;
1368   LttTime time;
1369   LttField * field;
1370   unsigned in=0, out=0;
1371   int i;
1372   GString * detail_event = g_string_new("");
1373   GList * list;
1374
1375   e = tfc->e;
1376   field = ltt_event_field(e);
1377   time = ltt_event_time(e);
1378
1379   if(event_viewer_data->raw_trace_data_queue_tmp->length){
1380     list = g_list_last(event_viewer_data->raw_trace_data_queue_tmp->head);
1381     prev_raw_trace_data = (RawTraceData *)(list->data);
1382   }
1383
1384   tmp_raw_trace_data = g_new(RawTraceData,1);
1385   tmp_raw_trace_data->cpu_id = ltt_event_cpu_id(e);
1386   tmp_raw_trace_data->event_name = g_strdup(ltt_eventtype_name(ltt_event_eventtype(e)));
1387   tmp_raw_trace_data->time = time;
1388
1389   if(prev_raw_trace_data) tmp_raw_trace_data->pid = prev_raw_trace_data->pid;
1390   else tmp_raw_trace_data->pid = -1;
1391
1392   tmp_raw_trace_data->entry_length = field == NULL ? 0 : field->field_size;
1393   if(field) get_event_detail(e, field, detail_event);
1394   tmp_raw_trace_data->event_description  = g_strdup(detail_event->str);
1395
1396   if(strcmp(tmp_raw_trace_data->event_name, "schedchange") == 0){
1397     get_pid(&in, &out, detail_event->str);
1398   }
1399
1400
1401   if(in != 0 || out != 0){
1402     tmp_raw_trace_data->pid = in;
1403     if(prev_raw_trace_data && prev_raw_trace_data->pid == -1){
1404       list = event_viewer_data->raw_trace_data_queue_tmp->head;
1405       for(i=0;i<event_viewer_data->raw_trace_data_queue_tmp->length;i++){
1406         data = (RawTraceData *)g_list_nth_data(list,i);
1407         data->pid = out;
1408       }
1409     }
1410   }
1411
1412   ltt_event_position(e, &tmp_raw_trace_data->ep);
1413
1414   if(event_viewer_data->raw_trace_data_queue_tmp->length >= RESERVE_SMALL_SIZE){
1415     if(event_viewer_data->append){
1416       list = g_list_last(event_viewer_data->raw_trace_data_queue_tmp->head);
1417       data = (RawTraceData *)(list->data);
1418       if(data->time.tv_sec  == time.tv_sec &&
1419          data->time.tv_nsec == time.tv_nsec){
1420         g_queue_push_tail(event_viewer_data->raw_trace_data_queue_tmp,tmp_raw_trace_data);
1421       }else{
1422         g_free(tmp_raw_trace_data);
1423       }
1424     }else{
1425       remove_item_from_queue(event_viewer_data->raw_trace_data_queue_tmp,TRUE);
1426       g_queue_push_tail(event_viewer_data->raw_trace_data_queue_tmp,tmp_raw_trace_data);
1427     }
1428   }else{
1429     g_queue_push_tail (event_viewer_data->raw_trace_data_queue_tmp,tmp_raw_trace_data);
1430   }
1431
1432   g_string_free(detail_event, TRUE);
1433
1434   return FALSE;
1435 }
1436
1437 void remove_item_from_queue(GQueue * q, gboolean fromHead)
1438 {
1439   RawTraceData *data1, *data2 = NULL;
1440   GList * list;
1441
1442   if(fromHead){
1443     data1 = (RawTraceData *)g_queue_pop_head(q);
1444     list  = g_list_first(q->head);
1445     if(list)
1446       data2 = (RawTraceData *)(list->data);
1447   }else{
1448     data1 = (RawTraceData *)g_queue_pop_tail(q);
1449     list  = g_list_last(q->head);
1450     if(list)
1451       data2 = (RawTraceData *)(list->data);
1452   }
1453
1454   if(data2){
1455     if(data1->time.tv_sec  == data2->time.tv_sec &&
1456        data1->time.tv_nsec == data2->time.tv_nsec){
1457       remove_item_from_queue(q, fromHead);
1458     }
1459   }
1460
1461   g_free(data1);
1462
1463   return;
1464 }
1465
1466 void remove_all_items_from_queue(GQueue *q)
1467 {
1468   RawTraceData *data;
1469   while((data = (RawTraceData *)g_queue_pop_head(q)) != NULL){
1470     g_free(data);
1471   }
1472 }
1473
1474